166 lines
7.4 KiB
C++
166 lines
7.4 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* AttrDef Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifdef GET_ATTRDEF_CLASSES
|
|
#undef GET_ATTRDEF_CLASSES
|
|
|
|
|
|
namespace mlir {
|
|
class AsmParser;
|
|
class AsmPrinter;
|
|
} // namespace mlir
|
|
namespace mlir::ptr {
|
|
|
|
/// Address attribute
|
|
/// The `address` attribute represents a raw memory address, expressed in bytes.
|
|
///
|
|
/// Example:
|
|
///
|
|
/// ```mlir
|
|
/// #ptr.address<0x1000> : !ptr.ptr<#ptr.generic_space>
|
|
/// ```
|
|
class AddressAttr;
|
|
/// Generic memory space
|
|
/// The `generic_space` attribute defines a memory space attribute with the
|
|
/// following properties:
|
|
/// - Load and store operations are always valid, regardless of the type.
|
|
/// - Atomic operations are always valid, regardless of the type.
|
|
/// - Cast operations to `generic_space` are always valid.
|
|
///
|
|
/// Example:
|
|
///
|
|
/// ```mlir
|
|
/// #ptr.generic_space : !ptr.ptr<#ptr.generic_space>
|
|
/// ```
|
|
class GenericSpaceAttr;
|
|
/// Null pointer attribute
|
|
/// The `null` attribute represents a null pointer.
|
|
///
|
|
/// Example:
|
|
///
|
|
/// ```mlir
|
|
/// #ptr.null
|
|
/// ```
|
|
class NullAttr;
|
|
/// ptr data layout spec
|
|
/// Defines the data layout spec for a pointer type. This attribute has 4
|
|
/// fields:
|
|
/// - [Required] size: size of the pointer in bits.
|
|
/// - [Required] abi: ABI-required alignment for the pointer in bits.
|
|
/// - [Required] preferred: preferred alignment for the pointer in bits.
|
|
/// - [Optional] index: bitwidth that should be used when performing index
|
|
/// computations for the type. Setting the field to `kOptionalSpecValue`, means
|
|
/// the field is optional.
|
|
///
|
|
/// Furthermore, the attribute will verify that all present values are divisible
|
|
/// by 8 (number of bits in a byte), and that `preferred` > `abi`.
|
|
///
|
|
/// Example:
|
|
/// ```mlir
|
|
/// // Spec for a 64 bit ptr, with a required alignment of 64 bits, but with
|
|
/// // a preferred alignment of 128 bits and an index bitwidth of 64 bits.
|
|
/// #ptr.spec<size = 64, abi = 64, preferred = 128, index = 64>
|
|
/// ```
|
|
class SpecAttr;
|
|
namespace detail {
|
|
|
|
struct AddressAttrStorage;
|
|
|
|
} // namespace detail
|
|
class AddressAttr : public ::mlir::Attribute::AttrBase<AddressAttr, ::mlir::Attribute, detail::AddressAttrStorage, ::mlir::TypedAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "ptr.address";
|
|
static constexpr ::llvm::StringLiteral dialectName = "ptr";
|
|
static AddressAttr get(::mlir::MLIRContext *context, PtrType type, ::llvm::APInt value);
|
|
static AddressAttr get(PtrType type, const llvm::APInt &value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"address"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
PtrType getType() const;
|
|
const ::llvm::APInt &getValue() const;
|
|
};
|
|
class GenericSpaceAttr : public ::mlir::Attribute::AttrBase<GenericSpaceAttr, ::mlir::Attribute, ::mlir::AttributeStorage, ::mlir::ptr::MemorySpaceAttrInterface::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "ptr.generic_space";
|
|
static constexpr ::llvm::StringLiteral dialectName = "ptr";
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"generic_space"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
bool isValidLoad(::mlir::Type type, ::mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
bool isValidStore(::mlir::Type type, ::mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
bool isValidAtomicOp(::mlir::ptr::AtomicBinOp op, ::mlir::Type type, ::mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
bool isValidAtomicXchg(::mlir::Type type, ::mlir::ptr::AtomicOrdering successOrdering, ::mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
bool isValidAddrSpaceCast(::mlir::Type tgt, ::mlir::Type src, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
bool isValidPtrIntCast(::mlir::Type intLikeTy, ::mlir::Type ptrLikeTy, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct NullAttrStorage;
|
|
|
|
} // namespace detail
|
|
class NullAttr : public ::mlir::Attribute::AttrBase<NullAttr, ::mlir::Attribute, detail::NullAttrStorage, ::mlir::TypedAttr::Trait> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "ptr.null";
|
|
static constexpr ::llvm::StringLiteral dialectName = "ptr";
|
|
static NullAttr get(::mlir::MLIRContext *context, PtrType type);
|
|
static NullAttr get(PtrType type);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"null"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
PtrType getType() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct SpecAttrStorage;
|
|
|
|
} // namespace detail
|
|
class SpecAttr : public ::mlir::Attribute::AttrBase<SpecAttr, ::mlir::Attribute, detail::SpecAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
/// Constant for specifying a spec entry is optional.
|
|
static constexpr uint32_t kOptionalSpecValue = std::numeric_limits<uint32_t>::max();
|
|
static constexpr ::llvm::StringLiteral name = "ptr.spec";
|
|
static constexpr ::llvm::StringLiteral dialectName = "ptr";
|
|
using Base::getChecked;
|
|
static SpecAttr get(::mlir::MLIRContext *context, uint32_t size, uint32_t abi, uint32_t preferred, uint32_t index = kOptionalSpecValue);
|
|
static SpecAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, uint32_t size, uint32_t abi, uint32_t preferred, uint32_t index = kOptionalSpecValue);
|
|
static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, uint32_t size, uint32_t abi, uint32_t preferred, uint32_t index);
|
|
static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, uint32_t size, uint32_t abi, uint32_t preferred, uint32_t index);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"spec"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
uint32_t getSize() const;
|
|
uint32_t getAbi() const;
|
|
uint32_t getPreferred() const;
|
|
uint32_t getIndex() const;
|
|
};
|
|
|
|
} // namespace mlir::ptr
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::ptr::AddressAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::ptr::GenericSpaceAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::ptr::NullAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::ptr::SpecAttr)
|
|
|
|
#endif // GET_ATTRDEF_CLASSES
|
|
|