OpInterfaces.h.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Interface Declarations                                                     *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
namespace llzk {
namespace pod {
class PodRefOpInterface;
namespace detail {
struct PodRefOpInterfaceInterfaceTraits {
  struct Concept {
    ::mlir::TypedValue<::llzk::pod::PodType> (*getPodRef)(const Concept *impl, ::mlir::Operation *);
    ::mlir::OpOperand &(*getPodRefMutable)(const Concept *impl, ::mlir::Operation *);
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::pod::PodRefOpInterface;
    Model() : Concept{getPodRef, getPodRefMutable} {}
 
    static inline ::mlir::TypedValue<::llzk::pod::PodType> getPodRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::OpOperand &getPodRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::pod::PodRefOpInterface;
    FallbackModel() : Concept{getPodRef, getPodRefMutable} {}
 
    static inline ::mlir::TypedValue<::llzk::pod::PodType> getPodRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::OpOperand &getPodRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
  };
};
template <typename ConcreteOp>
struct PodRefOpInterfaceTrait;
 
} // namespace detail
class PodRefOpInterface : public ::mlir::OpInterface<PodRefOpInterface, detail::PodRefOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<PodRefOpInterface, detail::PodRefOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::PodRefOpInterfaceTrait<ConcreteOp> {};
  ::mlir::TypedValue<::llzk::pod::PodType> getPodRef();
  ::mlir::OpOperand &getPodRefMutable();

    inline ::llzk::pod::PodType getPodRefType() { return getPodRef().getType(); }
};
namespace detail {
  template <typename ConcreteOp>
  struct PodRefOpInterfaceTrait : public ::mlir::OpInterface<PodRefOpInterface, detail::PodRefOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace pod
} // namespace llzk
namespace llzk {
namespace pod {
class PodAccessOpInterface;
namespace detail {
struct PodAccessOpInterfaceInterfaceTraits {
  struct Concept {
    ::mlir::FlatSymbolRefAttr (*getRecordNameAttr)(const Concept *impl, ::mlir::Operation *);
    bool (*isRead)(const Concept *impl, ::mlir::Operation *);
    const ::llzk::pod::PodRefOpInterface::Concept *implPodRefOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implPodRefOpInterface = interfaceMap.lookup<::llzk::pod::PodRefOpInterface>();
      assert(implPodRefOpInterface && "`::llzk::pod::PodAccessOpInterface` expected its base interface `::llzk::pod::PodRefOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::pod::PodAccessOpInterface;
    Model() : Concept{getRecordNameAttr, isRead} {}
 
    static inline ::mlir::FlatSymbolRefAttr getRecordNameAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline bool isRead(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::pod::PodAccessOpInterface;
    FallbackModel() : Concept{getRecordNameAttr, isRead} {}
 
    static inline ::mlir::FlatSymbolRefAttr getRecordNameAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline bool isRead(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
  };
};
template <typename ConcreteOp>
struct PodAccessOpInterfaceTrait;
 
} // namespace detail
class PodAccessOpInterface : public ::mlir::OpInterface<PodAccessOpInterface, detail::PodAccessOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<PodAccessOpInterface, detail::PodAccessOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::PodAccessOpInterfaceTrait<ConcreteOp> {};
  ::mlir::FlatSymbolRefAttr getRecordNameAttr();
  bool isRead();

    inline ::mlir::StringAttr getRecordNameAsStringAttr() {
      return getRecordNameAttr().getLeafReference();
    }

    bool canRewire(const ::mlir::DestructurableMemorySlot &slot,
            ::llvm::SmallPtrSetImpl<::mlir::Attribute> &usedIndices,
            ::mlir::SmallVectorImpl<::mlir::MemorySlot> &mustBeSafelyUsed,
            const ::mlir::DataLayout &dataLayout);

    ::mlir::DeletionKind rewire(const ::mlir::DestructurableMemorySlot &slot,
            ::llvm::DenseMap<::mlir::Attribute, ::mlir::MemorySlot> &subslots,
            ::mlir::OpBuilder &builder, const ::mlir::DataLayout &dataLayout);
  //===----------------------------------------------------------------===//
  // Inherited from ::llzk::pod::PodRefOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::llzk::pod::PodRefOpInterface () const {
    if (!*this) return nullptr;
    return ::llzk::pod::PodRefOpInterface(*this, getImpl()->implPodRefOpInterface);
  }

  ::mlir::TypedValue<::llzk::pod::PodType> getPodRef();
  ::mlir::OpOperand &getPodRefMutable();

    inline ::llzk::pod::PodType getPodRefType() { return getPodRef().getType(); }
};
namespace detail {
  template <typename ConcreteOp>
  struct PodAccessOpInterfaceTrait : public ::mlir::OpInterface<PodAccessOpInterface, detail::PodAccessOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace pod
} // namespace llzk
namespace llzk {
namespace pod {
template<typename ConcreteOp>
::mlir::TypedValue<::llzk::pod::PodType> detail::PodRefOpInterfaceInterfaceTraits::Model<ConcreteOp>::getPodRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getPodRef();
}
template<typename ConcreteOp>
::mlir::OpOperand &detail::PodRefOpInterfaceInterfaceTraits::Model<ConcreteOp>::getPodRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getPodRefMutable();
}
template<typename ConcreteOp>
::mlir::TypedValue<::llzk::pod::PodType> detail::PodRefOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getPodRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getPodRef(tablegen_opaque_val);
}
template<typename ConcreteOp>
::mlir::OpOperand &detail::PodRefOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getPodRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getPodRefMutable(tablegen_opaque_val);
}
} // namespace pod
} // namespace llzk
namespace llzk {
namespace pod {
template<typename ConcreteOp>
::mlir::FlatSymbolRefAttr detail::PodAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::getRecordNameAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getRecordNameAttr();
}
template<typename ConcreteOp>
bool detail::PodAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::isRead(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).isRead();
}
template<typename ConcreteOp>
::mlir::FlatSymbolRefAttr detail::PodAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getRecordNameAttr(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getRecordNameAttr(tablegen_opaque_val);
}
template<typename ConcreteOp>
bool detail::PodAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isRead(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->isRead(tablegen_opaque_val);
}
} // namespace pod
} // namespace llzk