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 array {
class ArrayRefOpInterface;
namespace detail {
struct ArrayRefOpInterfaceInterfaceTraits {
  struct Concept {
    ::mlir::TypedValue<::llzk::array::ArrayType> (*getArrRef)(const Concept *impl, ::mlir::Operation *);
    ::mlir::OpOperand &(*getArrRefMutable)(const Concept *impl, ::mlir::Operation *);
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::array::ArrayRefOpInterface;
    Model() : Concept{getArrRef, getArrRefMutable} {}
 
    static inline ::mlir::TypedValue<::llzk::array::ArrayType> getArrRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::OpOperand &getArrRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::array::ArrayRefOpInterface;
    FallbackModel() : Concept{getArrRef, getArrRefMutable} {}
 
    static inline ::mlir::TypedValue<::llzk::array::ArrayType> getArrRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::OpOperand &getArrRefMutable(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 ArrayRefOpInterfaceTrait;
 
} // namespace detail
class ArrayRefOpInterface : public ::mlir::OpInterface<ArrayRefOpInterface, detail::ArrayRefOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<ArrayRefOpInterface, detail::ArrayRefOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::ArrayRefOpInterfaceTrait<ConcreteOp> {};
  ::mlir::TypedValue<::llzk::array::ArrayType> getArrRef();
  ::mlir::OpOperand &getArrRefMutable();

    inline ::llzk::array::ArrayType getArrRefType() { return getArrRef().getType(); }
};
namespace detail {
  template <typename ConcreteOp>
  struct ArrayRefOpInterfaceTrait : public ::mlir::OpInterface<ArrayRefOpInterface, detail::ArrayRefOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace array
} // namespace llzk
namespace llzk {
namespace array {
class ArrayAccessOpInterface;
namespace detail {
struct ArrayAccessOpInterfaceInterfaceTraits {
  struct Concept {
    ::mlir::Operation::operand_range (*getIndices)(const Concept *impl, ::mlir::Operation *);
    ::mlir::MutableOperandRange (*getIndicesMutable)(const Concept *impl, ::mlir::Operation *);
    bool (*isRead)(const Concept *impl, ::mlir::Operation *);
    const ::llzk::array::ArrayRefOpInterface::Concept *implArrayRefOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implArrayRefOpInterface = interfaceMap.lookup<::llzk::array::ArrayRefOpInterface>();
      assert(implArrayRefOpInterface && "`::llzk::array::ArrayAccessOpInterface` expected its base interface `::llzk::array::ArrayRefOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::array::ArrayAccessOpInterface;
    Model() : Concept{getIndices, getIndicesMutable, isRead} {}
 
    static inline ::mlir::Operation::operand_range getIndices(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::MutableOperandRange getIndicesMutable(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::array::ArrayAccessOpInterface;
    FallbackModel() : Concept{getIndices, getIndicesMutable, isRead} {}
 
    static inline ::mlir::Operation::operand_range getIndices(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
    static inline ::mlir::MutableOperandRange getIndicesMutable(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 ArrayAccessOpInterfaceTrait;
 
} // namespace detail
class ArrayAccessOpInterface : public ::mlir::OpInterface<ArrayAccessOpInterface, detail::ArrayAccessOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<ArrayAccessOpInterface, detail::ArrayAccessOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::ArrayAccessOpInterfaceTrait<ConcreteOp> {};
  ::mlir::Operation::operand_range getIndices();
  ::mlir::MutableOperandRange getIndicesMutable();
  bool isRead();

    inline ::mlir::ArrayRef<::mlir::Attribute> getValueOperandDims() {
      return getArrRefType().getDimensionSizes().drop_front(getIndices().size());
    }

    ::mlir::ArrayAttr indexOperandsToAttributeArray();

    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);

    static ::llvm::SmallVector<::mlir::Value>
    genIndexConstants(::mlir::OpBuilder &bldr, ::mlir::Location loc, ::mlir::ArrayAttr index);

    static ::mlir::Value
    genRead(::mlir::OpBuilder &bldr, ::mlir::Location loc, ::mlir::Value arrayRef,
            ::mlir::ValueRange indices);

    static ::mlir::Value
    genRead(::mlir::OpBuilder &bldr, ::mlir::Location loc, ::mlir::Value arrayRef,
            ::mlir::ArrayAttr index);

    static void genWrite(::mlir::OpBuilder &bldr, ::mlir::Location loc, ::mlir::Value arrayRef,
            ::mlir::ValueRange indices, ::mlir::Value value);

    static void genWrite(::mlir::OpBuilder &bldr, ::mlir::Location loc, ::mlir::Value arrayRef,
            ::mlir::ArrayAttr index, ::mlir::Value value);
  //===----------------------------------------------------------------===//
  // Inherited from ::llzk::array::ArrayRefOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::llzk::array::ArrayRefOpInterface () const {
    if (!*this) return nullptr;
    return ::llzk::array::ArrayRefOpInterface(*this, getImpl()->implArrayRefOpInterface);
  }

  ::mlir::TypedValue<::llzk::array::ArrayType> getArrRef();
  ::mlir::OpOperand &getArrRefMutable();

    inline ::llzk::array::ArrayType getArrRefType() { return getArrRef().getType(); }
};
namespace detail {
  template <typename ConcreteOp>
  struct ArrayAccessOpInterfaceTrait : public ::mlir::OpInterface<ArrayAccessOpInterface, detail::ArrayAccessOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace array
} // namespace llzk
namespace llzk {
namespace array {
template<typename ConcreteOp>
::mlir::TypedValue<::llzk::array::ArrayType> detail::ArrayRefOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArrRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArrRef();
}
template<typename ConcreteOp>
::mlir::OpOperand &detail::ArrayRefOpInterfaceInterfaceTraits::Model<ConcreteOp>::getArrRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getArrRefMutable();
}
template<typename ConcreteOp>
::mlir::TypedValue<::llzk::array::ArrayType> detail::ArrayRefOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArrRef(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getArrRef(tablegen_opaque_val);
}
template<typename ConcreteOp>
::mlir::OpOperand &detail::ArrayRefOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getArrRefMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getArrRefMutable(tablegen_opaque_val);
}
} // namespace array
} // namespace llzk
namespace llzk {
namespace array {
template<typename ConcreteOp>
::mlir::Operation::operand_range detail::ArrayAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::getIndices(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getIndices();
}
template<typename ConcreteOp>
::mlir::MutableOperandRange detail::ArrayAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::getIndicesMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getIndicesMutable();
}
template<typename ConcreteOp>
bool detail::ArrayAccessOpInterfaceInterfaceTraits::Model<ConcreteOp>::isRead(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).isRead();
}
template<typename ConcreteOp>
::mlir::Operation::operand_range detail::ArrayAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getIndices(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getIndices(tablegen_opaque_val);
}
template<typename ConcreteOp>
::mlir::MutableOperandRange detail::ArrayAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getIndicesMutable(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getIndicesMutable(tablegen_opaque_val);
}
template<typename ConcreteOp>
bool detail::ArrayAccessOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::isRead(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->isRead(tablegen_opaque_val);
}
} // namespace array
} // namespace llzk