/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |* *| |* Op Declarations *| |* *| |* Automatically generated file, do not edit! *| |* From: LLVMOps.td *| |* *| \*===----------------------------------------------------------------------===*/ namespace mlir::LLVM { class AShrOp; } // namespace mlir::LLVM namespace mlir::LLVM { class AddOp; } // namespace mlir::LLVM namespace mlir::LLVM { class AddrSpaceCastOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Creates a pointer pointing to a global, alias or a function /// Creates an SSA value containing a pointer to a global value (function, /// variable or alias). The global value can be defined after its first /// referenced. If the global value is a constant, storing into it is not /// allowed. /// /// Examples: /// /// ```mlir /// func @foo() { /// // Get the address of a global variable. /// %0 = llvm.mlir.addressof @const : !llvm.ptr /// /// // Use it as a regular pointer. /// %1 = llvm.load %0 : !llvm.ptr -> i32 /// /// // Get the address of a function. /// %2 = llvm.mlir.addressof @foo : !llvm.ptr /// /// // The function address can be used for indirect calls. /// llvm.call %2() : !llvm.ptr, () -> () /// /// // Get the address of an aliased global. /// %3 = llvm.mlir.addressof @const_alias : !llvm.ptr /// } /// /// // Define the global. /// llvm.mlir.global @const(42 : i32) : i32 /// /// // Define an alias. /// llvm.mlir.alias @const_alias : i32 { /// %0 = llvm.mlir.addressof @const : !llvm.ptr /// llvm.return %0 : !llvm.ptr /// } /// ``` class AddressOfOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect alias. /// `llvm.mlir.alias` is a top level operation that defines a global alias for /// global variables and functions. The operation is always initialized by /// using a initializer region which could be a direct map to another global /// value or contain some address computation on top of it. /// /// It uses a symbol for its value, which will be uniqued by the module /// with respect to other symbols in it. /// /// Similarly to functions and globals, they can also have a linkage attribute. /// This attribute is placed between `llvm.mlir.alias` and the symbol name. If /// the attribute is omitted, `external` linkage is assumed by default. /// /// Examples: /// /// ```mlir /// // Global alias use @-identifiers. /// llvm.mlir.alias external @foo_alias {addr_space = 0 : i32} : !llvm.ptr { /// %0 = llvm.mlir.addressof @some_function : !llvm.ptr /// llvm.return %0 : !llvm.ptr /// } /// /// // More complex initialization. /// llvm.mlir.alias linkonce_odr hidden @glob /// {addr_space = 0 : i32, dso_local} : !llvm.array<32 x i32> { /// %0 = llvm.mlir.constant(1234 : i64) : i64 /// %1 = llvm.mlir.addressof @glob.private : !llvm.ptr /// %2 = llvm.ptrtoint %1 : !llvm.ptr to i64 /// %3 = llvm.add %2, %0 : i64 /// %4 = llvm.inttoptr %3 : i64 to !llvm.ptr /// llvm.return %4 : !llvm.ptr /// } /// ``` class AliasOp; } // namespace mlir::LLVM namespace mlir::LLVM { class AllocaOp; } // namespace mlir::LLVM namespace mlir::LLVM { class AndOp; } // namespace mlir::LLVM namespace mlir::LLVM { class AtomicCmpXchgOp; } // namespace mlir::LLVM namespace mlir::LLVM { class AtomicRMWOp; } // namespace mlir::LLVM namespace mlir::LLVM { class BitcastOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Creates a LLVM blockaddress ptr /// Creates an SSA value containing a pointer to a basic block. The block /// address information (function and block) is given by the `BlockAddressAttr` /// attribute. This operation assumes an existing `llvm.blocktag` operation /// identifying an existing MLIR block within a function. Example: /// /// ```mlir /// llvm.mlir.global private @g() : !llvm.ptr { /// %0 = llvm.blockaddress > : !llvm.ptr /// llvm.return %0 : !llvm.ptr /// } /// /// llvm.func @fn() { /// llvm.br ^bb1 /// ^bb1: // pred: ^bb0 /// llvm.blocktag /// llvm.return /// } /// ``` class BlockAddressOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// This operation uses a `tag` to uniquely identify an MLIR block in a /// function. The same tag is used by `llvm.blockaddress` in order to compute /// the target address. /// /// A given function should have at most one `llvm.blocktag` operation with a /// given `tag`. This operation cannot be used as a terminator. /// /// Example: /// /// ```mlir /// llvm.func @f() -> !llvm.ptr { /// %addr = llvm.blockaddress > : !llvm.ptr /// llvm.br ^bb1 /// ^bb1: /// llvm.blocktag /// llvm.return %addr : !llvm.ptr /// } /// ``` class BlockTagOp; } // namespace mlir::LLVM namespace mlir::LLVM { class BrOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Call to an LLVM intrinsic function. /// Call the specified llvm intrinsic. If the intrinsic is overloaded, use /// the MLIR function type of this op to determine which intrinsic to call. class CallIntrinsicOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Call to an LLVM function. /// In LLVM IR, functions may return either 0 or 1 value. LLVM IR dialect /// implements this behavior by providing a variadic `call` operation for 0- and /// 1-result functions. Even though MLIR supports multi-result functions, LLVM /// IR dialect disallows them. /// /// The `call` instruction supports both direct and indirect calls. Direct calls /// start with a function name (`@`-prefixed) and indirect calls start with an /// SSA value (`%`-prefixed). The direct callee, if present, is stored as a /// function attribute `callee`. For indirect calls, the callee is of `!llvm.ptr` type /// and is stored as the first value in `callee_operands`. If and only if the /// callee is a variadic function, the `var_callee_type` attribute must carry /// the variadic LLVM function type. The trailing type list contains the /// optional indirect callee type and the MLIR function type, which differs from /// the LLVM function type that uses an explicit void type to model functions /// that do not return a value. /// /// If this operatin has the `no_inline` attribute, then this specific function call /// will never be inlined. The opposite behavior will occur if the call has `always_inline` /// attribute. The `inline_hint` attribute indicates that it is desirable to inline /// this function call. /// /// Examples: /// /// ```mlir /// // Direct call without arguments and with one result. /// %0 = llvm.call @foo() : () -> (f32) /// /// // Direct call with arguments and without a result. /// llvm.call @bar(%0) : (f32) -> () /// /// // Indirect call with an argument and without a result. /// %1 = llvm.mlir.addressof @foo : !llvm.ptr /// llvm.call %1(%0) : !llvm.ptr, (f32) -> () /// /// // Direct variadic call. /// llvm.call @printf(%0, %1) vararg(!llvm.func) : (!llvm.ptr, i32) -> i32 /// /// // Indirect variadic call /// llvm.call %1(%0) vararg(!llvm.func) : !llvm.ptr, (i32) -> () /// ``` class CallOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect comdat region /// Provides access to object file COMDAT section/group functionality. /// /// Examples: /// ```mlir /// llvm.comdat @__llvm_comdat { /// llvm.comdat_selector @any any /// } /// llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64 /// ``` class ComdatOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect comdat selector declaration /// Provides access to object file COMDAT section/group functionality. /// /// Examples: /// ```mlir /// llvm.comdat @__llvm_comdat { /// llvm.comdat_selector @any any /// } /// llvm.mlir.global internal constant @has_any_comdat(1 : i64) comdat(@__llvm_comdat::@any) : i64 /// ``` class ComdatSelectorOp; } // namespace mlir::LLVM namespace mlir::LLVM { class CondBrOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Defines a constant of LLVM type. /// Unlike LLVM IR, MLIR does not have first-class constant values. Therefore, /// all constants must be created as SSA values before being used in other /// operations. `llvm.mlir.constant` creates such values for scalars, vectors, /// strings, structs, and array of structs. It has a mandatory `value` attribute /// whose type depends on the type of the constant value. The type of the constant /// value must correspond to the attribute type converted to LLVM IR type. /// /// When creating constant scalars, the `value` attribute must be either an /// integer attribute or a floating point attribute. The type of the attribute /// may be omitted for `i64` and `f64` types that are implied. /// /// When creating constant vectors, the `value` attribute must be either an /// array attribute, a dense attribute, or a sparse attribute that contains /// integers or floats. The number of elements in the result vector must match /// the number of elements in the attribute. /// /// When creating constant strings, the `value` attribute must be a string /// attribute. The type of the constant must be an LLVM array of `i8`s, and the /// length of the array must match the length of the attribute. /// /// When creating constant structs, the `value` attribute must be an array /// attribute that contains integers or floats. The type of the constant must be /// an LLVM struct type. The number of fields in the struct must match the /// number of elements in the attribute, and the type of each LLVM struct field /// must correspond to the type of the corresponding attribute element converted /// to LLVM IR. /// /// When creating an array of structs, the `value` attribute must be an array /// attribute, itself containing zero, or undef, or array attributes for each /// potential nested array type, and the elements of the leaf array attributes /// for must match the struct element types or be zero or undef attributes. /// /// Examples: /// /// ```mlir /// // Integer constant, internal i32 is mandatory /// %0 = llvm.mlir.constant(42 : i32) : i32 /// /// // It's okay to omit i64. /// %1 = llvm.mlir.constant(42) : i64 /// /// // Floating point constant. /// %2 = llvm.mlir.constant(42.0 : f32) : f32 /// /// // Splat dense vector constant. /// %3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : vector<4xf32> /// ``` class ConstantOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Creates a LLVM dso_local_equivalent ptr /// Creates an SSA value containing a pointer to a global value (function or /// alias to function). It represents a function which is functionally /// equivalent to a given function, but is always defined in the current /// linkage unit. The target function may not have `extern_weak` linkage. /// /// Examples: /// /// ```mlir /// llvm.mlir.global external constant @const() : i64 { /// %0 = llvm.mlir.addressof @const : !llvm.ptr /// %1 = llvm.ptrtoint %0 : !llvm.ptr to i64 /// %2 = llvm.dso_local_equivalent @func : !llvm.ptr /// %4 = llvm.ptrtoint %2 : !llvm.ptr to i64 /// llvm.return %4 : i64 /// } /// ``` class DSOLocalEquivalentOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Extract an element from an LLVM vector. class ExtractElementOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Extract a value from an LLVM struct. class ExtractValueOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FAddOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FCmpOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FDivOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FMulOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FNegOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FPExtOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FPToSIOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FPToUIOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FPTruncOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FRemOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FSubOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FenceOp; } // namespace mlir::LLVM namespace mlir::LLVM { class FreezeOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// This operation mirrors LLVM IRs 'getelementptr' operation that is used to /// perform pointer arithmetic. /// /// Like in LLVM IR, it is possible to use both constants as well as SSA values /// as indices. In the case of indexing within a structure, it is required to /// either use constant indices directly, or supply a constant SSA value. /// /// The no-wrap flags can be used to specify the low-level pointer arithmetic /// overflow behavior that LLVM uses after lowering the operation to LLVM IR. /// Valid options include 'inbounds' (pointer arithmetic must be within object /// bounds), 'nusw' (no unsigned signed wrap), and 'nuw' (no unsigned wrap). /// Note that 'inbounds' implies 'nusw' which is ensured by the enum /// definition. The flags can be set individually or in combination. /// /// Examples: /// /// ```mlir /// // GEP with an SSA value offset /// %0 = llvm.getelementptr %1[%2] : (!llvm.ptr, i64) -> !llvm.ptr, f32 /// /// // GEP with a constant offset and the inbounds attribute set /// %0 = llvm.getelementptr inbounds %1[3] : (!llvm.ptr) -> !llvm.ptr, f32 /// /// // GEP with constant offsets into a structure /// %0 = llvm.getelementptr %1[0, 1] /// : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, f32)> /// ``` class GEPOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect global_ctors. /// Specifies a list of constructor functions, priorities, and associated data. /// The functions referenced by this array will be called in ascending order /// of priority (i.e. lowest first) when the module is loaded. The order of /// functions with the same priority is not defined. This operation is /// translated to LLVM's global_ctors global variable. The initializer /// functions are run at load time. However, if the associated data is not /// `#llvm.zero`, functions only run if the data is not discarded. /// /// Examples: /// /// ```mlir /// llvm.func @ctor() { /// ... /// llvm.return /// } /// llvm.mlir.global_ctors ctors = [@ctor], priorities = [0], /// data = [#llvm.zero] /// ``` class GlobalCtorsOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect global_dtors. /// Specifies a list of destructor functions and priorities. The functions /// referenced by this array will be called in descending order of priority /// (i.e. highest first) when the module is unloaded. The order of functions /// with the same priority is not defined. This operation is translated to /// LLVM's global_dtors global variable. The destruction functions are run at /// load time. However, if the associated data is not `#llvm.zero`, functions /// only run if the data is not discarded. /// /// Examples: /// /// ```mlir /// llvm.func @dtor() { /// llvm.return /// } /// llvm.mlir.global_dtors dtors = [@dtor], priorities = [0], /// data = [#llvm.zero] /// ``` class GlobalDtorsOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect global. /// Since MLIR allows for arbitrary operations to be present at the top level, /// global variables are defined using the `llvm.mlir.global` operation. Both /// global constants and variables can be defined, and the value may also be /// initialized in both cases. /// /// There are two forms of initialization syntax. Simple constants that can be /// represented as MLIR attributes can be given in-line: /// /// ```mlir /// llvm.mlir.global @variable(32.0 : f32) : f32 /// ``` /// /// This initialization and type syntax is similar to `llvm.mlir.constant` and /// may use two types: one for MLIR attribute and another for the LLVM value. /// These types must be compatible. /// /// More complex constants that cannot be represented as MLIR attributes can be /// given in an initializer region: /// /// ```mlir /// // This global is initialized with the equivalent of: /// // i32* getelementptr (i32* @g2, i32 2) /// llvm.mlir.global constant @int_gep() : !llvm.ptr { /// %0 = llvm.mlir.addressof @g2 : !llvm.ptr /// %1 = llvm.mlir.constant(2 : i32) : i32 /// %2 = llvm.getelementptr %0[%1] /// : (!llvm.ptr, i32) -> !llvm.ptr, i32 /// // The initializer region must end with `llvm.return`. /// llvm.return %2 : !llvm.ptr /// } /// ``` /// /// Only one of the initializer attribute or initializer region may be provided. /// /// `llvm.mlir.global` must appear at top-level of the enclosing module. It uses /// an @-identifier for its value, which will be uniqued by the module with /// respect to other @-identifiers in it. /// /// Examples: /// /// ```mlir /// // Global values use @-identifiers. /// llvm.mlir.global constant @cst(42 : i32) : i32 /// /// // Non-constant values must also be initialized. /// llvm.mlir.global @variable(32.0 : f32) : f32 /// /// // Strings are expected to be of wrapped LLVM i8 array type and do not /// // automatically include the trailing zero. /// llvm.mlir.global @string("abc") : !llvm.array<3 x i8> /// /// // For strings globals, the trailing type may be omitted. /// llvm.mlir.global constant @no_trailing_type("foo bar") /// /// // A complex initializer is constructed with an initializer region. /// llvm.mlir.global constant @int_gep() : !llvm.ptr { /// %0 = llvm.mlir.addressof @g2 : !llvm.ptr /// %1 = llvm.mlir.constant(2 : i32) : i32 /// %2 = llvm.getelementptr %0[%1] /// : (!llvm.ptr, i32) -> !llvm.ptr, i32 /// llvm.return %2 : !llvm.ptr /// } /// ``` /// /// Similarly to functions, globals have a linkage attribute. In the custom /// syntax, this attribute is placed between `llvm.mlir.global` and the optional /// `constant` keyword. If the attribute is omitted, `external` linkage is /// assumed by default. /// /// Examples: /// /// ```mlir /// // A constant with internal linkage will not participate in linking. /// llvm.mlir.global internal constant @cst(42 : i32) : i32 /// /// // By default, "external" linkage is assumed and the global participates in /// // symbol resolution at link-time. /// llvm.mlir.global @glob(0 : f32) : f32 /// /// // Alignment is optional /// llvm.mlir.global private constant @y(dense<1.0> : tensor<8xf32>) : !llvm.array<8 x f32> /// ``` /// /// Like global variables in LLVM IR, globals can have an (optional) /// alignment attribute using keyword `alignment`. The integer value of the /// alignment must be a positive integer that is a power of 2. /// /// Examples: /// /// ```mlir /// // Alignment is optional /// llvm.mlir.global private constant @y(dense<1.0> : tensor<8xf32>) { alignment = 32 : i64 } : !llvm.array<8 x f32> /// ``` /// /// The `target_specific_attrs` attribute provides a mechanism to preserve /// target-specific LLVM IR attributes that are not explicitly modeled in the /// LLVM dialect. /// /// The attribute is an array containing either string attributes or /// two-element array attributes of strings. The value of a standalone string /// attribute is interpreted as the name of an LLVM IR attribute on the global. /// A two-element array is interpreted as a key-value pair. /// /// Example: /// /// ```mlir /// llvm.mlir.global external @example() { /// target_specific_attrs = ["value-less-attr", ["int-attr", "4"], ["string-attr", "string"]]} : f64 /// ``` class GlobalOp; } // namespace mlir::LLVM namespace mlir::LLVM { class ICmpOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect ifunc /// `llvm.mlir.ifunc` is a top level operation that defines a global ifunc. /// It defines a new symbol and takes a symbol refering to a resolver function. /// IFuncs can be called as regular functions. The function type is the same /// as the IFuncType. The symbol is resolved at runtime by calling a resolver /// function. /// /// Examples: /// /// ```mlir /// // IFuncs resolve a symbol at runtime using a resovler function. /// llvm.mlir.ifunc external @foo: !llvm.func, !llvm.ptr @resolver /// /// llvm.func @foo_1(i64) -> f32 /// llvm.func @foo_2(i64) -> f32 /// /// llvm.func @resolve_foo() -> !llvm.ptr attributes { /// %0 = llvm.mlir.addressof @foo_2 : !llvm.ptr /// %1 = llvm.mlir.addressof @foo_1 : !llvm.ptr /// /// // ... Logic selecting from foo_{1, 2} /// /// // Return function pointer to the selected function /// llvm.return %7 : !llvm.ptr /// } /// /// llvm.func @use_foo() { /// // IFuncs are called as regular functions /// %res = llvm.call @foo(%value) : i64 -> f32 /// } /// ``` class IFuncOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Transfer control flow to address in `$addr`. A list of possible target /// blocks in `$successors` can be provided and maybe used as a hint in LLVM: /// /// ```mlir /// ... /// llvm.func @g(... /// %dest = llvm.blockaddress > : !llvm.ptr /// llvm.indirectbr %dest : !llvm.ptr, [ /// ^head /// ] /// ^head: /// llvm.blocktag /// llvm.return %arg0 : i32 /// ... /// ``` /// /// It also supports a list of operands that can be passed to a target block: /// /// ```mlir /// llvm.indirectbr %dest : !llvm.ptr, [ /// ^head(%arg0 : i32), /// ^tail(%arg1, %arg0 : i32, i32) /// ] /// ^head(%r0 : i32): /// llvm.return %r0 : i32 /// ^tail(%r1 : i32, %r2 : i32): /// ... /// ``` class IndirectBrOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// The InlineAsmOp mirrors the underlying LLVM semantics with a notable /// exception: the embedded `asm_string` is not allowed to define or reference /// any symbol or any global variable: only the operands of the op may be read, /// written, or referenced. /// Attempting to define or reference any symbol or any global behavior is /// considered undefined behavior at this time. /// If `tail_call_kind` is used, the operation behaves like the specified /// tail call kind. The `musttail` kind it's not available for this operation, /// since it isn't supported by LLVM's inline asm. class InlineAsmOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Insert an element into an LLVM vector. class InsertElementOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Insert a value into an LLVM struct. class InsertValueOp; } // namespace mlir::LLVM namespace mlir::LLVM { class IntToPtrOp; } // namespace mlir::LLVM namespace mlir::LLVM { class InvokeOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// LLVM dialect function. /// MLIR functions are defined by an operation that is not built into the IR /// itself. The LLVM dialect provides an `llvm.func` operation to define /// functions compatible with LLVM IR. These functions have LLVM dialect /// function type but use MLIR syntax to express it. They are required to have /// exactly one result type. LLVM function operation is intended to capture /// additional properties of LLVM functions, such as linkage and calling /// convention, that may be modeled differently by the built-in MLIR function. /// /// ```mlir /// // The type of @bar is !llvm<"i64 (i64)"> /// llvm.func @bar(%arg0: i64) -> i64 { /// llvm.return %arg0 : i64 /// } /// /// // Type type of @foo is !llvm<"void (i64)"> /// // !llvm.void type is omitted /// llvm.func @foo(%arg0: i64) { /// llvm.return /// } /// /// // A function with `internal` linkage. /// llvm.func internal @internal_func() { /// llvm.return /// } /// ``` class LLVMFuncOp; } // namespace mlir::LLVM namespace mlir::LLVM { class LShrOp; } // namespace mlir::LLVM namespace mlir::LLVM { class LandingpadOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Options to pass to the linker when the object file is linked /// Pass the given options to the linker when the resulting object file is linked. /// This is used extensively on Windows to determine the C runtime that the object /// files should link against. /// /// Examples: /// ```mlir /// // Link against the MSVC static threaded CRT. /// llvm.linker_options ["/DEFAULTLIB:", "libcmt"] /// /// // Link against aarch64 compiler-rt builtins /// llvm.linker_options ["-l", "clang_rt.builtins-aarch64"] /// ``` class LinkerOptionsOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// The `load` operation is used to read from memory. A load may be marked as /// atomic, volatile, and/or nontemporal, and takes a number of optional /// attributes that specify aliasing information. /// /// An atomic load only supports a limited set of pointer, integer, and /// floating point types, and requires an explicit alignment. /// /// Examples: /// ```mlir /// // A volatile load of a float variable. /// %0 = llvm.load volatile %ptr : !llvm.ptr -> f32 /// /// // A nontemporal load of a float variable. /// %0 = llvm.load %ptr {nontemporal} : !llvm.ptr -> f32 /// /// // An atomic load of an integer variable. /// %0 = llvm.load %ptr atomic monotonic {alignment = 8 : i64} /// : !llvm.ptr -> i64 /// ``` /// /// See the following link for more details: /// https://llvm.org/docs/LangRef.html#load-instruction class LoadOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Wraps an LLVM `metadata` constant so it can be used as an SSA value. /// Materializes an `!llvm.metadata` SSA value that mirrors LLVM IR's /// `llvm::MetadataAsValue`: a wrapper that lifts an arbitrary /// `llvm::Metadata` node into the value domain so it can be used as an /// operand to instructions that take `metadata` arguments (for example the /// constrained floating-point intrinsics or `llvm.read_register`). /// /// The wrapped metadata is described by the `metadata` attribute, which /// must be one of the LLVM dialect's metadata-attribute classes: /// /// * `#llvm.md_string<"...">` -> `llvm::MDString`. /// * `#llvm.md_const<...>` -> `llvm::ConstantAsMetadata`. /// * `#llvm.md_func<@symbol>` -> `llvm::ValueAsMetadata` of a function. /// * `#llvm.md_node<...>` -> `llvm::MDNode` over any of the above. /// /// These can be nested arbitrarily to form metadata trees. Lowering to LLVM /// IR materialises the corresponding `llvm::Metadata` via the dialect's /// metadata-attribute converter and wraps the result with /// `llvm::MetadataAsValue::get(ctx, md)`. /// /// Example: /// /// ```mlir /// // Rounding-mode operand of a constrained-FP intrinsic: /// %rm = llvm.mlir.metadata_as_value #llvm.md_string<"round.tonearest"> /// : !llvm.metadata /// // Named-register metadata for llvm.read_register: /// %nr = llvm.mlir.metadata_as_value #llvm.md_node<#llvm.md_string<"sp">> /// : !llvm.metadata /// ``` class MetadataAsValueOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Information about module properties /// Represents the equivalent in MLIR for LLVM's `llvm.module.flags` metadata, /// which requires a list of metadata triplets (combining kind, name, value), /// either specified directly by a `ModuleFlagAttr` or defined by an attribute /// implementing `ModuleFlagAttrInterface` (which is used to wrap the details /// of metadata combining, provided other verifications, etc.) /// /// Example: /// ```mlir /// llvm.module.flags [ /// #llvm.mlir.module_flag, /// #llvm.mlir.module_flag /// ] /// ``` class ModuleFlagsOp; } // namespace mlir::LLVM namespace mlir::LLVM { class MulOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Module-level named metadata /// Represents an LLVM named metadata node (`llvm::NamedMDNode`). Named /// metadata nodes are module-level metadata that associate a name string /// with a list of metadata nodes. Each operand must be an `#llvm.md_node`. /// /// Note: cyclic metadata graphs are not supported. Because metadata attributes /// are represented as MLIR attributes (which form a tree), there is no way to /// express a metadata node that directly or transitively references itself. /// LLVM IR permits such cycles (e.g. `!0 = !{!0}`), but they cannot be /// represented here and will not round-trip through this op. /// /// Example: /// ```mlir /// llvm.named_metadata "foo.version" [ /// #llvm.md_node<#llvm.md_const<2 : i32>, /// #llvm.md_const<9 : i32>, /// #llvm.md_const<0 : i32> /// > /// ] /// llvm.named_metadata "foo.kernel" [ /// #llvm.md_node< /// #llvm.md_func<@my_kernel>, /// #llvm.md_node<>, /// #llvm.md_node< /// #llvm.md_node<#llvm.md_const<0 : i32>, /// #llvm.md_string<"foo.buffer"> /// > /// > /// > /// ] /// ``` class NamedMetadataOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Defines a value containing an empty token to LLVM type. /// MLIR does not have a way to spell the LLVM IR `none` token literal. This /// operation produces a builtin `!token` SSA value that lowers to /// `llvm::ConstantTokenNone` in LLVM IR. /// /// Examples: /// /// ```mlir /// %0 = llvm.mlir.none : !token /// ``` class NoneTokenOp; } // namespace mlir::LLVM namespace mlir::LLVM { class OrOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Creates a poison value of LLVM dialect type. /// Unlike LLVM IR, MLIR does not have first-class poison values. Such values /// must be created as SSA values using `llvm.mlir.poison`. This operation has /// no operands or attributes. It creates a poison value of the specified LLVM /// IR dialect type. /// /// Example: /// /// ```mlir /// // Create a poison value for a structure with a 32-bit integer followed /// // by a float. /// %0 = llvm.mlir.poison : !llvm.struct<(i32, f32)> /// ``` class PoisonOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Operation mirroring LLVM's `ptrtoaddr` operation. /// /// This operation casts a pointer (or a vector of pointers) to an integer /// (or a vector of integers) without capturing the provenance of the pointer. /// Therefore, an integer returned or derived from `llvm.ptrtoaddr` does not /// create a legal-to-access pointer when used in `llvm.inttoptr`. /// Code that only cares about the address value of a pointer /// (e.g. pointer subtraction) should prefer `llvm.ptrtoaddr` over /// `llvm.ptrtoint`. /// /// The integer type used as the result type is required to be equal in width /// to the pointer type as specified in the data layout. /// Use the `llvm-target-to-data-layout` pass to derive an MLIR datalayout from /// an LLVM datalayout. /// /// Examples: /// ``` /// llvm.func @default_64_bit_ptrtoaddr(%arg0 : !llvm.ptr) -> i64 { /// %0 = llvm.ptrtoaddr %arg0 : !llvm.ptr to i64 /// llvm.return i64 /// } /// /// module attributes { dlti.dl_spec = #dlti.dl_spec< /// #dlti.dl_entry : vector<3xi64>> /// >} { /// llvm.func @datalayout_32_bit(%arg0 : !llvm.ptr) -> i32 { /// %0 = llvm.ptrtoaddr %arg0 : !llvm.ptr to i32 /// llvm.return %0 : i32 /// } /// } /// ``` class PtrToAddrOp; } // namespace mlir::LLVM namespace mlir::LLVM { class PtrToIntOp; } // namespace mlir::LLVM namespace mlir::LLVM { class ResumeOp; } // namespace mlir::LLVM namespace mlir::LLVM { class ReturnOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SDivOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SExtOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SIToFPOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SRemOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SelectOp; } // namespace mlir::LLVM namespace mlir::LLVM { class ShlOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Construct a permutation of two vectors. class ShuffleVectorOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// The `store` operation is used to write to memory. A store may be marked as /// atomic, volatile, and/or nontemporal, and takes a number of optional /// attributes that specify aliasing information. /// /// An atomic store only supports a limited set of pointer, integer, and /// floating point types, and requires an explicit alignment. /// /// Examples: /// ```mlir /// // A volatile store of a float variable. /// llvm.store volatile %val, %ptr : f32, !llvm.ptr /// /// // A nontemporal store of a float variable. /// llvm.store %val, %ptr {nontemporal} : f32, !llvm.ptr /// /// // An atomic store of an integer variable. /// llvm.store %val, %ptr atomic monotonic {alignment = 8 : i64} /// : i64, !llvm.ptr /// ``` /// /// See the following link for more details: /// https://llvm.org/docs/LangRef.html#store-instruction class StoreOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SubOp; } // namespace mlir::LLVM namespace mlir::LLVM { class SwitchOp; } // namespace mlir::LLVM namespace mlir::LLVM { class TruncOp; } // namespace mlir::LLVM namespace mlir::LLVM { class UDivOp; } // namespace mlir::LLVM namespace mlir::LLVM { class UIToFPOp; } // namespace mlir::LLVM namespace mlir::LLVM { class URemOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Creates an undefined value of LLVM dialect type. /// Unlike LLVM IR, MLIR does not have first-class undefined values. Such values /// must be created as SSA values using `llvm.mlir.undef`. This operation has no /// operands or attributes. It creates an undefined value of the specified LLVM /// IR dialect type. /// /// Example: /// /// ```mlir /// // Create a structure with a 32-bit integer followed by a float. /// %0 = llvm.mlir.undef : !llvm.struct<(i32, f32)> /// ``` class UndefOp; } // namespace mlir::LLVM namespace mlir::LLVM { class UnreachableOp; } // namespace mlir::LLVM namespace mlir::LLVM { class VaArgOp; } // namespace mlir::LLVM namespace mlir::LLVM { class XOrOp; } // namespace mlir::LLVM namespace mlir::LLVM { class ZExtOp; } // namespace mlir::LLVM namespace mlir::LLVM { /// Creates a zero-initialized value of LLVM dialect type. /// Unlike LLVM IR, MLIR does not have first-class zero-initialized values. /// Such values must be created as SSA values using `llvm.mlir.zero`. This /// operation has no operands or attributes. It creates a zero-initialized /// value of the specified LLVM IR dialect type. /// /// Example: /// /// ```mlir /// // Create a zero-initialized value for a structure with a 32-bit integer /// // followed by a float. /// %0 = llvm.mlir.zero : !llvm.struct<(i32, f32)> /// ``` class ZeroOp; } // namespace mlir::LLVM #ifdef GET_OP_CLASSES #undef GET_OP_CLASSES namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AShrOp declarations //===----------------------------------------------------------------------===// namespace detail { class AShrOpGenericAdaptorBase { public: struct Properties { using isExactTy = ::mlir::UnitAttr; isExactTy isExact; auto getIsExact() const { auto &propStorage = this->isExact; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setIsExact(const ::mlir::UnitAttr &propValue) { this->isExact = propValue; } bool operator==(const Properties &rhs) const { return rhs.isExact == this->isExact && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AShrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.ashr", odsAttrs.getContext()); } AShrOpGenericAdaptorBase(AShrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getIsExactAttr(); bool getIsExact(); }; } // namespace detail template class AShrOpGenericAdaptor : public detail::AShrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AShrOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: AShrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AShrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AShrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AShrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AShrOpGenericAdaptor(values, attrs, Properties{}, {}) {} AShrOpGenericAdaptor(RangeT values, const AShrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AShrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AShrOpAdaptor : public AShrOpGenericAdaptor<::mlir::ValueRange> { public: using AShrOpGenericAdaptor::AShrOpGenericAdaptor; AShrOpAdaptor(AShrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AShrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::ExactFlagInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AShrOpAdaptor; template using GenericAdaptor = AShrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::setIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExactName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("isExact")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getIsExactAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getIsExactAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.ashr"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getIsExactAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().isExact); } bool getIsExact(); void setIsExactAttr(::mlir::UnitAttr attr) { getProperties().isExact = attr; } void setIsExact(bool attrValue); ::mlir::Attribute removeIsExactAttr() { auto attr = getProperties().isExact; getProperties().isExact = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AShrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AShrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AddOp declarations //===----------------------------------------------------------------------===// namespace detail { class AddOpGenericAdaptorBase { public: struct Properties { using overflowFlagsTy = ::mlir::LLVM::IntegerOverflowFlags; overflowFlagsTy overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none; ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() const { auto &propStorage = this->overflowFlags; return propStorage; } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags propValue) { auto &propStorage = this->overflowFlags; propStorage = propValue; } bool operator==(const Properties &rhs) const { return rhs.overflowFlags == this->overflowFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AddOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.add", odsAttrs.getContext()); } AddOpGenericAdaptorBase(AddOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } }; } // namespace detail template class AddOpGenericAdaptor : public detail::AddOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AddOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: AddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AddOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AddOpGenericAdaptor(values, attrs, Properties{}, {}) {} AddOpGenericAdaptor(RangeT values, const AddOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AddOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AddOpAdaptor : public AddOpGenericAdaptor<::mlir::ValueRange> { public: using AddOpGenericAdaptor::AddOpGenericAdaptor; AddOpAdaptor(AddOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AddOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait, ::mlir::OpTrait::IsCommutative, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AddOpAdaptor; template using GenericAdaptor = AddOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::setOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoUnsignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoSignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlagsAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.add"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags newOverflowFlags) { getProperties().setOverflowFlags(newOverflowFlags); } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AddOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AddOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AddrSpaceCastOp declarations //===----------------------------------------------------------------------===// namespace detail { class AddrSpaceCastOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AddrSpaceCastOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.addrspacecast", odsAttrs.getContext()); } AddrSpaceCastOpGenericAdaptorBase(AddrSpaceCastOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class AddrSpaceCastOpGenericAdaptor : public detail::AddrSpaceCastOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AddrSpaceCastOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: AddrSpaceCastOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AddrSpaceCastOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AddrSpaceCastOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AddrSpaceCastOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AddrSpaceCastOpGenericAdaptor(values, attrs, Properties{}, {}) {} AddrSpaceCastOpGenericAdaptor(RangeT values, const AddrSpaceCastOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AddrSpaceCastOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AddrSpaceCastOpAdaptor : public AddrSpaceCastOpGenericAdaptor<::mlir::ValueRange> { public: using AddrSpaceCastOpGenericAdaptor::AddrSpaceCastOpGenericAdaptor; AddrSpaceCastOpAdaptor(AddrSpaceCastOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AddrSpaceCastOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::PromotableOpInterface::Trait, ::mlir::ViewLikeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AddrSpaceCastOpAdaptor; template using GenericAdaptor = AddrSpaceCastOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::PromotableOpInterface::Trait::requiresReplacedValues; using ::mlir::PromotableOpInterface::Trait::visitReplacedValues; using ::mlir::ViewLikeOpInterface::Trait::getViewDest; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.addrspacecast"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AddrSpaceCastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AddrSpaceCastOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static AddrSpaceCastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static AddrSpaceCastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static AddrSpaceCastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static AddrSpaceCastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddrSpaceCastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddrSpaceCastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddrSpaceCastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddrSpaceCastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); bool canUsesBeRemoved(const ::llvm::SmallPtrSetImpl<::mlir::OpOperand *> &blockingUses, ::llvm::SmallVectorImpl<::mlir::OpOperand *> &newBlockingUses, const ::mlir::DataLayout &datalayout); ::mlir::DeletionKind removeBlockingUses(const ::llvm::SmallPtrSetImpl &blockingUses, ::mlir::OpBuilder &builder); ::mlir::Value getViewSource(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AddrSpaceCastOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AddressOfOp declarations //===----------------------------------------------------------------------===// namespace detail { class AddressOfOpGenericAdaptorBase { public: struct Properties { using global_nameTy = ::mlir::FlatSymbolRefAttr; global_nameTy global_name; auto getGlobalName() const { auto &propStorage = this->global_name; return ::llvm::cast<::mlir::FlatSymbolRefAttr>(propStorage); } void setGlobalName(const ::mlir::FlatSymbolRefAttr &propValue) { this->global_name = propValue; } bool operator==(const Properties &rhs) const { return rhs.global_name == this->global_name && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AddressOfOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.addressof", odsAttrs.getContext()); } AddressOfOpGenericAdaptorBase(AddressOfOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::FlatSymbolRefAttr getGlobalNameAttr() { auto attr = ::llvm::cast<::mlir::FlatSymbolRefAttr>(getProperties().global_name); return attr; } ::llvm::StringRef getGlobalName(); }; } // namespace detail template class AddressOfOpGenericAdaptor : public detail::AddressOfOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AddressOfOpGenericAdaptorBase; public: AddressOfOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AddressOfOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AddressOfOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AddressOfOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AddressOfOpGenericAdaptor(values, attrs, Properties{}, {}) {} AddressOfOpGenericAdaptor(RangeT values, const AddressOfOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AddressOfOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AddressOfOpAdaptor : public AddressOfOpGenericAdaptor<::mlir::ValueRange> { public: using AddressOfOpGenericAdaptor::AddressOfOpGenericAdaptor; AddressOfOpAdaptor(AddressOfOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AddressOfOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike, ::mlir::SymbolUserOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AddressOfOpAdaptor; template using GenericAdaptor = AddressOfOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("global_name")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getGlobalNameAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getGlobalNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.addressof"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::FlatSymbolRefAttr getGlobalNameAttr() { return ::llvm::cast<::mlir::FlatSymbolRefAttr>(getProperties().global_name); } ::llvm::StringRef getGlobalName(); void setGlobalNameAttr(::mlir::FlatSymbolRefAttr attr) { getProperties().global_name = attr; } void setGlobalName(::llvm::StringRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, GlobalOp global, ArrayRef attrs = {}); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, GlobalOp global, ArrayRef attrs = {}); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, GlobalOp global, ArrayRef attrs = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFuncOp func, ArrayRef attrs = {}); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFuncOp func, ArrayRef attrs = {}); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFuncOp func, ArrayRef attrs = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, AliasOp alias, ArrayRef attrs = {}); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, AliasOp alias, ArrayRef attrs = {}); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, AliasOp alias, ArrayRef attrs = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::FlatSymbolRefAttr global_name); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::FlatSymbolRefAttr global_name); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::FlatSymbolRefAttr global_name); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::FlatSymbolRefAttr global_name); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::FlatSymbolRefAttr global_name); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::FlatSymbolRefAttr global_name); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::llvm::StringRef global_name); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::llvm::StringRef global_name); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::llvm::StringRef global_name); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef global_name); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::llvm::StringRef global_name); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::llvm::StringRef global_name); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddressOfOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AddressOfOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Return the llvm.mlir.global operation that defined the value referenced /// here. GlobalOp getGlobal(SymbolTableCollection &symbolTable); /// Return the llvm.func operation that is referenced here. LLVMFuncOp getFunction(SymbolTableCollection &symbolTable); /// Return the llvm.mlir.alias operation that defined the value referenced /// here. AliasOp getAlias(SymbolTableCollection &symbolTable); /// Return the llvm.mlir.ifunc operation that defined the value referenced /// here. IFuncOp getIFunc(SymbolTableCollection &symbolTable); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AddressOfOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AddressOfOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AliasOp declarations //===----------------------------------------------------------------------===// namespace detail { class AliasOpGenericAdaptorBase { public: struct Properties { using alias_typeTy = ::mlir::TypeAttr; alias_typeTy alias_type; auto getAliasType() const { auto &propStorage = this->alias_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setAliasType(const ::mlir::TypeAttr &propValue) { this->alias_type = propValue; } using dso_localTy = ::mlir::UnitAttr; dso_localTy dso_local; auto getDsoLocal() const { auto &propStorage = this->dso_local; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setDsoLocal(const ::mlir::UnitAttr &propValue) { this->dso_local = propValue; } using linkageTy = ::mlir::LLVM::LinkageAttr; linkageTy linkage; auto getLinkage() const { auto &propStorage = this->linkage; return ::llvm::cast<::mlir::LLVM::LinkageAttr>(propStorage); } void setLinkage(const ::mlir::LLVM::LinkageAttr &propValue) { this->linkage = propValue; } using sym_nameTy = ::mlir::StringAttr; sym_nameTy sym_name; auto getSymName() const { auto &propStorage = this->sym_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setSymName(const ::mlir::StringAttr &propValue) { this->sym_name = propValue; } using thread_local_Ty = ::mlir::UnitAttr; thread_local_Ty thread_local_; auto getThreadLocal_() const { auto &propStorage = this->thread_local_; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setThreadLocal_(const ::mlir::UnitAttr &propValue) { this->thread_local_ = propValue; } using unnamed_addrTy = ::mlir::LLVM::UnnamedAddrAttr; unnamed_addrTy unnamed_addr; auto getUnnamedAddr() const { auto &propStorage = this->unnamed_addr; return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(propStorage); } void setUnnamedAddr(const ::mlir::LLVM::UnnamedAddrAttr &propValue) { this->unnamed_addr = propValue; } using visibility_Ty = ::mlir::LLVM::VisibilityAttr; visibility_Ty visibility_; auto getVisibility_() const { auto &propStorage = this->visibility_; return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(propStorage); } void setVisibility_(const ::mlir::LLVM::VisibilityAttr &propValue) { this->visibility_ = propValue; } bool operator==(const Properties &rhs) const { return rhs.alias_type == this->alias_type && rhs.dso_local == this->dso_local && rhs.linkage == this->linkage && rhs.sym_name == this->sym_name && rhs.thread_local_ == this->thread_local_ && rhs.unnamed_addr == this->unnamed_addr && rhs.visibility_ == this->visibility_ && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AliasOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.alias", odsAttrs.getContext()); } AliasOpGenericAdaptorBase(AliasOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::TypeAttr getAliasTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().alias_type); return attr; } ::mlir::Type getAliasType(); ::mlir::StringAttr getSymNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); return attr; } ::llvm::StringRef getSymName(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { auto attr = ::llvm::cast<::mlir::LLVM::LinkageAttr>(getProperties().linkage); return attr; } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr(); bool getDsoLocal(); ::mlir::UnitAttr getThreadLocal_Attr(); bool getThreadLocal_(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); return attr; } ::std::optional<::mlir::LLVM::UnnamedAddr> getUnnamedAddr(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr(); ::mlir::LLVM::Visibility getVisibility_(); ::mlir::Region &getInitializer() { return *odsRegions[0]; } ::mlir::RegionRange getRegions() { return odsRegions; } }; } // namespace detail template class AliasOpGenericAdaptor : public detail::AliasOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AliasOpGenericAdaptorBase; public: AliasOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AliasOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AliasOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AliasOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AliasOpGenericAdaptor(values, attrs, Properties{}, {}) {} AliasOpGenericAdaptor(RangeT values, const AliasOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AliasOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AliasOpAdaptor : public AliasOpGenericAdaptor<::mlir::ValueRange> { public: using AliasOpGenericAdaptor::AliasOpGenericAdaptor; AliasOpAdaptor(AliasOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AliasOp : public ::mlir::Op::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::IsIsolatedFromAbove, ::mlir::SymbolOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AliasOpAdaptor; template using GenericAdaptor = AliasOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("alias_type"), ::llvm::StringRef("dso_local"), ::llvm::StringRef("linkage"), ::llvm::StringRef("sym_name"), ::llvm::StringRef("thread_local_"), ::llvm::StringRef("unnamed_addr"), ::llvm::StringRef("visibility_")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAliasTypeAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAliasTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getDsoLocalAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getDsoLocalAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getLinkageAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getLinkageAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getSymNameAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getSymNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getThreadLocal_AttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getThreadLocal_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getUnnamedAddrAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getUnnamedAddrAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getVisibility_AttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getVisibility_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.alias"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Region &getInitializer() { return (*this)->getRegion(0); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::TypeAttr getAliasTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().alias_type); } ::mlir::Type getAliasType(); ::mlir::StringAttr getSymNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); } ::llvm::StringRef getSymName(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { return ::llvm::cast<::mlir::LLVM::LinkageAttr>(getProperties().linkage); } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().dso_local); } bool getDsoLocal(); ::mlir::UnitAttr getThreadLocal_Attr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().thread_local_); } bool getThreadLocal_(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); } ::std::optional<::mlir::LLVM::UnnamedAddr> getUnnamedAddr(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(getProperties().visibility_); } ::mlir::LLVM::Visibility getVisibility_(); void setAliasTypeAttr(::mlir::TypeAttr attr) { getProperties().alias_type = attr; } void setAliasType(::mlir::Type attrValue); void setSymNameAttr(::mlir::StringAttr attr) { getProperties().sym_name = attr; } void setSymName(::llvm::StringRef attrValue); void setLinkageAttr(::mlir::LLVM::LinkageAttr attr) { getProperties().linkage = attr; } void setLinkage(::mlir::LLVM::Linkage attrValue); void setDsoLocalAttr(::mlir::UnitAttr attr) { getProperties().dso_local = attr; } void setDsoLocal(bool attrValue); void setThreadLocal_Attr(::mlir::UnitAttr attr) { getProperties().thread_local_ = attr; } void setThreadLocal_(bool attrValue); void setUnnamedAddrAttr(::mlir::LLVM::UnnamedAddrAttr attr) { getProperties().unnamed_addr = attr; } void setUnnamedAddr(::std::optional<::mlir::LLVM::UnnamedAddr> attrValue); void setVisibility_Attr(::mlir::LLVM::VisibilityAttr attr) { getProperties().visibility_ = attr; } void setVisibility_(::mlir::LLVM::Visibility attrValue); ::mlir::Attribute removeDsoLocalAttr() { auto attr = getProperties().dso_local; getProperties().dso_local = {}; return attr; } ::mlir::Attribute removeThreadLocal_Attr() { auto attr = getProperties().thread_local_; getProperties().thread_local_ = {}; return attr; } ::mlir::Attribute removeUnnamedAddrAttr() { auto attr = getProperties().unnamed_addr; getProperties().unnamed_addr = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type type, Linkage linkage, StringRef name, bool dsoLocal = false, bool thread_local_ = false, ArrayRef attrs = {}); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type type, Linkage linkage, StringRef name, bool dsoLocal = false, bool thread_local_ = false, ArrayRef attrs = {}); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, Type type, Linkage linkage, StringRef name, bool dsoLocal = false, bool thread_local_ = false, ArrayRef attrs = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeAttr alias_type, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeAttr alias_type, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeAttr alias_type, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::TypeAttr alias_type, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::TypeAttr alias_type, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::TypeAttr alias_type, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type alias_type, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type alias_type, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type alias_type, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Type alias_type, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Type alias_type, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Type alias_type, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AliasOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AliasOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::LogicalResult verifyRegions(); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 7 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Return the LLVM type of the global alias. Type getType() { return getAliasType(); } /// Return the initializer region. It's always present and terminates /// with an `llvm.return` op with the initializer value. Region &getInitializerRegion() { return getOperation()->getRegion(0); } Block &getInitializerBlock() { return getInitializerRegion().front(); } // Retrieve address space information from the initializer block // result. unsigned getAddrSpace(); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AliasOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AliasOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AllocaOp declarations //===----------------------------------------------------------------------===// namespace detail { class AllocaOpGenericAdaptorBase { public: struct Properties { using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using elem_typeTy = ::mlir::TypeAttr; elem_typeTy elem_type; auto getElemType() const { auto &propStorage = this->elem_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setElemType(const ::mlir::TypeAttr &propValue) { this->elem_type = propValue; } using inallocaTy = ::mlir::UnitAttr; inallocaTy inalloca; auto getInalloca() const { auto &propStorage = this->inalloca; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setInalloca(const ::mlir::UnitAttr &propValue) { this->inalloca = propValue; } bool operator==(const Properties &rhs) const { return rhs.alignment == this->alignment && rhs.elem_type == this->elem_type && rhs.inalloca == this->inalloca && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AllocaOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.alloca", odsAttrs.getContext()); } AllocaOpGenericAdaptorBase(AllocaOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::TypeAttr getElemTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().elem_type); return attr; } ::mlir::Type getElemType(); ::mlir::UnitAttr getInallocaAttr(); bool getInalloca(); }; } // namespace detail template class AllocaOpGenericAdaptor : public detail::AllocaOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AllocaOpGenericAdaptorBase; static constexpr int odsIndex_arraySize = 0; public: AllocaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AllocaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AllocaOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AllocaOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AllocaOpGenericAdaptor(values, attrs, Properties{}, {}) {} AllocaOpGenericAdaptor(RangeT values, const AllocaOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AllocaOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArraySize() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AllocaOpAdaptor : public AllocaOpGenericAdaptor<::mlir::ValueRange> { public: using AllocaOpGenericAdaptor::AllocaOpGenericAdaptor; AllocaOpAdaptor(AllocaOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AllocaOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::PromotableAllocationOpInterface::Trait, ::mlir::DestructurableAllocationOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AllocaOpAdaptor; template using GenericAdaptor = AllocaOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arraySize = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("alignment"), ::llvm::StringRef("elem_type"), ::llvm::StringRef("inalloca")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getElemTypeAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getElemTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getInallocaAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getInallocaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.alloca"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::IntegerType> getArraySize() { return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArraySizeMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::TypeAttr getElemTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().elem_type); } ::mlir::Type getElemType(); ::mlir::UnitAttr getInallocaAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().inalloca); } bool getInalloca(); void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setElemTypeAttr(::mlir::TypeAttr attr) { getProperties().elem_type = attr; } void setElemType(::mlir::Type attrValue); void setInallocaAttr(::mlir::UnitAttr attr) { getProperties().inalloca = attr; } void setInalloca(bool attrValue); ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeInallocaAttr() { auto attr = getProperties().inalloca; getProperties().inalloca = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, Type elementType, Value arraySize, unsigned alignment = 0); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, Type elementType, Value arraySize, unsigned alignment = 0); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, Type elementType, Value arraySize, unsigned alignment = 0); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::TypeAttr elem_type, /*optional*/::mlir::UnitAttr inalloca = nullptr); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::TypeAttr elem_type, /*optional*/::mlir::UnitAttr inalloca = nullptr); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::TypeAttr elem_type, /*optional*/::mlir::UnitAttr inalloca = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::TypeAttr elem_type, /*optional*/::mlir::UnitAttr inalloca = nullptr); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::TypeAttr elem_type, /*optional*/::mlir::UnitAttr inalloca = nullptr); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::TypeAttr elem_type, /*optional*/::mlir::UnitAttr inalloca = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::Type elem_type, /*optional*/bool inalloca = false); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::Type elem_type, /*optional*/bool inalloca = false); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::Type elem_type, /*optional*/bool inalloca = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::Type elem_type, /*optional*/bool inalloca = false); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::Type elem_type, /*optional*/bool inalloca = false); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arraySize, /*optional*/::mlir::IntegerAttr alignment, ::mlir::Type elem_type, /*optional*/bool inalloca = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AllocaOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AllocaOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::SmallVector<::mlir::MemorySlot> getPromotableSlots(); ::mlir::Value getDefaultValue(const ::mlir::MemorySlot &slot, ::mlir::OpBuilder &builder); void handleBlockArgument(const ::mlir::MemorySlot &slot, ::mlir::BlockArgument argument, ::mlir::OpBuilder &builder); ::std::optional<::mlir::PromotableAllocationOpInterface> handlePromotionComplete(const ::mlir::MemorySlot &slot, ::mlir::Value defaultValue, ::mlir::OpBuilder &builder); ::llvm::SmallVector<::mlir::DestructurableMemorySlot> getDestructurableSlots(); ::llvm::DenseMap<::mlir::Attribute, ::mlir::MemorySlot> destructure(const ::mlir::DestructurableMemorySlot &slot, const ::llvm::SmallPtrSetImpl<::mlir::Attribute> &usedIndices, ::mlir::OpBuilder &builder, ::mlir::SmallVectorImpl<::mlir::DestructurableAllocationOpInterface> &newAllocators); ::std::optional<::mlir::DestructurableAllocationOpInterface> handleDestructuringComplete(const ::mlir::DestructurableMemorySlot &slot, ::mlir::OpBuilder &builder); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 3 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AllocaOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AllocaOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AndOp declarations //===----------------------------------------------------------------------===// namespace detail { class AndOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AndOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.and", odsAttrs.getContext()); } AndOpGenericAdaptorBase(AndOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class AndOpGenericAdaptor : public detail::AndOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AndOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: AndOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AndOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AndOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AndOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AndOpGenericAdaptor(values, attrs, Properties{}, {}) {} AndOpGenericAdaptor(RangeT values, const AndOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AndOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AndOpAdaptor : public AndOpGenericAdaptor<::mlir::ValueRange> { public: using AndOpGenericAdaptor::AndOpGenericAdaptor; AndOpAdaptor(AndOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AndOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AndOpAdaptor; template using GenericAdaptor = AndOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.and"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AndOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AndOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AndOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AtomicCmpXchgOp declarations //===----------------------------------------------------------------------===// namespace detail { class AtomicCmpXchgOpGenericAdaptorBase { public: struct Properties { using access_groupsTy = ::mlir::ArrayAttr; access_groupsTy access_groups; auto getAccessGroups() const { auto &propStorage = this->access_groups; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAccessGroups(const ::mlir::ArrayAttr &propValue) { this->access_groups = propValue; } using alias_scopesTy = ::mlir::ArrayAttr; alias_scopesTy alias_scopes; auto getAliasScopes() const { auto &propStorage = this->alias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAliasScopes(const ::mlir::ArrayAttr &propValue) { this->alias_scopes = propValue; } using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using failure_orderingTy = ::mlir::LLVM::AtomicOrderingAttr; failure_orderingTy failure_ordering; auto getFailureOrdering() const { auto &propStorage = this->failure_ordering; return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(propStorage); } void setFailureOrdering(const ::mlir::LLVM::AtomicOrderingAttr &propValue) { this->failure_ordering = propValue; } using noalias_scopesTy = ::mlir::ArrayAttr; noalias_scopesTy noalias_scopes; auto getNoaliasScopes() const { auto &propStorage = this->noalias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNoaliasScopes(const ::mlir::ArrayAttr &propValue) { this->noalias_scopes = propValue; } using success_orderingTy = ::mlir::LLVM::AtomicOrderingAttr; success_orderingTy success_ordering; auto getSuccessOrdering() const { auto &propStorage = this->success_ordering; return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(propStorage); } void setSuccessOrdering(const ::mlir::LLVM::AtomicOrderingAttr &propValue) { this->success_ordering = propValue; } using syncscopeTy = ::mlir::StringAttr; syncscopeTy syncscope; auto getSyncscope() const { auto &propStorage = this->syncscope; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSyncscope(const ::mlir::StringAttr &propValue) { this->syncscope = propValue; } using tbaaTy = ::mlir::ArrayAttr; tbaaTy tbaa; auto getTbaa() const { auto &propStorage = this->tbaa; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setTbaa(const ::mlir::ArrayAttr &propValue) { this->tbaa = propValue; } using volatile_Ty = ::mlir::UnitAttr; volatile_Ty volatile_; auto getVolatile_() const { auto &propStorage = this->volatile_; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setVolatile_(const ::mlir::UnitAttr &propValue) { this->volatile_ = propValue; } using weakTy = ::mlir::UnitAttr; weakTy weak; auto getWeak() const { auto &propStorage = this->weak; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setWeak(const ::mlir::UnitAttr &propValue) { this->weak = propValue; } bool operator==(const Properties &rhs) const { return rhs.access_groups == this->access_groups && rhs.alias_scopes == this->alias_scopes && rhs.alignment == this->alignment && rhs.failure_ordering == this->failure_ordering && rhs.noalias_scopes == this->noalias_scopes && rhs.success_ordering == this->success_ordering && rhs.syncscope == this->syncscope && rhs.tbaa == this->tbaa && rhs.volatile_ == this->volatile_ && rhs.weak == this->weak && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AtomicCmpXchgOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.cmpxchg", odsAttrs.getContext()); } AtomicCmpXchgOpGenericAdaptorBase(AtomicCmpXchgOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::AtomicOrderingAttr getSuccessOrderingAttr() { auto attr = ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().success_ordering); return attr; } ::mlir::LLVM::AtomicOrdering getSuccessOrdering(); ::mlir::LLVM::AtomicOrderingAttr getFailureOrderingAttr() { auto attr = ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().failure_ordering); return attr; } ::mlir::LLVM::AtomicOrdering getFailureOrdering(); ::mlir::StringAttr getSyncscopeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); return attr; } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::UnitAttr getWeakAttr(); bool getWeak(); ::mlir::UnitAttr getVolatile_Attr(); bool getVolatile_(); ::mlir::ArrayAttr getAccessGroupsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); return attr; } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); return attr; } ::std::optional< ::mlir::ArrayAttr > getTbaa(); }; } // namespace detail template class AtomicCmpXchgOpGenericAdaptor : public detail::AtomicCmpXchgOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AtomicCmpXchgOpGenericAdaptorBase; static constexpr int odsIndex_ptr = 0; static constexpr int odsIndex_cmp = 1; static constexpr int odsIndex_val = 2; public: AtomicCmpXchgOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AtomicCmpXchgOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AtomicCmpXchgOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AtomicCmpXchgOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AtomicCmpXchgOpGenericAdaptor(values, attrs, Properties{}, {}) {} AtomicCmpXchgOpGenericAdaptor(RangeT values, const AtomicCmpXchgOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AtomicCmpXchgOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getPtr() { return (*getODSOperands(0).begin()); } ValueT getCmp() { return (*getODSOperands(1).begin()); } ValueT getVal() { return (*getODSOperands(2).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AtomicCmpXchgOpAdaptor : public AtomicCmpXchgOpGenericAdaptor<::mlir::ValueRange> { public: using AtomicCmpXchgOpGenericAdaptor::AtomicCmpXchgOpGenericAdaptor; AtomicCmpXchgOpAdaptor(AtomicCmpXchgOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AtomicCmpXchgOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::LLVM::AccessGroupOpInterface::Trait, ::mlir::LLVM::AliasAnalysisOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AtomicCmpXchgOpAdaptor; template using GenericAdaptor = AtomicCmpXchgOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_ptr = 0; static constexpr int odsIndex_cmp = 1; static constexpr int odsIndex_val = 2; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::AccessGroupOpInterface::Trait::getAccessGroupsOrNull; using ::mlir::LLVM::AccessGroupOpInterface::Trait::setAccessGroups; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getNoAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setNoAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getTBAATagsOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setTBAATags; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("access_groups"), ::llvm::StringRef("alias_scopes"), ::llvm::StringRef("alignment"), ::llvm::StringRef("failure_ordering"), ::llvm::StringRef("noalias_scopes"), ::llvm::StringRef("success_ordering"), ::llvm::StringRef("syncscope"), ::llvm::StringRef("tbaa"), ::llvm::StringRef("volatile_"), ::llvm::StringRef("weak")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAccessGroupsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAccessGroupsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAliasScopesAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getFailureOrderingAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getFailureOrderingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getNoaliasScopesAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getNoaliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getSuccessOrderingAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getSuccessOrderingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getSyncscopeAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getSyncscopeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getTbaaAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getTbaaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getVolatile_AttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getVolatile_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } ::mlir::StringAttr getWeakAttrName() { return getAttributeNameForIndex(9); } static ::mlir::StringAttr getWeakAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 9); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.cmpxchg"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getPtr() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getCmp() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::TypedValue<::mlir::Type> getVal() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(2).begin()); } ::mlir::OpOperand &getPtrMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getCmpMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getValMutable() { auto range = getODSOperandIndexAndLength(2); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::AtomicOrderingAttr getSuccessOrderingAttr() { return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().success_ordering); } ::mlir::LLVM::AtomicOrdering getSuccessOrdering(); ::mlir::LLVM::AtomicOrderingAttr getFailureOrderingAttr() { return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().failure_ordering); } ::mlir::LLVM::AtomicOrdering getFailureOrdering(); ::mlir::StringAttr getSyncscopeAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::UnitAttr getWeakAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().weak); } bool getWeak(); ::mlir::UnitAttr getVolatile_Attr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().volatile_); } bool getVolatile_(); ::mlir::ArrayAttr getAccessGroupsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); } ::std::optional< ::mlir::ArrayAttr > getTbaa(); void setSuccessOrderingAttr(::mlir::LLVM::AtomicOrderingAttr attr) { getProperties().success_ordering = attr; } void setSuccessOrdering(::mlir::LLVM::AtomicOrdering attrValue); void setFailureOrderingAttr(::mlir::LLVM::AtomicOrderingAttr attr) { getProperties().failure_ordering = attr; } void setFailureOrdering(::mlir::LLVM::AtomicOrdering attrValue); void setSyncscopeAttr(::mlir::StringAttr attr) { getProperties().syncscope = attr; } void setSyncscope(::std::optional<::llvm::StringRef> attrValue); void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setWeakAttr(::mlir::UnitAttr attr) { getProperties().weak = attr; } void setWeak(bool attrValue); void setVolatile_Attr(::mlir::UnitAttr attr) { getProperties().volatile_ = attr; } void setVolatile_(bool attrValue); void setAccessGroupsAttr(::mlir::ArrayAttr attr) { getProperties().access_groups = attr; } void setAliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().alias_scopes = attr; } void setNoaliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().noalias_scopes = attr; } void setTbaaAttr(::mlir::ArrayAttr attr) { getProperties().tbaa = attr; } ::mlir::Attribute removeSyncscopeAttr() { auto attr = getProperties().syncscope; getProperties().syncscope = {}; return attr; } ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeWeakAttr() { auto attr = getProperties().weak; getProperties().weak = {}; return attr; } ::mlir::Attribute removeVolatile_Attr() { auto attr = getProperties().volatile_; getProperties().volatile_ = {}; return attr; } ::mlir::Attribute removeAccessGroupsAttr() { auto attr = getProperties().access_groups; getProperties().access_groups = {}; return attr; } ::mlir::Attribute removeAliasScopesAttr() { auto attr = getProperties().alias_scopes; getProperties().alias_scopes = {}; return attr; } ::mlir::Attribute removeNoaliasScopesAttr() { auto attr = getProperties().noalias_scopes; getProperties().noalias_scopes = {}; return attr; } ::mlir::Attribute removeTbaaAttr() { auto attr = getProperties().tbaa; getProperties().tbaa = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value ptr, Value cmp, Value val, LLVM::AtomicOrdering successOrdering, LLVM::AtomicOrdering failureOrdering, StringRef syncscope = StringRef(), unsigned alignment = 0, bool isWeak = false, bool isVolatile = false); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value ptr, Value cmp, Value val, LLVM::AtomicOrdering successOrdering, LLVM::AtomicOrdering failureOrdering, StringRef syncscope = StringRef(), unsigned alignment = 0, bool isWeak = false, bool isVolatile = false); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, Value ptr, Value cmp, Value val, LLVM::AtomicOrdering successOrdering, LLVM::AtomicOrdering failureOrdering, StringRef syncscope = StringRef(), unsigned alignment = 0, bool isWeak = false, bool isVolatile = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr success_ordering, ::mlir::LLVM::AtomicOrderingAttr failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr weak, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value ptr, ::mlir::Value cmp, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering success_ordering, ::mlir::LLVM::AtomicOrdering failure_ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool weak, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicCmpXchgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicCmpXchgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); ::llvm::SmallVector<::mlir::Value> getAccessedOperands(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 10 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AtomicCmpXchgOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AtomicCmpXchgOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::AtomicRMWOp declarations //===----------------------------------------------------------------------===// namespace detail { class AtomicRMWOpGenericAdaptorBase { public: struct Properties { using access_groupsTy = ::mlir::ArrayAttr; access_groupsTy access_groups; auto getAccessGroups() const { auto &propStorage = this->access_groups; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAccessGroups(const ::mlir::ArrayAttr &propValue) { this->access_groups = propValue; } using alias_scopesTy = ::mlir::ArrayAttr; alias_scopesTy alias_scopes; auto getAliasScopes() const { auto &propStorage = this->alias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAliasScopes(const ::mlir::ArrayAttr &propValue) { this->alias_scopes = propValue; } using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using bin_opTy = ::mlir::LLVM::AtomicBinOpAttr; bin_opTy bin_op; auto getBinOp() const { auto &propStorage = this->bin_op; return ::llvm::cast<::mlir::LLVM::AtomicBinOpAttr>(propStorage); } void setBinOp(const ::mlir::LLVM::AtomicBinOpAttr &propValue) { this->bin_op = propValue; } using noalias_scopesTy = ::mlir::ArrayAttr; noalias_scopesTy noalias_scopes; auto getNoaliasScopes() const { auto &propStorage = this->noalias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNoaliasScopes(const ::mlir::ArrayAttr &propValue) { this->noalias_scopes = propValue; } using orderingTy = ::mlir::LLVM::AtomicOrderingAttr; orderingTy ordering; auto getOrdering() const { auto &propStorage = this->ordering; return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(propStorage); } void setOrdering(const ::mlir::LLVM::AtomicOrderingAttr &propValue) { this->ordering = propValue; } using syncscopeTy = ::mlir::StringAttr; syncscopeTy syncscope; auto getSyncscope() const { auto &propStorage = this->syncscope; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSyncscope(const ::mlir::StringAttr &propValue) { this->syncscope = propValue; } using tbaaTy = ::mlir::ArrayAttr; tbaaTy tbaa; auto getTbaa() const { auto &propStorage = this->tbaa; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setTbaa(const ::mlir::ArrayAttr &propValue) { this->tbaa = propValue; } using volatile_Ty = ::mlir::UnitAttr; volatile_Ty volatile_; auto getVolatile_() const { auto &propStorage = this->volatile_; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setVolatile_(const ::mlir::UnitAttr &propValue) { this->volatile_ = propValue; } bool operator==(const Properties &rhs) const { return rhs.access_groups == this->access_groups && rhs.alias_scopes == this->alias_scopes && rhs.alignment == this->alignment && rhs.bin_op == this->bin_op && rhs.noalias_scopes == this->noalias_scopes && rhs.ordering == this->ordering && rhs.syncscope == this->syncscope && rhs.tbaa == this->tbaa && rhs.volatile_ == this->volatile_ && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: AtomicRMWOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.atomicrmw", odsAttrs.getContext()); } AtomicRMWOpGenericAdaptorBase(AtomicRMWOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::AtomicBinOpAttr getBinOpAttr() { auto attr = ::llvm::cast<::mlir::LLVM::AtomicBinOpAttr>(getProperties().bin_op); return attr; } ::mlir::LLVM::AtomicBinOp getBinOp(); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr() { auto attr = ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().ordering); return attr; } ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); return attr; } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::UnitAttr getVolatile_Attr(); bool getVolatile_(); ::mlir::ArrayAttr getAccessGroupsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); return attr; } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); return attr; } ::std::optional< ::mlir::ArrayAttr > getTbaa(); }; } // namespace detail template class AtomicRMWOpGenericAdaptor : public detail::AtomicRMWOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::AtomicRMWOpGenericAdaptorBase; static constexpr int odsIndex_ptr = 0; static constexpr int odsIndex_val = 1; public: AtomicRMWOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} AtomicRMWOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : AtomicRMWOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} AtomicRMWOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : AtomicRMWOpGenericAdaptor(values, attrs, Properties{}, {}) {} AtomicRMWOpGenericAdaptor(RangeT values, const AtomicRMWOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> AtomicRMWOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getPtr() { return (*getODSOperands(0).begin()); } ValueT getVal() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class AtomicRMWOpAdaptor : public AtomicRMWOpGenericAdaptor<::mlir::ValueRange> { public: using AtomicRMWOpGenericAdaptor::AtomicRMWOpGenericAdaptor; AtomicRMWOpAdaptor(AtomicRMWOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class AtomicRMWOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::LLVM::AccessGroupOpInterface::Trait, ::mlir::LLVM::AliasAnalysisOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = AtomicRMWOpAdaptor; template using GenericAdaptor = AtomicRMWOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_ptr = 0; static constexpr int odsIndex_val = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::AccessGroupOpInterface::Trait::getAccessGroupsOrNull; using ::mlir::LLVM::AccessGroupOpInterface::Trait::setAccessGroups; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getNoAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setNoAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getTBAATagsOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setTBAATags; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("access_groups"), ::llvm::StringRef("alias_scopes"), ::llvm::StringRef("alignment"), ::llvm::StringRef("bin_op"), ::llvm::StringRef("noalias_scopes"), ::llvm::StringRef("ordering"), ::llvm::StringRef("syncscope"), ::llvm::StringRef("tbaa"), ::llvm::StringRef("volatile_")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAccessGroupsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAccessGroupsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAliasScopesAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getBinOpAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getBinOpAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getNoaliasScopesAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getNoaliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getOrderingAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getOrderingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getSyncscopeAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getSyncscopeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getTbaaAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getTbaaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getVolatile_AttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getVolatile_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.atomicrmw"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getPtr() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getVal() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getPtrMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getValMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::AtomicBinOpAttr getBinOpAttr() { return ::llvm::cast<::mlir::LLVM::AtomicBinOpAttr>(getProperties().bin_op); } ::mlir::LLVM::AtomicBinOp getBinOp(); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr() { return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().ordering); } ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::UnitAttr getVolatile_Attr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().volatile_); } bool getVolatile_(); ::mlir::ArrayAttr getAccessGroupsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); } ::std::optional< ::mlir::ArrayAttr > getTbaa(); void setBinOpAttr(::mlir::LLVM::AtomicBinOpAttr attr) { getProperties().bin_op = attr; } void setBinOp(::mlir::LLVM::AtomicBinOp attrValue); void setOrderingAttr(::mlir::LLVM::AtomicOrderingAttr attr) { getProperties().ordering = attr; } void setOrdering(::mlir::LLVM::AtomicOrdering attrValue); void setSyncscopeAttr(::mlir::StringAttr attr) { getProperties().syncscope = attr; } void setSyncscope(::std::optional<::llvm::StringRef> attrValue); void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setVolatile_Attr(::mlir::UnitAttr attr) { getProperties().volatile_ = attr; } void setVolatile_(bool attrValue); void setAccessGroupsAttr(::mlir::ArrayAttr attr) { getProperties().access_groups = attr; } void setAliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().alias_scopes = attr; } void setNoaliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().noalias_scopes = attr; } void setTbaaAttr(::mlir::ArrayAttr attr) { getProperties().tbaa = attr; } ::mlir::Attribute removeSyncscopeAttr() { auto attr = getProperties().syncscope; getProperties().syncscope = {}; return attr; } ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeVolatile_Attr() { auto attr = getProperties().volatile_; getProperties().volatile_ = {}; return attr; } ::mlir::Attribute removeAccessGroupsAttr() { auto attr = getProperties().access_groups; getProperties().access_groups = {}; return attr; } ::mlir::Attribute removeAliasScopesAttr() { auto attr = getProperties().alias_scopes; getProperties().alias_scopes = {}; return attr; } ::mlir::Attribute removeNoaliasScopesAttr() { auto attr = getProperties().noalias_scopes; getProperties().noalias_scopes = {}; return attr; } ::mlir::Attribute removeTbaaAttr() { auto attr = getProperties().tbaa; getProperties().tbaa = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVM::AtomicBinOp binOp, Value ptr, Value val, LLVM::AtomicOrdering ordering, StringRef syncscope = StringRef(), unsigned alignment = 0, bool isVolatile = false); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVM::AtomicBinOp binOp, Value ptr, Value val, LLVM::AtomicOrdering ordering, StringRef syncscope = StringRef(), unsigned alignment = 0, bool isVolatile = false); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, LLVM::AtomicBinOp binOp, Value ptr, Value val, LLVM::AtomicOrdering ordering, StringRef syncscope = StringRef(), unsigned alignment = 0, bool isVolatile = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicBinOpAttr bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicBinOp bin_op, ::mlir::Value ptr, ::mlir::Value val, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicRMWOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static AtomicRMWOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); ::llvm::SmallVector<::mlir::Value> getAccessedOperands(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 9 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::AtomicRMWOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::AtomicRMWOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::BitcastOp declarations //===----------------------------------------------------------------------===// namespace detail { class BitcastOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: BitcastOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.bitcast", odsAttrs.getContext()); } BitcastOpGenericAdaptorBase(BitcastOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class BitcastOpGenericAdaptor : public detail::BitcastOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::BitcastOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: BitcastOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} BitcastOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : BitcastOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} BitcastOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : BitcastOpGenericAdaptor(values, attrs, Properties{}, {}) {} BitcastOpGenericAdaptor(RangeT values, const BitcastOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> BitcastOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class BitcastOpAdaptor : public BitcastOpGenericAdaptor<::mlir::ValueRange> { public: using BitcastOpGenericAdaptor::BitcastOpGenericAdaptor; BitcastOpAdaptor(BitcastOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class BitcastOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::PromotableOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = BitcastOpAdaptor; template using GenericAdaptor = BitcastOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::PromotableOpInterface::Trait::requiresReplacedValues; using ::mlir::PromotableOpInterface::Trait::visitReplacedValues; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.bitcast"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static BitcastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static BitcastOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static BitcastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static BitcastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static BitcastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static BitcastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BitcastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BitcastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BitcastOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BitcastOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); bool canUsesBeRemoved(const ::llvm::SmallPtrSetImpl<::mlir::OpOperand *> &blockingUses, ::llvm::SmallVectorImpl<::mlir::OpOperand *> &newBlockingUses, const ::mlir::DataLayout &datalayout); ::mlir::DeletionKind removeBlockingUses(const ::llvm::SmallPtrSetImpl &blockingUses, ::mlir::OpBuilder &builder); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::BitcastOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::BlockAddressOp declarations //===----------------------------------------------------------------------===// namespace detail { class BlockAddressOpGenericAdaptorBase { public: struct Properties { using block_addrTy = ::mlir::LLVM::BlockAddressAttr; block_addrTy block_addr; auto getBlockAddr() const { auto &propStorage = this->block_addr; return ::llvm::cast<::mlir::LLVM::BlockAddressAttr>(propStorage); } void setBlockAddr(const ::mlir::LLVM::BlockAddressAttr &propValue) { this->block_addr = propValue; } bool operator==(const Properties &rhs) const { return rhs.block_addr == this->block_addr && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: BlockAddressOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.blockaddress", odsAttrs.getContext()); } BlockAddressOpGenericAdaptorBase(BlockAddressOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::BlockAddressAttr getBlockAddrAttr() { auto attr = ::llvm::cast<::mlir::LLVM::BlockAddressAttr>(getProperties().block_addr); return attr; } ::mlir::LLVM::BlockAddressAttr getBlockAddr(); }; } // namespace detail template class BlockAddressOpGenericAdaptor : public detail::BlockAddressOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::BlockAddressOpGenericAdaptorBase; public: BlockAddressOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} BlockAddressOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : BlockAddressOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} BlockAddressOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : BlockAddressOpGenericAdaptor(values, attrs, Properties{}, {}) {} BlockAddressOpGenericAdaptor(RangeT values, const BlockAddressOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> BlockAddressOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class BlockAddressOpAdaptor : public BlockAddressOpGenericAdaptor<::mlir::ValueRange> { public: using BlockAddressOpGenericAdaptor::BlockAddressOpGenericAdaptor; BlockAddressOpAdaptor(BlockAddressOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class BlockAddressOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike, ::mlir::SymbolUserOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = BlockAddressOpAdaptor; template using GenericAdaptor = BlockAddressOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("block_addr")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getBlockAddrAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getBlockAddrAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.blockaddress"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::BlockAddressAttr getBlockAddrAttr() { return ::llvm::cast<::mlir::LLVM::BlockAddressAttr>(getProperties().block_addr); } ::mlir::LLVM::BlockAddressAttr getBlockAddr(); void setBlockAddrAttr(::mlir::LLVM::BlockAddressAttr attr) { getProperties().block_addr = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::BlockAddressAttr block_addr); static BlockAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::BlockAddressAttr block_addr); static BlockAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::BlockAddressAttr block_addr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::BlockAddressAttr block_addr); static BlockAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::BlockAddressAttr block_addr); static BlockAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::BlockAddressAttr block_addr); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BlockAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BlockAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BlockAddressOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BlockAddressOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Return the llvm.func operation that is referenced here. LLVMFuncOp getFunction(SymbolTableCollection &symbolTable); /// Search for the matching `llvm.blocktag` operation. This is performed /// by walking the function in `block_addr`. BlockTagOp getBlockTagOp(); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::BlockAddressOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::BlockAddressOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::BlockTagOp declarations //===----------------------------------------------------------------------===// namespace detail { class BlockTagOpGenericAdaptorBase { public: struct Properties { using tagTy = ::mlir::LLVM::BlockTagAttr; tagTy tag; auto getTag() const { auto &propStorage = this->tag; return ::llvm::cast<::mlir::LLVM::BlockTagAttr>(propStorage); } void setTag(const ::mlir::LLVM::BlockTagAttr &propValue) { this->tag = propValue; } bool operator==(const Properties &rhs) const { return rhs.tag == this->tag && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: BlockTagOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.blocktag", odsAttrs.getContext()); } BlockTagOpGenericAdaptorBase(BlockTagOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::BlockTagAttr getTagAttr() { auto attr = ::llvm::cast<::mlir::LLVM::BlockTagAttr>(getProperties().tag); return attr; } ::mlir::LLVM::BlockTagAttr getTag(); }; } // namespace detail template class BlockTagOpGenericAdaptor : public detail::BlockTagOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::BlockTagOpGenericAdaptorBase; public: BlockTagOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} BlockTagOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : BlockTagOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} BlockTagOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : BlockTagOpGenericAdaptor(values, attrs, Properties{}, {}) {} BlockTagOpGenericAdaptor(RangeT values, const BlockTagOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> BlockTagOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class BlockTagOpAdaptor : public BlockTagOpGenericAdaptor<::mlir::ValueRange> { public: using BlockTagOpGenericAdaptor::BlockTagOpGenericAdaptor; BlockTagOpAdaptor(BlockTagOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class BlockTagOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = BlockTagOpAdaptor; template using GenericAdaptor = BlockTagOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("tag")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getTagAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getTagAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.blocktag"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::BlockTagAttr getTagAttr() { return ::llvm::cast<::mlir::LLVM::BlockTagAttr>(getProperties().tag); } ::mlir::LLVM::BlockTagAttr getTag(); void setTagAttr(::mlir::LLVM::BlockTagAttr attr) { getProperties().tag = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::BlockTagAttr tag); static BlockTagOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::BlockTagAttr tag); static BlockTagOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::BlockTagAttr tag); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::BlockTagAttr tag); static BlockTagOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::BlockTagAttr tag); static BlockTagOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::BlockTagAttr tag); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BlockTagOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BlockTagOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BlockTagOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BlockTagOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::BlockTagOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::BlockTagOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::BrOp declarations //===----------------------------------------------------------------------===// namespace detail { class BrOpGenericAdaptorBase { public: struct Properties { using loop_annotationTy = ::mlir::LLVM::LoopAnnotationAttr; loop_annotationTy loop_annotation; auto getLoopAnnotation() const { auto &propStorage = this->loop_annotation; return ::llvm::dyn_cast_or_null<::mlir::LLVM::LoopAnnotationAttr>(propStorage); } void setLoopAnnotation(const ::mlir::LLVM::LoopAnnotationAttr &propValue) { this->loop_annotation = propValue; } bool operator==(const Properties &rhs) const { return rhs.loop_annotation == this->loop_annotation && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: BrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.br", odsAttrs.getContext()); } BrOpGenericAdaptorBase(BrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::LoopAnnotationAttr getLoopAnnotationAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::LoopAnnotationAttr>(getProperties().loop_annotation); return attr; } ::std::optional<::mlir::LLVM::LoopAnnotationAttr> getLoopAnnotation(); }; } // namespace detail template class BrOpGenericAdaptor : public detail::BrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::BrOpGenericAdaptorBase; static constexpr int odsIndex_destOperands = 0; public: BrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} BrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : BrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} BrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : BrOpGenericAdaptor(values, attrs, Properties{}, {}) {} BrOpGenericAdaptor(RangeT values, const BrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> BrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getDestOperands() { return getODSOperands(0); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class BrOpAdaptor : public BrOpGenericAdaptor<::mlir::ValueRange> { public: using BrOpGenericAdaptor::BrOpGenericAdaptor; BrOpAdaptor(BrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class BrOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = BrOpAdaptor; template using GenericAdaptor = BrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_destOperands = 0; using Properties = FoldAdaptor::Properties; using ::mlir::BranchOpInterface::Trait::getSuccessorForOperands; using ::mlir::BranchOpInterface::Trait::areTypesCompatible; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("loop_annotation")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getLoopAnnotationAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getLoopAnnotationAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.br"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::Operation::operand_range getDestOperands() { return getODSOperands(0); } ::mlir::MutableOperandRange getDestOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Block *getDest() { return (*this)->getSuccessor(0); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::LoopAnnotationAttr getLoopAnnotationAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::LoopAnnotationAttr>(getProperties().loop_annotation); } ::std::optional<::mlir::LLVM::LoopAnnotationAttr> getLoopAnnotation(); void setLoopAnnotationAttr(::mlir::LLVM::LoopAnnotationAttr attr) { getProperties().loop_annotation = attr; } ::mlir::Attribute removeLoopAnnotationAttr() { auto attr = getProperties().loop_annotation; getProperties().loop_annotation = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Block *dest); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Block *dest); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, Block *dest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange operands, Block *dest); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ValueRange operands, Block *dest); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, ValueRange operands, Block *dest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange destOperands, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *dest); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange destOperands, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *dest); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange destOperands, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *dest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange destOperands, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *dest); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange destOperands, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *dest); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange destOperands, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *dest); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static BrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::SuccessorOperands getSuccessorOperands(unsigned index); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::BrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::BrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::CallIntrinsicOp declarations //===----------------------------------------------------------------------===// namespace detail { class CallIntrinsicOpGenericAdaptorBase { public: struct Properties { using arg_attrsTy = ::mlir::ArrayAttr; arg_attrsTy arg_attrs; auto getArgAttrs() const { auto &propStorage = this->arg_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setArgAttrs(const ::mlir::ArrayAttr &propValue) { this->arg_attrs = propValue; } using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } using intrinTy = ::mlir::StringAttr; intrinTy intrin; auto getIntrin() const { auto &propStorage = this->intrin; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setIntrin(const ::mlir::StringAttr &propValue) { this->intrin = propValue; } using op_bundle_sizesTy = ::mlir::DenseI32ArrayAttr; op_bundle_sizesTy op_bundle_sizes; auto getOpBundleSizes() const { auto &propStorage = this->op_bundle_sizes; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setOpBundleSizes(const ::mlir::DenseI32ArrayAttr &propValue) { this->op_bundle_sizes = propValue; } using op_bundle_tagsTy = ::mlir::ArrayAttr; op_bundle_tagsTy op_bundle_tags; auto getOpBundleTags() const { auto &propStorage = this->op_bundle_tags; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setOpBundleTags(const ::mlir::ArrayAttr &propValue) { this->op_bundle_tags = propValue; } using res_attrsTy = ::mlir::ArrayAttr; res_attrsTy res_attrs; auto getResAttrs() const { auto &propStorage = this->res_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setResAttrs(const ::mlir::ArrayAttr &propValue) { this->res_attrs = propValue; } using operandSegmentSizesTy = std::array; operandSegmentSizesTy operandSegmentSizes; ::llvm::ArrayRef getOperandSegmentSizes() const { auto &propStorage = this->operandSegmentSizes; return propStorage; } void setOperandSegmentSizes(::llvm::ArrayRef propValue) { auto &propStorage = this->operandSegmentSizes; ::llvm::copy(propValue, propStorage.begin()); } bool operator==(const Properties &rhs) const { return rhs.arg_attrs == this->arg_attrs && rhs.fastmathFlags == this->fastmathFlags && rhs.intrin == this->intrin && rhs.op_bundle_sizes == this->op_bundle_sizes && rhs.op_bundle_tags == this->op_bundle_tags && rhs.res_attrs == this->res_attrs && rhs.operandSegmentSizes == this->operandSegmentSizes && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: CallIntrinsicOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.call_intrinsic", odsAttrs.getContext()); } CallIntrinsicOpGenericAdaptorBase(CallIntrinsicOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getIntrinAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().intrin); return attr; } ::llvm::StringRef getIntrin(); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().op_bundle_sizes); return attr; } ::llvm::ArrayRef getOpBundleSizes(); ::mlir::ArrayAttr getOpBundleTagsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().op_bundle_tags); return attr; } ::std::optional< ::mlir::ArrayAttr > getOpBundleTags(); ::mlir::ArrayAttr getArgAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); }; } // namespace detail template class CallIntrinsicOpGenericAdaptor : public detail::CallIntrinsicOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::CallIntrinsicOpGenericAdaptorBase; static constexpr int odsIndex_args = 0; static constexpr int odsIndex_op_bundle_operands = 1; public: CallIntrinsicOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} CallIntrinsicOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : CallIntrinsicOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} CallIntrinsicOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs) : CallIntrinsicOpGenericAdaptor(values, attrs, Properties{}, {}) {} CallIntrinsicOpGenericAdaptor(RangeT values, const CallIntrinsicOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> CallIntrinsicOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getArgs() { return getODSOperands(0); } ::llvm::SmallVector getOpBundleOperands() { auto tblgenTmpOperands = getODSOperands(1); auto sizes = getOpBundleSizes(); ::llvm::SmallVector tblgenTmpOperandGroups; for (int i = 0, e = sizes.size(); i < e; ++i) { tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i])); tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]); } return tblgenTmpOperandGroups; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class CallIntrinsicOpAdaptor : public CallIntrinsicOpGenericAdaptor<::mlir::ValueRange> { public: using CallIntrinsicOpGenericAdaptor::CallIntrinsicOpGenericAdaptor; CallIntrinsicOpAdaptor(CallIntrinsicOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class CallIntrinsicOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = CallIntrinsicOpAdaptor; template using GenericAdaptor = CallIntrinsicOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_args = 0; static constexpr int odsIndex_op_bundle_operands = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("arg_attrs"), ::llvm::StringRef("fastmathFlags"), ::llvm::StringRef("intrin"), ::llvm::StringRef("op_bundle_sizes"), ::llvm::StringRef("op_bundle_tags"), ::llvm::StringRef("res_attrs"), ::llvm::StringRef("operandSegmentSizes")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getArgAttrsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getArgAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getIntrinAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getIntrinAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getOpBundleSizesAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getOpBundleSizesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getOpBundleTagsAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getOpBundleTagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getResAttrsAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getResAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getOperandSegmentSizesAttrName() { return (*this)->getName().getAttributeNames().back(); } static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) { return name.getAttributeNames().back(); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.call_intrinsic"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::Operation::operand_range getArgs() { return getODSOperands(0); } ::mlir::OperandRangeRange getOpBundleOperands() { return getODSOperands(1).split(getOpBundleSizesAttr()); } ::mlir::MutableOperandRange getArgsMutable(); ::mlir::MutableOperandRangeRange getOpBundleOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index); ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getResults() { auto results = getODSResults(0); return results.empty() ? ::mlir::TypedValue<::mlir::Type>() : ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*results.begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getIntrinAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().intrin); } ::llvm::StringRef getIntrin(); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().op_bundle_sizes); } ::llvm::ArrayRef getOpBundleSizes(); ::mlir::ArrayAttr getOpBundleTagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().op_bundle_tags); } ::std::optional< ::mlir::ArrayAttr > getOpBundleTags(); ::mlir::ArrayAttr getArgAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); void setIntrinAttr(::mlir::StringAttr attr) { getProperties().intrin = attr; } void setIntrin(::llvm::StringRef attrValue); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); void setOpBundleSizesAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().op_bundle_sizes = attr; } void setOpBundleSizes(::llvm::ArrayRef attrValue); void setOpBundleTagsAttr(::mlir::ArrayAttr attr) { getProperties().op_bundle_tags = attr; } void setArgAttrsAttr(::mlir::ArrayAttr attr) { getProperties().arg_attrs = attr; } void setResAttrsAttr(::mlir::ArrayAttr attr) { getProperties().res_attrs = attr; } ::mlir::Attribute removeOpBundleTagsAttr() { auto attr = getProperties().op_bundle_tags; getProperties().op_bundle_tags = {}; return attr; } ::mlir::Attribute removeArgAttrsAttr() { auto attr = getProperties().arg_attrs; getProperties().arg_attrs = {}; return attr; } ::mlir::Attribute removeResAttrsAttr() { auto attr = getProperties().res_attrs; getProperties().res_attrs = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, StringAttr intrin, ValueRange args); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, StringAttr intrin, ValueRange args); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, StringAttr intrin, ValueRange args); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, StringAttr intrin, ValueRange args, FastmathFlagsAttr fastMathFlags); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, StringAttr intrin, ValueRange args, FastmathFlagsAttr fastMathFlags); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, StringAttr intrin, ValueRange args, FastmathFlagsAttr fastMathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, StringAttr intrin, ValueRange args); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, StringAttr intrin, ValueRange args); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, StringAttr intrin, ValueRange args); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange resultTypes, StringAttr intrin, ValueRange args, FastmathFlagsAttr fastMathFlags); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, TypeRange resultTypes, StringAttr intrin, ValueRange args, FastmathFlagsAttr fastMathFlags); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, TypeRange resultTypes, StringAttr intrin, ValueRange args, FastmathFlagsAttr fastMathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type results, ::mlir::StringAttr intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type results, ::mlir::StringAttr intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type results, ::mlir::StringAttr intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::StringAttr intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::StringAttr intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::StringAttr intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type results, ::llvm::StringRef intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlags fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type results, ::llvm::StringRef intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlags fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type results, ::llvm::StringRef intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlags fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlags fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::llvm::StringRef intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlags fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::llvm::StringRef intrin, ::mlir::ValueRange args, ::mlir::LLVM::FastmathFlags fastmathFlags, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static CallIntrinsicOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static CallIntrinsicOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 6 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::CallIntrinsicOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::CallIntrinsicOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::CallOp declarations //===----------------------------------------------------------------------===// namespace detail { class CallOpGenericAdaptorBase { public: struct Properties { using CConvTy = ::mlir::LLVM::CConvAttr; CConvTy CConv; auto getCConv() const { auto &propStorage = this->CConv; return ::llvm::dyn_cast_or_null<::mlir::LLVM::CConvAttr>(propStorage); } void setCConv(const ::mlir::LLVM::CConvAttr &propValue) { this->CConv = propValue; } using TailCallKindTy = ::mlir::LLVM::TailCallKindAttr; TailCallKindTy TailCallKind; auto getTailCallKind() const { auto &propStorage = this->TailCallKind; return ::llvm::dyn_cast_or_null<::mlir::LLVM::TailCallKindAttr>(propStorage); } void setTailCallKind(const ::mlir::LLVM::TailCallKindAttr &propValue) { this->TailCallKind = propValue; } using access_groupsTy = ::mlir::ArrayAttr; access_groupsTy access_groups; auto getAccessGroups() const { auto &propStorage = this->access_groups; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAccessGroups(const ::mlir::ArrayAttr &propValue) { this->access_groups = propValue; } using alias_scopesTy = ::mlir::ArrayAttr; alias_scopesTy alias_scopes; auto getAliasScopes() const { auto &propStorage = this->alias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAliasScopes(const ::mlir::ArrayAttr &propValue) { this->alias_scopes = propValue; } using allocsizeTy = ::mlir::DenseI32ArrayAttr; allocsizeTy allocsize; auto getAllocsize() const { auto &propStorage = this->allocsize; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setAllocsize(const ::mlir::DenseI32ArrayAttr &propValue) { this->allocsize = propValue; } using always_inlineTy = ::mlir::UnitAttr; always_inlineTy always_inline; auto getAlwaysInline() const { auto &propStorage = this->always_inline; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setAlwaysInline(const ::mlir::UnitAttr &propValue) { this->always_inline = propValue; } using arg_attrsTy = ::mlir::ArrayAttr; arg_attrsTy arg_attrs; auto getArgAttrs() const { auto &propStorage = this->arg_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setArgAttrs(const ::mlir::ArrayAttr &propValue) { this->arg_attrs = propValue; } using builtinTy = ::mlir::UnitAttr; builtinTy builtin; auto getBuiltin() const { auto &propStorage = this->builtin; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setBuiltin(const ::mlir::UnitAttr &propValue) { this->builtin = propValue; } using calleeTy = ::mlir::FlatSymbolRefAttr; calleeTy callee; auto getCallee() const { auto &propStorage = this->callee; return ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(propStorage); } void setCallee(const ::mlir::FlatSymbolRefAttr &propValue) { this->callee = propValue; } using coldTy = ::mlir::UnitAttr; coldTy cold; auto getCold() const { auto &propStorage = this->cold; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setCold(const ::mlir::UnitAttr &propValue) { this->cold = propValue; } using convergentTy = ::mlir::UnitAttr; convergentTy convergent; auto getConvergent() const { auto &propStorage = this->convergent; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setConvergent(const ::mlir::UnitAttr &propValue) { this->convergent = propValue; } using default_func_attrsTy = ::mlir::DictionaryAttr; default_func_attrsTy default_func_attrs; auto getDefaultFuncAttrs() const { auto &propStorage = this->default_func_attrs; return ::llvm::dyn_cast_or_null<::mlir::DictionaryAttr>(propStorage); } void setDefaultFuncAttrs(const ::mlir::DictionaryAttr &propValue) { this->default_func_attrs = propValue; } using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } using hotTy = ::mlir::UnitAttr; hotTy hot; auto getHot() const { auto &propStorage = this->hot; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setHot(const ::mlir::UnitAttr &propValue) { this->hot = propValue; } using inline_hintTy = ::mlir::UnitAttr; inline_hintTy inline_hint; auto getInlineHint() const { auto &propStorage = this->inline_hint; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setInlineHint(const ::mlir::UnitAttr &propValue) { this->inline_hint = propValue; } using memory_effectsTy = ::mlir::LLVM::MemoryEffectsAttr; memory_effectsTy memory_effects; auto getMemoryEffects() const { auto &propStorage = this->memory_effects; return ::llvm::dyn_cast_or_null<::mlir::LLVM::MemoryEffectsAttr>(propStorage); } void setMemoryEffects(const ::mlir::LLVM::MemoryEffectsAttr &propValue) { this->memory_effects = propValue; } using minsizeTy = ::mlir::UnitAttr; minsizeTy minsize; auto getMinsize() const { auto &propStorage = this->minsize; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setMinsize(const ::mlir::UnitAttr &propValue) { this->minsize = propValue; } using modular_formatTy = ::mlir::StringAttr; modular_formatTy modular_format; auto getModularFormat() const { auto &propStorage = this->modular_format; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setModularFormat(const ::mlir::StringAttr &propValue) { this->modular_format = propValue; } using no_caller_saved_registersTy = ::mlir::UnitAttr; no_caller_saved_registersTy no_caller_saved_registers; auto getNoCallerSavedRegisters() const { auto &propStorage = this->no_caller_saved_registers; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoCallerSavedRegisters(const ::mlir::UnitAttr &propValue) { this->no_caller_saved_registers = propValue; } using no_inlineTy = ::mlir::UnitAttr; no_inlineTy no_inline; auto getNoInline() const { auto &propStorage = this->no_inline; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoInline(const ::mlir::UnitAttr &propValue) { this->no_inline = propValue; } using no_unwindTy = ::mlir::UnitAttr; no_unwindTy no_unwind; auto getNoUnwind() const { auto &propStorage = this->no_unwind; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoUnwind(const ::mlir::UnitAttr &propValue) { this->no_unwind = propValue; } using noalias_scopesTy = ::mlir::ArrayAttr; noalias_scopesTy noalias_scopes; auto getNoaliasScopes() const { auto &propStorage = this->noalias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNoaliasScopes(const ::mlir::ArrayAttr &propValue) { this->noalias_scopes = propValue; } using nobuiltinTy = ::mlir::UnitAttr; nobuiltinTy nobuiltin; auto getNobuiltin() const { auto &propStorage = this->nobuiltin; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNobuiltin(const ::mlir::UnitAttr &propValue) { this->nobuiltin = propValue; } using nobuiltinsTy = ::mlir::ArrayAttr; nobuiltinsTy nobuiltins; auto getNobuiltins() const { auto &propStorage = this->nobuiltins; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNobuiltins(const ::mlir::ArrayAttr &propValue) { this->nobuiltins = propValue; } using nocallbackTy = ::mlir::UnitAttr; nocallbackTy nocallback; auto getNocallback() const { auto &propStorage = this->nocallback; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNocallback(const ::mlir::UnitAttr &propValue) { this->nocallback = propValue; } using noduplicateTy = ::mlir::UnitAttr; noduplicateTy noduplicate; auto getNoduplicate() const { auto &propStorage = this->noduplicate; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoduplicate(const ::mlir::UnitAttr &propValue) { this->noduplicate = propValue; } using noreturnTy = ::mlir::UnitAttr; noreturnTy noreturn; auto getNoreturn() const { auto &propStorage = this->noreturn; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoreturn(const ::mlir::UnitAttr &propValue) { this->noreturn = propValue; } using op_bundle_sizesTy = ::mlir::DenseI32ArrayAttr; op_bundle_sizesTy op_bundle_sizes; auto getOpBundleSizes() const { auto &propStorage = this->op_bundle_sizes; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setOpBundleSizes(const ::mlir::DenseI32ArrayAttr &propValue) { this->op_bundle_sizes = propValue; } using op_bundle_tagsTy = ::mlir::ArrayAttr; op_bundle_tagsTy op_bundle_tags; auto getOpBundleTags() const { auto &propStorage = this->op_bundle_tags; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setOpBundleTags(const ::mlir::ArrayAttr &propValue) { this->op_bundle_tags = propValue; } using optsizeTy = ::mlir::UnitAttr; optsizeTy optsize; auto getOptsize() const { auto &propStorage = this->optsize; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setOptsize(const ::mlir::UnitAttr &propValue) { this->optsize = propValue; } using res_attrsTy = ::mlir::ArrayAttr; res_attrsTy res_attrs; auto getResAttrs() const { auto &propStorage = this->res_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setResAttrs(const ::mlir::ArrayAttr &propValue) { this->res_attrs = propValue; } using returns_twiceTy = ::mlir::UnitAttr; returns_twiceTy returns_twice; auto getReturnsTwice() const { auto &propStorage = this->returns_twice; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setReturnsTwice(const ::mlir::UnitAttr &propValue) { this->returns_twice = propValue; } using save_reg_paramsTy = ::mlir::UnitAttr; save_reg_paramsTy save_reg_params; auto getSaveRegParams() const { auto &propStorage = this->save_reg_params; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setSaveRegParams(const ::mlir::UnitAttr &propValue) { this->save_reg_params = propValue; } using tbaaTy = ::mlir::ArrayAttr; tbaaTy tbaa; auto getTbaa() const { auto &propStorage = this->tbaa; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setTbaa(const ::mlir::ArrayAttr &propValue) { this->tbaa = propValue; } using trap_func_nameTy = ::mlir::StringAttr; trap_func_nameTy trap_func_name; auto getTrapFuncName() const { auto &propStorage = this->trap_func_name; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setTrapFuncName(const ::mlir::StringAttr &propValue) { this->trap_func_name = propValue; } using var_callee_typeTy = ::mlir::TypeAttr; var_callee_typeTy var_callee_type; auto getVarCalleeType() const { auto &propStorage = this->var_callee_type; return ::llvm::dyn_cast_or_null<::mlir::TypeAttr>(propStorage); } void setVarCalleeType(const ::mlir::TypeAttr &propValue) { this->var_callee_type = propValue; } using will_returnTy = ::mlir::UnitAttr; will_returnTy will_return; auto getWillReturn() const { auto &propStorage = this->will_return; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setWillReturn(const ::mlir::UnitAttr &propValue) { this->will_return = propValue; } using zero_call_used_regsTy = ::mlir::StringAttr; zero_call_used_regsTy zero_call_used_regs; auto getZeroCallUsedRegs() const { auto &propStorage = this->zero_call_used_regs; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setZeroCallUsedRegs(const ::mlir::StringAttr &propValue) { this->zero_call_used_regs = propValue; } using operandSegmentSizesTy = std::array; operandSegmentSizesTy operandSegmentSizes; ::llvm::ArrayRef getOperandSegmentSizes() const { auto &propStorage = this->operandSegmentSizes; return propStorage; } void setOperandSegmentSizes(::llvm::ArrayRef propValue) { auto &propStorage = this->operandSegmentSizes; ::llvm::copy(propValue, propStorage.begin()); } bool operator==(const Properties &rhs) const { return rhs.CConv == this->CConv && rhs.TailCallKind == this->TailCallKind && rhs.access_groups == this->access_groups && rhs.alias_scopes == this->alias_scopes && rhs.allocsize == this->allocsize && rhs.always_inline == this->always_inline && rhs.arg_attrs == this->arg_attrs && rhs.builtin == this->builtin && rhs.callee == this->callee && rhs.cold == this->cold && rhs.convergent == this->convergent && rhs.default_func_attrs == this->default_func_attrs && rhs.fastmathFlags == this->fastmathFlags && rhs.hot == this->hot && rhs.inline_hint == this->inline_hint && rhs.memory_effects == this->memory_effects && rhs.minsize == this->minsize && rhs.modular_format == this->modular_format && rhs.no_caller_saved_registers == this->no_caller_saved_registers && rhs.no_inline == this->no_inline && rhs.no_unwind == this->no_unwind && rhs.noalias_scopes == this->noalias_scopes && rhs.nobuiltin == this->nobuiltin && rhs.nobuiltins == this->nobuiltins && rhs.nocallback == this->nocallback && rhs.noduplicate == this->noduplicate && rhs.noreturn == this->noreturn && rhs.op_bundle_sizes == this->op_bundle_sizes && rhs.op_bundle_tags == this->op_bundle_tags && rhs.optsize == this->optsize && rhs.res_attrs == this->res_attrs && rhs.returns_twice == this->returns_twice && rhs.save_reg_params == this->save_reg_params && rhs.tbaa == this->tbaa && rhs.trap_func_name == this->trap_func_name && rhs.var_callee_type == this->var_callee_type && rhs.will_return == this->will_return && rhs.zero_call_used_regs == this->zero_call_used_regs && rhs.operandSegmentSizes == this->operandSegmentSizes && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: CallOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.call", odsAttrs.getContext()); } CallOpGenericAdaptorBase(CallOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::TypeAttr getVarCalleeTypeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::TypeAttr>(getProperties().var_callee_type); return attr; } ::std::optional<::mlir::LLVM::LLVMFunctionType> getVarCalleeType(); ::mlir::FlatSymbolRefAttr getCalleeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(getProperties().callee); return attr; } ::std::optional< ::llvm::StringRef > getCallee(); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); ::mlir::LLVM::CConvAttr getCConvAttr(); ::mlir::LLVM::cconv::CConv getCConv(); ::mlir::LLVM::TailCallKindAttr getTailCallKindAttr(); ::mlir::LLVM::tailcallkind::TailCallKind getTailCallKind(); ::mlir::LLVM::MemoryEffectsAttr getMemoryEffectsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::MemoryEffectsAttr>(getProperties().memory_effects); return attr; } ::std::optional<::mlir::LLVM::MemoryEffectsAttr> getMemoryEffects(); ::mlir::UnitAttr getConvergentAttr(); bool getConvergent(); ::mlir::UnitAttr getNoUnwindAttr(); bool getNoUnwind(); ::mlir::UnitAttr getWillReturnAttr(); bool getWillReturn(); ::mlir::UnitAttr getNoreturnAttr(); bool getNoreturn(); ::mlir::UnitAttr getReturnsTwiceAttr(); bool getReturnsTwice(); ::mlir::UnitAttr getHotAttr(); bool getHot(); ::mlir::UnitAttr getColdAttr(); bool getCold(); ::mlir::UnitAttr getNoduplicateAttr(); bool getNoduplicate(); ::mlir::UnitAttr getNoCallerSavedRegistersAttr(); bool getNoCallerSavedRegisters(); ::mlir::UnitAttr getNocallbackAttr(); bool getNocallback(); ::mlir::StringAttr getModularFormatAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().modular_format); return attr; } ::std::optional< ::llvm::StringRef > getModularFormat(); ::mlir::ArrayAttr getNobuiltinsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().nobuiltins); return attr; } ::std::optional< ::mlir::ArrayAttr > getNobuiltins(); ::mlir::DenseI32ArrayAttr getAllocsizeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().allocsize); return attr; } ::std::optional<::llvm::ArrayRef> getAllocsize(); ::mlir::UnitAttr getOptsizeAttr(); bool getOptsize(); ::mlir::UnitAttr getMinsizeAttr(); bool getMinsize(); ::mlir::UnitAttr getBuiltinAttr(); bool getBuiltin(); ::mlir::UnitAttr getNobuiltinAttr(); bool getNobuiltin(); ::mlir::UnitAttr getSaveRegParamsAttr(); bool getSaveRegParams(); ::mlir::StringAttr getZeroCallUsedRegsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().zero_call_used_regs); return attr; } ::std::optional< ::llvm::StringRef > getZeroCallUsedRegs(); ::mlir::StringAttr getTrapFuncNameAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().trap_func_name); return attr; } ::std::optional< ::llvm::StringRef > getTrapFuncName(); ::mlir::DictionaryAttr getDefaultFuncAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DictionaryAttr>(getProperties().default_func_attrs); return attr; } ::std::optional< ::mlir::DictionaryAttr > getDefaultFuncAttrs(); ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().op_bundle_sizes); return attr; } ::llvm::ArrayRef getOpBundleSizes(); ::mlir::ArrayAttr getOpBundleTagsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().op_bundle_tags); return attr; } ::std::optional< ::mlir::ArrayAttr > getOpBundleTags(); ::mlir::ArrayAttr getArgAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); ::mlir::UnitAttr getNoInlineAttr(); bool getNoInline(); ::mlir::UnitAttr getAlwaysInlineAttr(); bool getAlwaysInline(); ::mlir::UnitAttr getInlineHintAttr(); bool getInlineHint(); ::mlir::ArrayAttr getAccessGroupsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); return attr; } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); return attr; } ::std::optional< ::mlir::ArrayAttr > getTbaa(); }; } // namespace detail template class CallOpGenericAdaptor : public detail::CallOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::CallOpGenericAdaptorBase; static constexpr int odsIndex_callee_operands = 0; static constexpr int odsIndex_op_bundle_operands = 1; public: CallOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} CallOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : CallOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} CallOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs) : CallOpGenericAdaptor(values, attrs, Properties{}, {}) {} CallOpGenericAdaptor(RangeT values, const CallOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> CallOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getCalleeOperands() { return getODSOperands(0); } ::llvm::SmallVector getOpBundleOperands() { auto tblgenTmpOperands = getODSOperands(1); auto sizes = getOpBundleSizes(); ::llvm::SmallVector tblgenTmpOperandGroups; for (int i = 0, e = sizes.size(); i < e; ++i) { tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i])); tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]); } return tblgenTmpOperandGroups; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class CallOpAdaptor : public CallOpGenericAdaptor<::mlir::ValueRange> { public: using CallOpGenericAdaptor::CallOpGenericAdaptor; CallOpAdaptor(CallOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class CallOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = CallOpAdaptor; template using GenericAdaptor = CallOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_callee_operands = 0; static constexpr int odsIndex_op_bundle_operands = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::AccessGroupOpInterface::Trait::getAccessGroupsOrNull; using ::mlir::LLVM::AccessGroupOpInterface::Trait::setAccessGroups; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getNoAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setNoAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getTBAATagsOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setTBAATags; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; using ::mlir::CallOpInterface::Trait::resolveCallableInTable; using ::mlir::CallOpInterface::Trait::resolveCallable; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("CConv"), ::llvm::StringRef("TailCallKind"), ::llvm::StringRef("access_groups"), ::llvm::StringRef("alias_scopes"), ::llvm::StringRef("allocsize"), ::llvm::StringRef("always_inline"), ::llvm::StringRef("arg_attrs"), ::llvm::StringRef("builtin"), ::llvm::StringRef("callee"), ::llvm::StringRef("cold"), ::llvm::StringRef("convergent"), ::llvm::StringRef("default_func_attrs"), ::llvm::StringRef("fastmathFlags"), ::llvm::StringRef("hot"), ::llvm::StringRef("inline_hint"), ::llvm::StringRef("memory_effects"), ::llvm::StringRef("minsize"), ::llvm::StringRef("modular_format"), ::llvm::StringRef("no_caller_saved_registers"), ::llvm::StringRef("no_inline"), ::llvm::StringRef("no_unwind"), ::llvm::StringRef("noalias_scopes"), ::llvm::StringRef("nobuiltin"), ::llvm::StringRef("nobuiltins"), ::llvm::StringRef("nocallback"), ::llvm::StringRef("noduplicate"), ::llvm::StringRef("noreturn"), ::llvm::StringRef("op_bundle_sizes"), ::llvm::StringRef("op_bundle_tags"), ::llvm::StringRef("optsize"), ::llvm::StringRef("res_attrs"), ::llvm::StringRef("returns_twice"), ::llvm::StringRef("save_reg_params"), ::llvm::StringRef("tbaa"), ::llvm::StringRef("trap_func_name"), ::llvm::StringRef("var_callee_type"), ::llvm::StringRef("will_return"), ::llvm::StringRef("zero_call_used_regs"), ::llvm::StringRef("operandSegmentSizes")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getCConvAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getCConvAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getTailCallKindAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getTailCallKindAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getAccessGroupsAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getAccessGroupsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getAliasScopesAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getAliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getAllocsizeAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getAllocsizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getAlwaysInlineAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getAlwaysInlineAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getArgAttrsAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getArgAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getBuiltinAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getBuiltinAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getCalleeAttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getCalleeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } ::mlir::StringAttr getColdAttrName() { return getAttributeNameForIndex(9); } static ::mlir::StringAttr getColdAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 9); } ::mlir::StringAttr getConvergentAttrName() { return getAttributeNameForIndex(10); } static ::mlir::StringAttr getConvergentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 10); } ::mlir::StringAttr getDefaultFuncAttrsAttrName() { return getAttributeNameForIndex(11); } static ::mlir::StringAttr getDefaultFuncAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 11); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(12); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 12); } ::mlir::StringAttr getHotAttrName() { return getAttributeNameForIndex(13); } static ::mlir::StringAttr getHotAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 13); } ::mlir::StringAttr getInlineHintAttrName() { return getAttributeNameForIndex(14); } static ::mlir::StringAttr getInlineHintAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 14); } ::mlir::StringAttr getMemoryEffectsAttrName() { return getAttributeNameForIndex(15); } static ::mlir::StringAttr getMemoryEffectsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 15); } ::mlir::StringAttr getMinsizeAttrName() { return getAttributeNameForIndex(16); } static ::mlir::StringAttr getMinsizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 16); } ::mlir::StringAttr getModularFormatAttrName() { return getAttributeNameForIndex(17); } static ::mlir::StringAttr getModularFormatAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 17); } ::mlir::StringAttr getNoCallerSavedRegistersAttrName() { return getAttributeNameForIndex(18); } static ::mlir::StringAttr getNoCallerSavedRegistersAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 18); } ::mlir::StringAttr getNoInlineAttrName() { return getAttributeNameForIndex(19); } static ::mlir::StringAttr getNoInlineAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 19); } ::mlir::StringAttr getNoUnwindAttrName() { return getAttributeNameForIndex(20); } static ::mlir::StringAttr getNoUnwindAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 20); } ::mlir::StringAttr getNoaliasScopesAttrName() { return getAttributeNameForIndex(21); } static ::mlir::StringAttr getNoaliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 21); } ::mlir::StringAttr getNobuiltinAttrName() { return getAttributeNameForIndex(22); } static ::mlir::StringAttr getNobuiltinAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 22); } ::mlir::StringAttr getNobuiltinsAttrName() { return getAttributeNameForIndex(23); } static ::mlir::StringAttr getNobuiltinsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 23); } ::mlir::StringAttr getNocallbackAttrName() { return getAttributeNameForIndex(24); } static ::mlir::StringAttr getNocallbackAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 24); } ::mlir::StringAttr getNoduplicateAttrName() { return getAttributeNameForIndex(25); } static ::mlir::StringAttr getNoduplicateAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 25); } ::mlir::StringAttr getNoreturnAttrName() { return getAttributeNameForIndex(26); } static ::mlir::StringAttr getNoreturnAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 26); } ::mlir::StringAttr getOpBundleSizesAttrName() { return getAttributeNameForIndex(27); } static ::mlir::StringAttr getOpBundleSizesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 27); } ::mlir::StringAttr getOpBundleTagsAttrName() { return getAttributeNameForIndex(28); } static ::mlir::StringAttr getOpBundleTagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 28); } ::mlir::StringAttr getOptsizeAttrName() { return getAttributeNameForIndex(29); } static ::mlir::StringAttr getOptsizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 29); } ::mlir::StringAttr getResAttrsAttrName() { return getAttributeNameForIndex(30); } static ::mlir::StringAttr getResAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 30); } ::mlir::StringAttr getReturnsTwiceAttrName() { return getAttributeNameForIndex(31); } static ::mlir::StringAttr getReturnsTwiceAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 31); } ::mlir::StringAttr getSaveRegParamsAttrName() { return getAttributeNameForIndex(32); } static ::mlir::StringAttr getSaveRegParamsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 32); } ::mlir::StringAttr getTbaaAttrName() { return getAttributeNameForIndex(33); } static ::mlir::StringAttr getTbaaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 33); } ::mlir::StringAttr getTrapFuncNameAttrName() { return getAttributeNameForIndex(34); } static ::mlir::StringAttr getTrapFuncNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 34); } ::mlir::StringAttr getVarCalleeTypeAttrName() { return getAttributeNameForIndex(35); } static ::mlir::StringAttr getVarCalleeTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 35); } ::mlir::StringAttr getWillReturnAttrName() { return getAttributeNameForIndex(36); } static ::mlir::StringAttr getWillReturnAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 36); } ::mlir::StringAttr getZeroCallUsedRegsAttrName() { return getAttributeNameForIndex(37); } static ::mlir::StringAttr getZeroCallUsedRegsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 37); } ::mlir::StringAttr getOperandSegmentSizesAttrName() { return (*this)->getName().getAttributeNames().back(); } static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) { return name.getAttributeNames().back(); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.call"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::Operation::operand_range getCalleeOperands() { return getODSOperands(0); } ::mlir::OperandRangeRange getOpBundleOperands() { return getODSOperands(1).split(getOpBundleSizesAttr()); } ::mlir::MutableOperandRange getCalleeOperandsMutable(); ::mlir::MutableOperandRangeRange getOpBundleOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index); ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getResult() { auto results = getODSResults(0); return results.empty() ? ::mlir::TypedValue<::mlir::Type>() : ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*results.begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::TypeAttr getVarCalleeTypeAttr() { return ::llvm::dyn_cast_or_null<::mlir::TypeAttr>(getProperties().var_callee_type); } ::std::optional<::mlir::LLVM::LLVMFunctionType> getVarCalleeType(); ::mlir::FlatSymbolRefAttr getCalleeAttr() { return ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(getProperties().callee); } ::std::optional< ::llvm::StringRef > getCallee(); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); ::mlir::LLVM::CConvAttr getCConvAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::CConvAttr>(getProperties().CConv); } ::mlir::LLVM::cconv::CConv getCConv(); ::mlir::LLVM::TailCallKindAttr getTailCallKindAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::TailCallKindAttr>(getProperties().TailCallKind); } ::mlir::LLVM::tailcallkind::TailCallKind getTailCallKind(); ::mlir::LLVM::MemoryEffectsAttr getMemoryEffectsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::MemoryEffectsAttr>(getProperties().memory_effects); } ::std::optional<::mlir::LLVM::MemoryEffectsAttr> getMemoryEffects(); ::mlir::UnitAttr getConvergentAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().convergent); } bool getConvergent(); ::mlir::UnitAttr getNoUnwindAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().no_unwind); } bool getNoUnwind(); ::mlir::UnitAttr getWillReturnAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().will_return); } bool getWillReturn(); ::mlir::UnitAttr getNoreturnAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().noreturn); } bool getNoreturn(); ::mlir::UnitAttr getReturnsTwiceAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().returns_twice); } bool getReturnsTwice(); ::mlir::UnitAttr getHotAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().hot); } bool getHot(); ::mlir::UnitAttr getColdAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().cold); } bool getCold(); ::mlir::UnitAttr getNoduplicateAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().noduplicate); } bool getNoduplicate(); ::mlir::UnitAttr getNoCallerSavedRegistersAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().no_caller_saved_registers); } bool getNoCallerSavedRegisters(); ::mlir::UnitAttr getNocallbackAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nocallback); } bool getNocallback(); ::mlir::StringAttr getModularFormatAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().modular_format); } ::std::optional< ::llvm::StringRef > getModularFormat(); ::mlir::ArrayAttr getNobuiltinsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().nobuiltins); } ::std::optional< ::mlir::ArrayAttr > getNobuiltins(); ::mlir::DenseI32ArrayAttr getAllocsizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().allocsize); } ::std::optional<::llvm::ArrayRef> getAllocsize(); ::mlir::UnitAttr getOptsizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().optsize); } bool getOptsize(); ::mlir::UnitAttr getMinsizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().minsize); } bool getMinsize(); ::mlir::UnitAttr getBuiltinAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().builtin); } bool getBuiltin(); ::mlir::UnitAttr getNobuiltinAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nobuiltin); } bool getNobuiltin(); ::mlir::UnitAttr getSaveRegParamsAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().save_reg_params); } bool getSaveRegParams(); ::mlir::StringAttr getZeroCallUsedRegsAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().zero_call_used_regs); } ::std::optional< ::llvm::StringRef > getZeroCallUsedRegs(); ::mlir::StringAttr getTrapFuncNameAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().trap_func_name); } ::std::optional< ::llvm::StringRef > getTrapFuncName(); ::mlir::DictionaryAttr getDefaultFuncAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::DictionaryAttr>(getProperties().default_func_attrs); } ::std::optional< ::mlir::DictionaryAttr > getDefaultFuncAttrs(); ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().op_bundle_sizes); } ::llvm::ArrayRef getOpBundleSizes(); ::mlir::ArrayAttr getOpBundleTagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().op_bundle_tags); } ::std::optional< ::mlir::ArrayAttr > getOpBundleTags(); ::mlir::ArrayAttr getArgAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); ::mlir::UnitAttr getNoInlineAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().no_inline); } bool getNoInline(); ::mlir::UnitAttr getAlwaysInlineAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().always_inline); } bool getAlwaysInline(); ::mlir::UnitAttr getInlineHintAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().inline_hint); } bool getInlineHint(); ::mlir::ArrayAttr getAccessGroupsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); } ::std::optional< ::mlir::ArrayAttr > getTbaa(); void setVarCalleeTypeAttr(::mlir::TypeAttr attr) { getProperties().var_callee_type = attr; } void setVarCalleeType(::std::optional<::mlir::LLVM::LLVMFunctionType> attrValue); void setCalleeAttr(::mlir::FlatSymbolRefAttr attr) { getProperties().callee = attr; } void setCallee(::std::optional<::llvm::StringRef> attrValue); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); void setCConvAttr(::mlir::LLVM::CConvAttr attr) { getProperties().CConv = attr; } void setCConv(::mlir::LLVM::cconv::CConv attrValue); void setTailCallKindAttr(::mlir::LLVM::TailCallKindAttr attr) { getProperties().TailCallKind = attr; } void setTailCallKind(::mlir::LLVM::tailcallkind::TailCallKind attrValue); void setMemoryEffectsAttr(::mlir::LLVM::MemoryEffectsAttr attr) { getProperties().memory_effects = attr; } void setConvergentAttr(::mlir::UnitAttr attr) { getProperties().convergent = attr; } void setConvergent(bool attrValue); void setNoUnwindAttr(::mlir::UnitAttr attr) { getProperties().no_unwind = attr; } void setNoUnwind(bool attrValue); void setWillReturnAttr(::mlir::UnitAttr attr) { getProperties().will_return = attr; } void setWillReturn(bool attrValue); void setNoreturnAttr(::mlir::UnitAttr attr) { getProperties().noreturn = attr; } void setNoreturn(bool attrValue); void setReturnsTwiceAttr(::mlir::UnitAttr attr) { getProperties().returns_twice = attr; } void setReturnsTwice(bool attrValue); void setHotAttr(::mlir::UnitAttr attr) { getProperties().hot = attr; } void setHot(bool attrValue); void setColdAttr(::mlir::UnitAttr attr) { getProperties().cold = attr; } void setCold(bool attrValue); void setNoduplicateAttr(::mlir::UnitAttr attr) { getProperties().noduplicate = attr; } void setNoduplicate(bool attrValue); void setNoCallerSavedRegistersAttr(::mlir::UnitAttr attr) { getProperties().no_caller_saved_registers = attr; } void setNoCallerSavedRegisters(bool attrValue); void setNocallbackAttr(::mlir::UnitAttr attr) { getProperties().nocallback = attr; } void setNocallback(bool attrValue); void setModularFormatAttr(::mlir::StringAttr attr) { getProperties().modular_format = attr; } void setModularFormat(::std::optional<::llvm::StringRef> attrValue); void setNobuiltinsAttr(::mlir::ArrayAttr attr) { getProperties().nobuiltins = attr; } void setAllocsizeAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().allocsize = attr; } void setAllocsize(::std::optional<::llvm::ArrayRef> attrValue); void setOptsizeAttr(::mlir::UnitAttr attr) { getProperties().optsize = attr; } void setOptsize(bool attrValue); void setMinsizeAttr(::mlir::UnitAttr attr) { getProperties().minsize = attr; } void setMinsize(bool attrValue); void setBuiltinAttr(::mlir::UnitAttr attr) { getProperties().builtin = attr; } void setBuiltin(bool attrValue); void setNobuiltinAttr(::mlir::UnitAttr attr) { getProperties().nobuiltin = attr; } void setNobuiltin(bool attrValue); void setSaveRegParamsAttr(::mlir::UnitAttr attr) { getProperties().save_reg_params = attr; } void setSaveRegParams(bool attrValue); void setZeroCallUsedRegsAttr(::mlir::StringAttr attr) { getProperties().zero_call_used_regs = attr; } void setZeroCallUsedRegs(::std::optional<::llvm::StringRef> attrValue); void setTrapFuncNameAttr(::mlir::StringAttr attr) { getProperties().trap_func_name = attr; } void setTrapFuncName(::std::optional<::llvm::StringRef> attrValue); void setDefaultFuncAttrsAttr(::mlir::DictionaryAttr attr) { getProperties().default_func_attrs = attr; } void setOpBundleSizesAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().op_bundle_sizes = attr; } void setOpBundleSizes(::llvm::ArrayRef attrValue); void setOpBundleTagsAttr(::mlir::ArrayAttr attr) { getProperties().op_bundle_tags = attr; } void setArgAttrsAttr(::mlir::ArrayAttr attr) { getProperties().arg_attrs = attr; } void setResAttrsAttr(::mlir::ArrayAttr attr) { getProperties().res_attrs = attr; } void setNoInlineAttr(::mlir::UnitAttr attr) { getProperties().no_inline = attr; } void setNoInline(bool attrValue); void setAlwaysInlineAttr(::mlir::UnitAttr attr) { getProperties().always_inline = attr; } void setAlwaysInline(bool attrValue); void setInlineHintAttr(::mlir::UnitAttr attr) { getProperties().inline_hint = attr; } void setInlineHint(bool attrValue); void setAccessGroupsAttr(::mlir::ArrayAttr attr) { getProperties().access_groups = attr; } void setAliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().alias_scopes = attr; } void setNoaliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().noalias_scopes = attr; } void setTbaaAttr(::mlir::ArrayAttr attr) { getProperties().tbaa = attr; } ::mlir::Attribute removeVarCalleeTypeAttr() { auto attr = getProperties().var_callee_type; getProperties().var_callee_type = {}; return attr; } ::mlir::Attribute removeCalleeAttr() { auto attr = getProperties().callee; getProperties().callee = {}; return attr; } ::mlir::Attribute removeMemoryEffectsAttr() { auto attr = getProperties().memory_effects; getProperties().memory_effects = {}; return attr; } ::mlir::Attribute removeConvergentAttr() { auto attr = getProperties().convergent; getProperties().convergent = {}; return attr; } ::mlir::Attribute removeNoUnwindAttr() { auto attr = getProperties().no_unwind; getProperties().no_unwind = {}; return attr; } ::mlir::Attribute removeWillReturnAttr() { auto attr = getProperties().will_return; getProperties().will_return = {}; return attr; } ::mlir::Attribute removeNoreturnAttr() { auto attr = getProperties().noreturn; getProperties().noreturn = {}; return attr; } ::mlir::Attribute removeReturnsTwiceAttr() { auto attr = getProperties().returns_twice; getProperties().returns_twice = {}; return attr; } ::mlir::Attribute removeHotAttr() { auto attr = getProperties().hot; getProperties().hot = {}; return attr; } ::mlir::Attribute removeColdAttr() { auto attr = getProperties().cold; getProperties().cold = {}; return attr; } ::mlir::Attribute removeNoduplicateAttr() { auto attr = getProperties().noduplicate; getProperties().noduplicate = {}; return attr; } ::mlir::Attribute removeNoCallerSavedRegistersAttr() { auto attr = getProperties().no_caller_saved_registers; getProperties().no_caller_saved_registers = {}; return attr; } ::mlir::Attribute removeNocallbackAttr() { auto attr = getProperties().nocallback; getProperties().nocallback = {}; return attr; } ::mlir::Attribute removeModularFormatAttr() { auto attr = getProperties().modular_format; getProperties().modular_format = {}; return attr; } ::mlir::Attribute removeNobuiltinsAttr() { auto attr = getProperties().nobuiltins; getProperties().nobuiltins = {}; return attr; } ::mlir::Attribute removeAllocsizeAttr() { auto attr = getProperties().allocsize; getProperties().allocsize = {}; return attr; } ::mlir::Attribute removeOptsizeAttr() { auto attr = getProperties().optsize; getProperties().optsize = {}; return attr; } ::mlir::Attribute removeMinsizeAttr() { auto attr = getProperties().minsize; getProperties().minsize = {}; return attr; } ::mlir::Attribute removeBuiltinAttr() { auto attr = getProperties().builtin; getProperties().builtin = {}; return attr; } ::mlir::Attribute removeNobuiltinAttr() { auto attr = getProperties().nobuiltin; getProperties().nobuiltin = {}; return attr; } ::mlir::Attribute removeSaveRegParamsAttr() { auto attr = getProperties().save_reg_params; getProperties().save_reg_params = {}; return attr; } ::mlir::Attribute removeZeroCallUsedRegsAttr() { auto attr = getProperties().zero_call_used_regs; getProperties().zero_call_used_regs = {}; return attr; } ::mlir::Attribute removeTrapFuncNameAttr() { auto attr = getProperties().trap_func_name; getProperties().trap_func_name = {}; return attr; } ::mlir::Attribute removeDefaultFuncAttrsAttr() { auto attr = getProperties().default_func_attrs; getProperties().default_func_attrs = {}; return attr; } ::mlir::Attribute removeOpBundleTagsAttr() { auto attr = getProperties().op_bundle_tags; getProperties().op_bundle_tags = {}; return attr; } ::mlir::Attribute removeArgAttrsAttr() { auto attr = getProperties().arg_attrs; getProperties().arg_attrs = {}; return attr; } ::mlir::Attribute removeResAttrsAttr() { auto attr = getProperties().res_attrs; getProperties().res_attrs = {}; return attr; } ::mlir::Attribute removeNoInlineAttr() { auto attr = getProperties().no_inline; getProperties().no_inline = {}; return attr; } ::mlir::Attribute removeAlwaysInlineAttr() { auto attr = getProperties().always_inline; getProperties().always_inline = {}; return attr; } ::mlir::Attribute removeInlineHintAttr() { auto attr = getProperties().inline_hint; getProperties().inline_hint = {}; return attr; } ::mlir::Attribute removeAccessGroupsAttr() { auto attr = getProperties().access_groups; getProperties().access_groups = {}; return attr; } ::mlir::Attribute removeAliasScopesAttr() { auto attr = getProperties().alias_scopes; getProperties().alias_scopes = {}; return attr; } ::mlir::Attribute removeNoaliasScopesAttr() { auto attr = getProperties().noalias_scopes; getProperties().noalias_scopes = {}; return attr; } ::mlir::Attribute removeTbaaAttr() { auto attr = getProperties().tbaa; getProperties().tbaa = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFuncOp func, ValueRange args); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFuncOp func, ValueRange args); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFuncOp func, ValueRange args); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFunctionType calleeType, ValueRange args); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFunctionType calleeType, ValueRange args); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFunctionType calleeType, ValueRange args); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange results, StringAttr callee, ValueRange args = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, TypeRange results, StringAttr callee, ValueRange args = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, TypeRange results, StringAttr callee, ValueRange args = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange results, FlatSymbolRefAttr callee, ValueRange args = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, TypeRange results, FlatSymbolRefAttr callee, ValueRange args = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, TypeRange results, FlatSymbolRefAttr callee, ValueRange args = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange results, StringRef callee, ValueRange args = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, TypeRange results, StringRef callee, ValueRange args = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, TypeRange results, StringRef callee, ValueRange args = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFunctionType calleeType, StringAttr callee, ValueRange args = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFunctionType calleeType, StringAttr callee, ValueRange args = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFunctionType calleeType, StringAttr callee, ValueRange args = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange args = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange args = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange args = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFunctionType calleeType, StringRef callee, ValueRange args = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFunctionType calleeType, StringRef callee, ValueRange args = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFunctionType calleeType, StringRef callee, ValueRange args = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::mlir::LLVM::CConvAttr CConv, ::mlir::LLVM::TailCallKindAttr TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/::mlir::UnitAttr convergent, /*optional*/::mlir::UnitAttr no_unwind, /*optional*/::mlir::UnitAttr will_return, /*optional*/::mlir::UnitAttr noreturn, /*optional*/::mlir::UnitAttr returns_twice, /*optional*/::mlir::UnitAttr hot, /*optional*/::mlir::UnitAttr cold, /*optional*/::mlir::UnitAttr noduplicate, /*optional*/::mlir::UnitAttr no_caller_saved_registers, /*optional*/::mlir::UnitAttr nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/::mlir::UnitAttr optsize, /*optional*/::mlir::UnitAttr minsize, /*optional*/::mlir::UnitAttr builtin, /*optional*/::mlir::UnitAttr nobuiltin, /*optional*/::mlir::UnitAttr save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/::mlir::UnitAttr no_inline, /*optional*/::mlir::UnitAttr always_inline, /*optional*/::mlir::UnitAttr inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::mlir::LLVM::CConvAttr CConv, ::mlir::LLVM::TailCallKindAttr TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/::mlir::UnitAttr convergent, /*optional*/::mlir::UnitAttr no_unwind, /*optional*/::mlir::UnitAttr will_return, /*optional*/::mlir::UnitAttr noreturn, /*optional*/::mlir::UnitAttr returns_twice, /*optional*/::mlir::UnitAttr hot, /*optional*/::mlir::UnitAttr cold, /*optional*/::mlir::UnitAttr noduplicate, /*optional*/::mlir::UnitAttr no_caller_saved_registers, /*optional*/::mlir::UnitAttr nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/::mlir::UnitAttr optsize, /*optional*/::mlir::UnitAttr minsize, /*optional*/::mlir::UnitAttr builtin, /*optional*/::mlir::UnitAttr nobuiltin, /*optional*/::mlir::UnitAttr save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/::mlir::UnitAttr no_inline, /*optional*/::mlir::UnitAttr always_inline, /*optional*/::mlir::UnitAttr inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::mlir::LLVM::CConvAttr CConv, ::mlir::LLVM::TailCallKindAttr TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/::mlir::UnitAttr convergent, /*optional*/::mlir::UnitAttr no_unwind, /*optional*/::mlir::UnitAttr will_return, /*optional*/::mlir::UnitAttr noreturn, /*optional*/::mlir::UnitAttr returns_twice, /*optional*/::mlir::UnitAttr hot, /*optional*/::mlir::UnitAttr cold, /*optional*/::mlir::UnitAttr noduplicate, /*optional*/::mlir::UnitAttr no_caller_saved_registers, /*optional*/::mlir::UnitAttr nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/::mlir::UnitAttr optsize, /*optional*/::mlir::UnitAttr minsize, /*optional*/::mlir::UnitAttr builtin, /*optional*/::mlir::UnitAttr nobuiltin, /*optional*/::mlir::UnitAttr save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/::mlir::UnitAttr no_inline, /*optional*/::mlir::UnitAttr always_inline, /*optional*/::mlir::UnitAttr inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::mlir::LLVM::CConvAttr CConv, ::mlir::LLVM::TailCallKindAttr TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/::mlir::UnitAttr convergent, /*optional*/::mlir::UnitAttr no_unwind, /*optional*/::mlir::UnitAttr will_return, /*optional*/::mlir::UnitAttr noreturn, /*optional*/::mlir::UnitAttr returns_twice, /*optional*/::mlir::UnitAttr hot, /*optional*/::mlir::UnitAttr cold, /*optional*/::mlir::UnitAttr noduplicate, /*optional*/::mlir::UnitAttr no_caller_saved_registers, /*optional*/::mlir::UnitAttr nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/::mlir::UnitAttr optsize, /*optional*/::mlir::UnitAttr minsize, /*optional*/::mlir::UnitAttr builtin, /*optional*/::mlir::UnitAttr nobuiltin, /*optional*/::mlir::UnitAttr save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/::mlir::UnitAttr no_inline, /*optional*/::mlir::UnitAttr always_inline, /*optional*/::mlir::UnitAttr inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::mlir::LLVM::CConvAttr CConv, ::mlir::LLVM::TailCallKindAttr TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/::mlir::UnitAttr convergent, /*optional*/::mlir::UnitAttr no_unwind, /*optional*/::mlir::UnitAttr will_return, /*optional*/::mlir::UnitAttr noreturn, /*optional*/::mlir::UnitAttr returns_twice, /*optional*/::mlir::UnitAttr hot, /*optional*/::mlir::UnitAttr cold, /*optional*/::mlir::UnitAttr noduplicate, /*optional*/::mlir::UnitAttr no_caller_saved_registers, /*optional*/::mlir::UnitAttr nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/::mlir::UnitAttr optsize, /*optional*/::mlir::UnitAttr minsize, /*optional*/::mlir::UnitAttr builtin, /*optional*/::mlir::UnitAttr nobuiltin, /*optional*/::mlir::UnitAttr save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/::mlir::UnitAttr no_inline, /*optional*/::mlir::UnitAttr always_inline, /*optional*/::mlir::UnitAttr inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags, ::mlir::LLVM::CConvAttr CConv, ::mlir::LLVM::TailCallKindAttr TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/::mlir::UnitAttr convergent, /*optional*/::mlir::UnitAttr no_unwind, /*optional*/::mlir::UnitAttr will_return, /*optional*/::mlir::UnitAttr noreturn, /*optional*/::mlir::UnitAttr returns_twice, /*optional*/::mlir::UnitAttr hot, /*optional*/::mlir::UnitAttr cold, /*optional*/::mlir::UnitAttr noduplicate, /*optional*/::mlir::UnitAttr no_caller_saved_registers, /*optional*/::mlir::UnitAttr nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/::mlir::UnitAttr optsize, /*optional*/::mlir::UnitAttr minsize, /*optional*/::mlir::UnitAttr builtin, /*optional*/::mlir::UnitAttr nobuiltin, /*optional*/::mlir::UnitAttr save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/::mlir::UnitAttr no_inline, /*optional*/::mlir::UnitAttr always_inline, /*optional*/::mlir::UnitAttr inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlags fastmathFlags, ::mlir::LLVM::cconv::CConv CConv, ::mlir::LLVM::tailcallkind::TailCallKind TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/bool convergent, /*optional*/bool no_unwind, /*optional*/bool will_return, /*optional*/bool noreturn, /*optional*/bool returns_twice, /*optional*/bool hot, /*optional*/bool cold, /*optional*/bool noduplicate, /*optional*/bool no_caller_saved_registers, /*optional*/bool nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/bool optsize, /*optional*/bool minsize, /*optional*/bool builtin, /*optional*/bool nobuiltin, /*optional*/bool save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/bool no_inline, /*optional*/bool always_inline, /*optional*/bool inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlags fastmathFlags, ::mlir::LLVM::cconv::CConv CConv, ::mlir::LLVM::tailcallkind::TailCallKind TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/bool convergent, /*optional*/bool no_unwind, /*optional*/bool will_return, /*optional*/bool noreturn, /*optional*/bool returns_twice, /*optional*/bool hot, /*optional*/bool cold, /*optional*/bool noduplicate, /*optional*/bool no_caller_saved_registers, /*optional*/bool nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/bool optsize, /*optional*/bool minsize, /*optional*/bool builtin, /*optional*/bool nobuiltin, /*optional*/bool save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/bool no_inline, /*optional*/bool always_inline, /*optional*/bool inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlags fastmathFlags, ::mlir::LLVM::cconv::CConv CConv, ::mlir::LLVM::tailcallkind::TailCallKind TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/bool convergent, /*optional*/bool no_unwind, /*optional*/bool will_return, /*optional*/bool noreturn, /*optional*/bool returns_twice, /*optional*/bool hot, /*optional*/bool cold, /*optional*/bool noduplicate, /*optional*/bool no_caller_saved_registers, /*optional*/bool nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/bool optsize, /*optional*/bool minsize, /*optional*/bool builtin, /*optional*/bool nobuiltin, /*optional*/bool save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/bool no_inline, /*optional*/bool always_inline, /*optional*/bool inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlags fastmathFlags, ::mlir::LLVM::cconv::CConv CConv, ::mlir::LLVM::tailcallkind::TailCallKind TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/bool convergent, /*optional*/bool no_unwind, /*optional*/bool will_return, /*optional*/bool noreturn, /*optional*/bool returns_twice, /*optional*/bool hot, /*optional*/bool cold, /*optional*/bool noduplicate, /*optional*/bool no_caller_saved_registers, /*optional*/bool nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/bool optsize, /*optional*/bool minsize, /*optional*/bool builtin, /*optional*/bool nobuiltin, /*optional*/bool save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/bool no_inline, /*optional*/bool always_inline, /*optional*/bool inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlags fastmathFlags, ::mlir::LLVM::cconv::CConv CConv, ::mlir::LLVM::tailcallkind::TailCallKind TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/bool convergent, /*optional*/bool no_unwind, /*optional*/bool will_return, /*optional*/bool noreturn, /*optional*/bool returns_twice, /*optional*/bool hot, /*optional*/bool cold, /*optional*/bool noduplicate, /*optional*/bool no_caller_saved_registers, /*optional*/bool nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/bool optsize, /*optional*/bool minsize, /*optional*/bool builtin, /*optional*/bool nobuiltin, /*optional*/bool save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/bool no_inline, /*optional*/bool always_inline, /*optional*/bool inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, ::mlir::LLVM::FastmathFlags fastmathFlags, ::mlir::LLVM::cconv::CConv CConv, ::mlir::LLVM::tailcallkind::TailCallKind TailCallKind, /*optional*/::mlir::LLVM::MemoryEffectsAttr memory_effects, /*optional*/bool convergent, /*optional*/bool no_unwind, /*optional*/bool will_return, /*optional*/bool noreturn, /*optional*/bool returns_twice, /*optional*/bool hot, /*optional*/bool cold, /*optional*/bool noduplicate, /*optional*/bool no_caller_saved_registers, /*optional*/bool nocallback, /*optional*/::mlir::StringAttr modular_format, /*optional*/::mlir::ArrayAttr nobuiltins, /*optional*/::mlir::DenseI32ArrayAttr allocsize, /*optional*/bool optsize, /*optional*/bool minsize, /*optional*/bool builtin, /*optional*/bool nobuiltin, /*optional*/bool save_reg_params, /*optional*/::mlir::StringAttr zero_call_used_regs, /*optional*/::mlir::StringAttr trap_func_name, /*optional*/::mlir::DictionaryAttr default_func_attrs, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, /*optional*/bool no_inline, /*optional*/bool always_inline, /*optional*/bool inline_hint, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static CallOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static CallOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::SmallVector<::mlir::Value> getAccessedOperands(); ::mlir::CallInterfaceCallable getCallableForCallee(); void setCalleeFromCallable(::mlir::CallInterfaceCallable callee); ::mlir::Operation::operand_range getArgOperands(); ::mlir::MutableOperandRange getArgOperandsMutable(); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 38 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Returns the callee function type. LLVMFunctionType getCalleeFunctionType(); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::CallOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::CallOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ComdatOp declarations //===----------------------------------------------------------------------===// namespace detail { class ComdatOpGenericAdaptorBase { public: struct Properties { using sym_nameTy = ::mlir::StringAttr; sym_nameTy sym_name; auto getSymName() const { auto &propStorage = this->sym_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setSymName(const ::mlir::StringAttr &propValue) { this->sym_name = propValue; } bool operator==(const Properties &rhs) const { return rhs.sym_name == this->sym_name && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ComdatOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.comdat", odsAttrs.getContext()); } ComdatOpGenericAdaptorBase(ComdatOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getSymNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); return attr; } ::llvm::StringRef getSymName(); ::mlir::Region &getBody() { return *odsRegions[0]; } ::mlir::RegionRange getRegions() { return odsRegions; } }; } // namespace detail template class ComdatOpGenericAdaptor : public detail::ComdatOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ComdatOpGenericAdaptorBase; public: ComdatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ComdatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ComdatOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ComdatOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ComdatOpGenericAdaptor(values, attrs, Properties{}, {}) {} ComdatOpGenericAdaptor(RangeT values, const ComdatOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ComdatOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ComdatOpAdaptor : public ComdatOpGenericAdaptor<::mlir::ValueRange> { public: using ComdatOpGenericAdaptor::ComdatOpGenericAdaptor; ComdatOpAdaptor(ComdatOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ComdatOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = ComdatOpAdaptor; template using GenericAdaptor = ComdatOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("sym_name")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getSymNameAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getSymNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.comdat"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Region &getBody() { return (*this)->getRegion(0); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getSymNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); } ::llvm::StringRef getSymName(); void setSymNameAttr(::mlir::StringAttr attr) { getProperties().sym_name = attr; } void setSymName(::llvm::StringRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, StringRef symName); static ComdatOp create(::mlir::OpBuilder &builder, ::mlir::Location location, StringRef symName); static ComdatOp create(::mlir::ImplicitLocOpBuilder &builder, StringRef symName); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verifyRegions(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ComdatOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ComdatOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ComdatSelectorOp declarations //===----------------------------------------------------------------------===// namespace detail { class ComdatSelectorOpGenericAdaptorBase { public: struct Properties { using comdatTy = ::mlir::LLVM::comdat::ComdatAttr; comdatTy comdat; auto getComdat() const { auto &propStorage = this->comdat; return ::llvm::cast<::mlir::LLVM::comdat::ComdatAttr>(propStorage); } void setComdat(const ::mlir::LLVM::comdat::ComdatAttr &propValue) { this->comdat = propValue; } using sym_nameTy = ::mlir::StringAttr; sym_nameTy sym_name; auto getSymName() const { auto &propStorage = this->sym_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setSymName(const ::mlir::StringAttr &propValue) { this->sym_name = propValue; } bool operator==(const Properties &rhs) const { return rhs.comdat == this->comdat && rhs.sym_name == this->sym_name && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ComdatSelectorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.comdat_selector", odsAttrs.getContext()); } ComdatSelectorOpGenericAdaptorBase(ComdatSelectorOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getSymNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); return attr; } ::llvm::StringRef getSymName(); ::mlir::LLVM::comdat::ComdatAttr getComdatAttr() { auto attr = ::llvm::cast<::mlir::LLVM::comdat::ComdatAttr>(getProperties().comdat); return attr; } ::mlir::LLVM::comdat::Comdat getComdat(); }; } // namespace detail template class ComdatSelectorOpGenericAdaptor : public detail::ComdatSelectorOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ComdatSelectorOpGenericAdaptorBase; public: ComdatSelectorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ComdatSelectorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ComdatSelectorOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ComdatSelectorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ComdatSelectorOpGenericAdaptor(values, attrs, Properties{}, {}) {} ComdatSelectorOpGenericAdaptor(RangeT values, const ComdatSelectorOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ComdatSelectorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ComdatSelectorOpAdaptor : public ComdatSelectorOpGenericAdaptor<::mlir::ValueRange> { public: using ComdatSelectorOpGenericAdaptor::ComdatSelectorOpGenericAdaptor; ComdatSelectorOpAdaptor(ComdatSelectorOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ComdatSelectorOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = ComdatSelectorOpAdaptor; template using GenericAdaptor = ComdatSelectorOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("comdat"), ::llvm::StringRef("sym_name")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getComdatAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getComdatAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getSymNameAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getSymNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.comdat_selector"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getSymNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); } ::llvm::StringRef getSymName(); ::mlir::LLVM::comdat::ComdatAttr getComdatAttr() { return ::llvm::cast<::mlir::LLVM::comdat::ComdatAttr>(getProperties().comdat); } ::mlir::LLVM::comdat::Comdat getComdat(); void setSymNameAttr(::mlir::StringAttr attr) { getProperties().sym_name = attr; } void setSymName(::llvm::StringRef attrValue); void setComdatAttr(::mlir::LLVM::comdat::ComdatAttr attr) { getProperties().comdat = attr; } void setComdat(::mlir::LLVM::comdat::Comdat attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::StringAttr sym_name, ::mlir::LLVM::comdat::ComdatAttr comdat); static ComdatSelectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::StringAttr sym_name, ::mlir::LLVM::comdat::ComdatAttr comdat); static ComdatSelectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::StringAttr sym_name, ::mlir::LLVM::comdat::ComdatAttr comdat); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::StringAttr sym_name, ::mlir::LLVM::comdat::ComdatAttr comdat); static ComdatSelectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::StringAttr sym_name, ::mlir::LLVM::comdat::ComdatAttr comdat); static ComdatSelectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::StringAttr sym_name, ::mlir::LLVM::comdat::ComdatAttr comdat); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::StringRef sym_name, ::mlir::LLVM::comdat::Comdat comdat); static ComdatSelectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::llvm::StringRef sym_name, ::mlir::LLVM::comdat::Comdat comdat); static ComdatSelectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::llvm::StringRef sym_name, ::mlir::LLVM::comdat::Comdat comdat); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef sym_name, ::mlir::LLVM::comdat::Comdat comdat); static ComdatSelectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::llvm::StringRef sym_name, ::mlir::LLVM::comdat::Comdat comdat); static ComdatSelectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::llvm::StringRef sym_name, ::mlir::LLVM::comdat::Comdat comdat); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ComdatSelectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ComdatSelectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ComdatSelectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ComdatSelectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 2 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ComdatSelectorOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ComdatSelectorOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::CondBrOp declarations //===----------------------------------------------------------------------===// namespace detail { class CondBrOpGenericAdaptorBase { public: struct Properties { using branch_weightsTy = ::mlir::DenseI32ArrayAttr; branch_weightsTy branch_weights; auto getBranchWeights() const { auto &propStorage = this->branch_weights; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setBranchWeights(const ::mlir::DenseI32ArrayAttr &propValue) { this->branch_weights = propValue; } using loop_annotationTy = ::mlir::LLVM::LoopAnnotationAttr; loop_annotationTy loop_annotation; auto getLoopAnnotation() const { auto &propStorage = this->loop_annotation; return ::llvm::dyn_cast_or_null<::mlir::LLVM::LoopAnnotationAttr>(propStorage); } void setLoopAnnotation(const ::mlir::LLVM::LoopAnnotationAttr &propValue) { this->loop_annotation = propValue; } using operandSegmentSizesTy = std::array; operandSegmentSizesTy operandSegmentSizes; ::llvm::ArrayRef getOperandSegmentSizes() const { auto &propStorage = this->operandSegmentSizes; return propStorage; } void setOperandSegmentSizes(::llvm::ArrayRef propValue) { auto &propStorage = this->operandSegmentSizes; ::llvm::copy(propValue, propStorage.begin()); } bool operator==(const Properties &rhs) const { return rhs.branch_weights == this->branch_weights && rhs.loop_annotation == this->loop_annotation && rhs.operandSegmentSizes == this->operandSegmentSizes && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: CondBrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.cond_br", odsAttrs.getContext()); } CondBrOpGenericAdaptorBase(CondBrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::DenseI32ArrayAttr getBranchWeightsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().branch_weights); return attr; } ::std::optional<::llvm::ArrayRef> getBranchWeights(); ::mlir::LLVM::LoopAnnotationAttr getLoopAnnotationAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::LoopAnnotationAttr>(getProperties().loop_annotation); return attr; } ::std::optional<::mlir::LLVM::LoopAnnotationAttr> getLoopAnnotation(); }; } // namespace detail template class CondBrOpGenericAdaptor : public detail::CondBrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::CondBrOpGenericAdaptorBase; static constexpr int odsIndex_condition = 0; static constexpr int odsIndex_trueDestOperands = 1; static constexpr int odsIndex_falseDestOperands = 2; public: CondBrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} CondBrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : CondBrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} CondBrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs) : CondBrOpGenericAdaptor(values, attrs, Properties{}, {}) {} CondBrOpGenericAdaptor(RangeT values, const CondBrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> CondBrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getCondition() { return (*getODSOperands(0).begin()); } RangeT getTrueDestOperands() { return getODSOperands(1); } RangeT getFalseDestOperands() { return getODSOperands(2); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class CondBrOpAdaptor : public CondBrOpGenericAdaptor<::mlir::ValueRange> { public: using CondBrOpGenericAdaptor::CondBrOpGenericAdaptor; CondBrOpAdaptor(CondBrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class CondBrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::BranchOpInterface::Trait, ::mlir::WeightedBranchOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { public: using Op::Op; using Op::print; using Adaptor = CondBrOpAdaptor; template using GenericAdaptor = CondBrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_condition = 0; static constexpr int odsIndex_trueDestOperands = 1; static constexpr int odsIndex_falseDestOperands = 2; using Properties = FoldAdaptor::Properties; using ::mlir::BranchOpInterface::Trait::getSuccessorForOperands; using ::mlir::BranchOpInterface::Trait::areTypesCompatible; using ::mlir::WeightedBranchOpInterface::Trait::getWeights; using ::mlir::WeightedBranchOpInterface::Trait::setWeights; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("branch_weights"), ::llvm::StringRef("loop_annotation"), ::llvm::StringRef("operandSegmentSizes")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getBranchWeightsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getBranchWeightsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getLoopAnnotationAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getLoopAnnotationAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getOperandSegmentSizesAttrName() { return (*this)->getName().getAttributeNames().back(); } static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) { return name.getAttributeNames().back(); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.cond_br"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::IntegerType> getCondition() { return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(0).begin()); } ::mlir::Operation::operand_range getTrueDestOperands() { return getODSOperands(1); } ::mlir::Operation::operand_range getFalseDestOperands() { return getODSOperands(2); } ::mlir::OpOperand &getConditionMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::MutableOperandRange getTrueDestOperandsMutable(); ::mlir::MutableOperandRange getFalseDestOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Block *getTrueDest() { return (*this)->getSuccessor(0); } ::mlir::Block *getFalseDest() { return (*this)->getSuccessor(1); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::DenseI32ArrayAttr getBranchWeightsAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().branch_weights); } ::std::optional<::llvm::ArrayRef> getBranchWeights(); ::mlir::LLVM::LoopAnnotationAttr getLoopAnnotationAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::LoopAnnotationAttr>(getProperties().loop_annotation); } ::std::optional<::mlir::LLVM::LoopAnnotationAttr> getLoopAnnotation(); void setBranchWeightsAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().branch_weights = attr; } void setBranchWeights(::std::optional<::llvm::ArrayRef> attrValue); void setLoopAnnotationAttr(::mlir::LLVM::LoopAnnotationAttr attr) { getProperties().loop_annotation = attr; } ::mlir::Attribute removeBranchWeightsAttr() { auto attr = getProperties().branch_weights; getProperties().branch_weights = {}; return attr; } ::mlir::Attribute removeLoopAnnotationAttr() { auto attr = getProperties().loop_annotation; getProperties().loop_annotation = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value condition, Block *trueDest, ValueRange trueOperands, Block *falseDest, ValueRange falseOperands, std::optional> weights = {}); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value condition, Block *trueDest, ValueRange trueOperands, Block *falseDest, ValueRange falseOperands, std::optional> weights = {}); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, Value condition, Block *trueDest, ValueRange trueOperands, Block *falseDest, ValueRange falseOperands, std::optional> weights = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value condition, Block *trueDest, Block *falseDest, ValueRange falseOperands = {}); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value condition, Block *trueDest, Block *falseDest, ValueRange falseOperands = {}); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, Value condition, Block *trueDest, Block *falseDest, ValueRange falseOperands = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value condition, ValueRange trueOperands, ValueRange falseOperands, DenseI32ArrayAttr branchWeights, Block *trueDest, Block *falseDest); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value condition, ValueRange trueOperands, ValueRange falseOperands, DenseI32ArrayAttr branchWeights, Block *trueDest, Block *falseDest); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, Value condition, ValueRange trueOperands, ValueRange falseOperands, DenseI32ArrayAttr branchWeights, Block *trueDest, Block *falseDest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value condition, ::mlir::ValueRange trueDestOperands, ::mlir::ValueRange falseDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *trueDest, ::mlir::Block *falseDest); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value condition, ::mlir::ValueRange trueDestOperands, ::mlir::ValueRange falseDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *trueDest, ::mlir::Block *falseDest); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value condition, ::mlir::ValueRange trueDestOperands, ::mlir::ValueRange falseDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *trueDest, ::mlir::Block *falseDest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::ValueRange trueDestOperands, ::mlir::ValueRange falseDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *trueDest, ::mlir::Block *falseDest); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::ValueRange trueDestOperands, ::mlir::ValueRange falseDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *trueDest, ::mlir::Block *falseDest); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::ValueRange trueDestOperands, ::mlir::ValueRange falseDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, /*optional*/::mlir::LLVM::LoopAnnotationAttr loop_annotation, ::mlir::Block *trueDest, ::mlir::Block *falseDest); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static CondBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static CondBrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::SuccessorOperands getSuccessorOperands(unsigned index); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 2 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::CondBrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::CondBrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ConstantOp declarations //===----------------------------------------------------------------------===// namespace detail { class ConstantOpGenericAdaptorBase { public: struct Properties { using valueTy = ::mlir::Attribute; valueTy value; auto getValue() const { auto &propStorage = this->value; return ::llvm::cast<::mlir::Attribute>(propStorage); } void setValue(const ::mlir::Attribute &propValue) { this->value = propValue; } bool operator==(const Properties &rhs) const { return rhs.value == this->value && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ConstantOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.constant", odsAttrs.getContext()); } ConstantOpGenericAdaptorBase(ConstantOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::Attribute getValueAttr() { auto attr = ::llvm::cast<::mlir::Attribute>(getProperties().value); return attr; } ::mlir::Attribute getValue(); }; } // namespace detail template class ConstantOpGenericAdaptor : public detail::ConstantOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ConstantOpGenericAdaptorBase; public: ConstantOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ConstantOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ConstantOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ConstantOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ConstantOpGenericAdaptor(values, attrs, Properties{}, {}) {} ConstantOpGenericAdaptor(RangeT values, const ConstantOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ConstantOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ConstantOpAdaptor : public ConstantOpGenericAdaptor<::mlir::ValueRange> { public: using ConstantOpGenericAdaptor::ConstantOpGenericAdaptor; ConstantOpAdaptor(ConstantOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ConstantOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike> { public: using Op::Op; using Op::print; using Adaptor = ConstantOpAdaptor; template using GenericAdaptor = ConstantOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("value")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getValueAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getValueAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.constant"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::Attribute getValueAttr() { return ::llvm::cast<::mlir::Attribute>(getProperties().value); } ::mlir::Attribute getValue(); void setValueAttr(::mlir::Attribute attr) { getProperties().value = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type type, int64_t value); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type type, int64_t value); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, Type type, int64_t value); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type type, const APInt &value); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type type, const APInt &value); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, Type type, const APInt &value); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type type, const APFloat &value); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type type, const APFloat &value); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, Type type, const APFloat &value); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypedAttr value); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, TypedAttr value); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, TypedAttr value); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Attribute value); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Attribute value); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Attribute value); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Attribute value); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Attribute value); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Attribute value); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ConstantOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ConstantOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Whether the constant op can be constructed with a particular value and /// type. static bool isBuildableWith(Attribute value, Type type); /// Build the constant op with `value` and `type` if possible, otherwise /// returns null. static ConstantOp materialize(OpBuilder &builder, Attribute value, Type type, Location loc); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ConstantOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ConstantOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::DSOLocalEquivalentOp declarations //===----------------------------------------------------------------------===// namespace detail { class DSOLocalEquivalentOpGenericAdaptorBase { public: struct Properties { using function_nameTy = ::mlir::FlatSymbolRefAttr; function_nameTy function_name; auto getFunctionName() const { auto &propStorage = this->function_name; return ::llvm::cast<::mlir::FlatSymbolRefAttr>(propStorage); } void setFunctionName(const ::mlir::FlatSymbolRefAttr &propValue) { this->function_name = propValue; } bool operator==(const Properties &rhs) const { return rhs.function_name == this->function_name && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: DSOLocalEquivalentOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.dso_local_equivalent", odsAttrs.getContext()); } DSOLocalEquivalentOpGenericAdaptorBase(DSOLocalEquivalentOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::FlatSymbolRefAttr getFunctionNameAttr() { auto attr = ::llvm::cast<::mlir::FlatSymbolRefAttr>(getProperties().function_name); return attr; } ::llvm::StringRef getFunctionName(); }; } // namespace detail template class DSOLocalEquivalentOpGenericAdaptor : public detail::DSOLocalEquivalentOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::DSOLocalEquivalentOpGenericAdaptorBase; public: DSOLocalEquivalentOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} DSOLocalEquivalentOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : DSOLocalEquivalentOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} DSOLocalEquivalentOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : DSOLocalEquivalentOpGenericAdaptor(values, attrs, Properties{}, {}) {} DSOLocalEquivalentOpGenericAdaptor(RangeT values, const DSOLocalEquivalentOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> DSOLocalEquivalentOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class DSOLocalEquivalentOpAdaptor : public DSOLocalEquivalentOpGenericAdaptor<::mlir::ValueRange> { public: using DSOLocalEquivalentOpGenericAdaptor::DSOLocalEquivalentOpGenericAdaptor; DSOLocalEquivalentOpAdaptor(DSOLocalEquivalentOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class DSOLocalEquivalentOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike, ::mlir::SymbolUserOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = DSOLocalEquivalentOpAdaptor; template using GenericAdaptor = DSOLocalEquivalentOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("function_name")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFunctionNameAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFunctionNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.dso_local_equivalent"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::FlatSymbolRefAttr getFunctionNameAttr() { return ::llvm::cast<::mlir::FlatSymbolRefAttr>(getProperties().function_name); } ::llvm::StringRef getFunctionName(); void setFunctionNameAttr(::mlir::FlatSymbolRefAttr attr) { getProperties().function_name = attr; } void setFunctionName(::llvm::StringRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::FlatSymbolRefAttr function_name); static DSOLocalEquivalentOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::FlatSymbolRefAttr function_name); static DSOLocalEquivalentOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::FlatSymbolRefAttr function_name); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::FlatSymbolRefAttr function_name); static DSOLocalEquivalentOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::FlatSymbolRefAttr function_name); static DSOLocalEquivalentOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::FlatSymbolRefAttr function_name); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::llvm::StringRef function_name); static DSOLocalEquivalentOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::llvm::StringRef function_name); static DSOLocalEquivalentOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::llvm::StringRef function_name); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef function_name); static DSOLocalEquivalentOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::llvm::StringRef function_name); static DSOLocalEquivalentOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::llvm::StringRef function_name); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static DSOLocalEquivalentOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static DSOLocalEquivalentOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static DSOLocalEquivalentOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static DSOLocalEquivalentOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Return the llvm.func operation that is referenced here. LLVMFuncOp getFunction(SymbolTableCollection &symbolTable); /// Return the llvm.mlir.alias operation that defined the value referenced /// here. AliasOp getAlias(SymbolTableCollection &symbolTable); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::DSOLocalEquivalentOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::DSOLocalEquivalentOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ExtractElementOp declarations //===----------------------------------------------------------------------===// namespace detail { class ExtractElementOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ExtractElementOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.extractelement", odsAttrs.getContext()); } ExtractElementOpGenericAdaptorBase(ExtractElementOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class ExtractElementOpGenericAdaptor : public detail::ExtractElementOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ExtractElementOpGenericAdaptorBase; static constexpr int odsIndex_vector = 0; static constexpr int odsIndex_position = 1; public: ExtractElementOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ExtractElementOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ExtractElementOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ExtractElementOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ExtractElementOpGenericAdaptor(values, attrs, Properties{}, {}) {} ExtractElementOpGenericAdaptor(RangeT values, const ExtractElementOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ExtractElementOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getVector() { return (*getODSOperands(0).begin()); } ValueT getPosition() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ExtractElementOpAdaptor : public ExtractElementOpGenericAdaptor<::mlir::ValueRange> { public: using ExtractElementOpGenericAdaptor::ExtractElementOpGenericAdaptor; ExtractElementOpAdaptor(ExtractElementOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ExtractElementOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = ExtractElementOpAdaptor; template using GenericAdaptor = ExtractElementOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_vector = 0; static constexpr int odsIndex_position = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.extractelement"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::VectorType> getVector() { return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::IntegerType> getPosition() { return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getVectorMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getPositionMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value position); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value position); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value vector, ::mlir::Value position); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value vector, ::mlir::Value position); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value vector, ::mlir::Value position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value position); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value position); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value position); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ExtractElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ExtractElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ExtractElementOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ExtractValueOp declarations //===----------------------------------------------------------------------===// namespace detail { class ExtractValueOpGenericAdaptorBase { public: struct Properties { using positionTy = ::mlir::DenseI64ArrayAttr; positionTy position; auto getPosition() const { auto &propStorage = this->position; return ::llvm::cast<::mlir::DenseI64ArrayAttr>(propStorage); } void setPosition(const ::mlir::DenseI64ArrayAttr &propValue) { this->position = propValue; } bool operator==(const Properties &rhs) const { return rhs.position == this->position && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ExtractValueOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.extractvalue", odsAttrs.getContext()); } ExtractValueOpGenericAdaptorBase(ExtractValueOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::DenseI64ArrayAttr getPositionAttr() { auto attr = ::llvm::cast<::mlir::DenseI64ArrayAttr>(getProperties().position); return attr; } ::llvm::ArrayRef getPosition(); }; } // namespace detail template class ExtractValueOpGenericAdaptor : public detail::ExtractValueOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ExtractValueOpGenericAdaptorBase; static constexpr int odsIndex_container = 0; public: ExtractValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ExtractValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ExtractValueOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ExtractValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ExtractValueOpGenericAdaptor(values, attrs, Properties{}, {}) {} ExtractValueOpGenericAdaptor(RangeT values, const ExtractValueOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ExtractValueOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getContainer() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ExtractValueOpAdaptor : public ExtractValueOpGenericAdaptor<::mlir::ValueRange> { public: using ExtractValueOpGenericAdaptor::ExtractValueOpGenericAdaptor; ExtractValueOpAdaptor(ExtractValueOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ExtractValueOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = ExtractValueOpAdaptor; template using GenericAdaptor = ExtractValueOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_container = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("position")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getPositionAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getPositionAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.extractvalue"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getContainer() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getContainerMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::DenseI64ArrayAttr getPositionAttr() { return ::llvm::cast<::mlir::DenseI64ArrayAttr>(getProperties().position); } ::llvm::ArrayRef getPosition(); void setPositionAttr(::mlir::DenseI64ArrayAttr attr) { getProperties().position = attr; } void setPosition(::llvm::ArrayRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value container, ArrayRef position); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value container, ArrayRef position); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, Value container, ArrayRef position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::DenseI64ArrayAttr position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::llvm::ArrayRef position); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::llvm::ArrayRef position); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::llvm::ArrayRef position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::llvm::ArrayRef position); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::llvm::ArrayRef position); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::llvm::ArrayRef position); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ExtractValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ExtractValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ExtractValueOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ExtractValueOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FAddOp declarations //===----------------------------------------------------------------------===// namespace detail { class FAddOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FAddOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fadd", odsAttrs.getContext()); } FAddOpGenericAdaptorBase(FAddOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FAddOpGenericAdaptor : public detail::FAddOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FAddOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: FAddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FAddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FAddOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FAddOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FAddOpGenericAdaptor(values, attrs, Properties{}, {}) {} FAddOpGenericAdaptor(RangeT values, const FAddOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FAddOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FAddOpAdaptor : public FAddOpGenericAdaptor<::mlir::ValueRange> { public: using FAddOpGenericAdaptor::FAddOpGenericAdaptor; FAddOpAdaptor(FAddOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FAddOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FAddOpAdaptor; template using GenericAdaptor = FAddOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fadd"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FAddOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FAddOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FAddOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FAddOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FCmpOp declarations //===----------------------------------------------------------------------===// namespace detail { class FCmpOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } using predicateTy = ::mlir::LLVM::FCmpPredicateAttr; predicateTy predicate; auto getPredicate() const { auto &propStorage = this->predicate; return ::llvm::cast<::mlir::LLVM::FCmpPredicateAttr>(propStorage); } void setPredicate(const ::mlir::LLVM::FCmpPredicateAttr &propValue) { this->predicate = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && rhs.predicate == this->predicate && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FCmpOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fcmp", odsAttrs.getContext()); } FCmpOpGenericAdaptorBase(FCmpOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FCmpPredicateAttr getPredicateAttr() { auto attr = ::llvm::cast<::mlir::LLVM::FCmpPredicateAttr>(getProperties().predicate); return attr; } ::mlir::LLVM::FCmpPredicate getPredicate(); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FCmpOpGenericAdaptor : public detail::FCmpOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FCmpOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: FCmpOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FCmpOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FCmpOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FCmpOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FCmpOpGenericAdaptor(values, attrs, Properties{}, {}) {} FCmpOpGenericAdaptor(RangeT values, const FCmpOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FCmpOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FCmpOpAdaptor : public FCmpOpGenericAdaptor<::mlir::ValueRange> { public: using FCmpOpGenericAdaptor::FCmpOpGenericAdaptor; FCmpOpAdaptor(FCmpOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FCmpOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::OpTrait::SameTypeOperands, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FCmpOpAdaptor; template using GenericAdaptor = FCmpOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags"), ::llvm::StringRef("predicate")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getPredicateAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getPredicateAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fcmp"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FCmpPredicateAttr getPredicateAttr() { return ::llvm::cast<::mlir::LLVM::FCmpPredicateAttr>(getProperties().predicate); } ::mlir::LLVM::FCmpPredicate getPredicate(); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setPredicateAttr(::mlir::LLVM::FCmpPredicateAttr attr) { getProperties().predicate = attr; } void setPredicate(::mlir::LLVM::FCmpPredicate attrValue); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::FCmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::FCmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FCmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FCmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 2 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FCmpOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FCmpOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FDivOp declarations //===----------------------------------------------------------------------===// namespace detail { class FDivOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FDivOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fdiv", odsAttrs.getContext()); } FDivOpGenericAdaptorBase(FDivOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FDivOpGenericAdaptor : public detail::FDivOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FDivOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: FDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FDivOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FDivOpGenericAdaptor(values, attrs, Properties{}, {}) {} FDivOpGenericAdaptor(RangeT values, const FDivOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FDivOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FDivOpAdaptor : public FDivOpGenericAdaptor<::mlir::ValueRange> { public: using FDivOpGenericAdaptor::FDivOpGenericAdaptor; FDivOpAdaptor(FDivOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FDivOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FDivOpAdaptor; template using GenericAdaptor = FDivOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fdiv"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FDivOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FDivOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FMulOp declarations //===----------------------------------------------------------------------===// namespace detail { class FMulOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FMulOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fmul", odsAttrs.getContext()); } FMulOpGenericAdaptorBase(FMulOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FMulOpGenericAdaptor : public detail::FMulOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FMulOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: FMulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FMulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FMulOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FMulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FMulOpGenericAdaptor(values, attrs, Properties{}, {}) {} FMulOpGenericAdaptor(RangeT values, const FMulOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FMulOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FMulOpAdaptor : public FMulOpGenericAdaptor<::mlir::ValueRange> { public: using FMulOpGenericAdaptor::FMulOpGenericAdaptor; FMulOpAdaptor(FMulOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FMulOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FMulOpAdaptor; template using GenericAdaptor = FMulOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fmul"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FMulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FMulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FMulOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FMulOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FNegOp declarations //===----------------------------------------------------------------------===// namespace detail { class FNegOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FNegOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fneg", odsAttrs.getContext()); } FNegOpGenericAdaptorBase(FNegOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FNegOpGenericAdaptor : public detail::FNegOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FNegOpGenericAdaptorBase; static constexpr int odsIndex_operand = 0; public: FNegOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FNegOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FNegOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FNegOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FNegOpGenericAdaptor(values, attrs, Properties{}, {}) {} FNegOpGenericAdaptor(RangeT values, const FNegOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FNegOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getOperand() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FNegOpAdaptor : public FNegOpGenericAdaptor<::mlir::ValueRange> { public: using FNegOpGenericAdaptor::FNegOpGenericAdaptor; FNegOpAdaptor(FNegOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FNegOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FNegOpAdaptor; template using GenericAdaptor = FNegOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_operand = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fneg"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getOperand() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getOperandMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value operand, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value operand, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FNegOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FNegOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FNegOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FNegOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FPExtOp declarations //===----------------------------------------------------------------------===// namespace detail { class FPExtOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FPExtOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fpext", odsAttrs.getContext()); } FPExtOpGenericAdaptorBase(FPExtOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FPExtOpGenericAdaptor : public detail::FPExtOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FPExtOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: FPExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FPExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FPExtOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FPExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FPExtOpGenericAdaptor(values, attrs, Properties{}, {}) {} FPExtOpGenericAdaptor(RangeT values, const FPExtOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FPExtOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FPExtOpAdaptor : public FPExtOpGenericAdaptor<::mlir::ValueRange> { public: using FPExtOpGenericAdaptor::FPExtOpGenericAdaptor; FPExtOpAdaptor(FPExtOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FPExtOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FPExtOpAdaptor; template using GenericAdaptor = FPExtOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fpext"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FPExtOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FPExtOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FPToSIOp declarations //===----------------------------------------------------------------------===// namespace detail { class FPToSIOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FPToSIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fptosi", odsAttrs.getContext()); } FPToSIOpGenericAdaptorBase(FPToSIOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class FPToSIOpGenericAdaptor : public detail::FPToSIOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FPToSIOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: FPToSIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FPToSIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FPToSIOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FPToSIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FPToSIOpGenericAdaptor(values, attrs, Properties{}, {}) {} FPToSIOpGenericAdaptor(RangeT values, const FPToSIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FPToSIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FPToSIOpAdaptor : public FPToSIOpGenericAdaptor<::mlir::ValueRange> { public: using FPToSIOpGenericAdaptor::FPToSIOpGenericAdaptor; FPToSIOpAdaptor(FPToSIOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FPToSIOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FPToSIOpAdaptor; template using GenericAdaptor = FPToSIOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fptosi"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPToSIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPToSIOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static FPToSIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static FPToSIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static FPToSIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static FPToSIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPToSIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPToSIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPToSIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPToSIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FPToSIOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FPToUIOp declarations //===----------------------------------------------------------------------===// namespace detail { class FPToUIOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FPToUIOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fptoui", odsAttrs.getContext()); } FPToUIOpGenericAdaptorBase(FPToUIOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class FPToUIOpGenericAdaptor : public detail::FPToUIOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FPToUIOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: FPToUIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FPToUIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FPToUIOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FPToUIOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FPToUIOpGenericAdaptor(values, attrs, Properties{}, {}) {} FPToUIOpGenericAdaptor(RangeT values, const FPToUIOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FPToUIOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FPToUIOpAdaptor : public FPToUIOpGenericAdaptor<::mlir::ValueRange> { public: using FPToUIOpGenericAdaptor::FPToUIOpGenericAdaptor; FPToUIOpAdaptor(FPToUIOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FPToUIOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FPToUIOpAdaptor; template using GenericAdaptor = FPToUIOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fptoui"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPToUIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPToUIOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static FPToUIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static FPToUIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static FPToUIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static FPToUIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPToUIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPToUIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPToUIOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPToUIOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FPToUIOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FPTruncOp declarations //===----------------------------------------------------------------------===// namespace detail { class FPTruncOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FPTruncOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fptrunc", odsAttrs.getContext()); } FPTruncOpGenericAdaptorBase(FPTruncOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FPTruncOpGenericAdaptor : public detail::FPTruncOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FPTruncOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: FPTruncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FPTruncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FPTruncOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FPTruncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FPTruncOpGenericAdaptor(values, attrs, Properties{}, {}) {} FPTruncOpGenericAdaptor(RangeT values, const FPTruncOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FPTruncOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FPTruncOpAdaptor : public FPTruncOpGenericAdaptor<::mlir::ValueRange> { public: using FPTruncOpGenericAdaptor::FPTruncOpGenericAdaptor; FPTruncOpAdaptor(FPTruncOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FPTruncOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FPTruncOpAdaptor; template using GenericAdaptor = FPTruncOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fptrunc"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPTruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FPTruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FPTruncOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FPTruncOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FRemOp declarations //===----------------------------------------------------------------------===// namespace detail { class FRemOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FRemOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.frem", odsAttrs.getContext()); } FRemOpGenericAdaptorBase(FRemOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FRemOpGenericAdaptor : public detail::FRemOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FRemOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: FRemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FRemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FRemOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FRemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FRemOpGenericAdaptor(values, attrs, Properties{}, {}) {} FRemOpGenericAdaptor(RangeT values, const FRemOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FRemOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FRemOpAdaptor : public FRemOpGenericAdaptor<::mlir::ValueRange> { public: using FRemOpGenericAdaptor::FRemOpGenericAdaptor; FRemOpAdaptor(FRemOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FRemOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FRemOpAdaptor; template using GenericAdaptor = FRemOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.frem"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FRemOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FRemOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FSubOp declarations //===----------------------------------------------------------------------===// namespace detail { class FSubOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FSubOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fsub", odsAttrs.getContext()); } FSubOpGenericAdaptorBase(FSubOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class FSubOpGenericAdaptor : public detail::FSubOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FSubOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: FSubOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FSubOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FSubOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FSubOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FSubOpGenericAdaptor(values, attrs, Properties{}, {}) {} FSubOpGenericAdaptor(RangeT values, const FSubOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FSubOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FSubOpAdaptor : public FSubOpGenericAdaptor<::mlir::ValueRange> { public: using FSubOpGenericAdaptor::FSubOpGenericAdaptor; FSubOpAdaptor(FSubOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FSubOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FSubOpAdaptor; template using GenericAdaptor = FSubOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fsub"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FSubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FSubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FSubOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FSubOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FenceOp declarations //===----------------------------------------------------------------------===// namespace detail { class FenceOpGenericAdaptorBase { public: struct Properties { using orderingTy = ::mlir::LLVM::AtomicOrderingAttr; orderingTy ordering; auto getOrdering() const { auto &propStorage = this->ordering; return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(propStorage); } void setOrdering(const ::mlir::LLVM::AtomicOrderingAttr &propValue) { this->ordering = propValue; } using syncscopeTy = ::mlir::StringAttr; syncscopeTy syncscope; auto getSyncscope() const { auto &propStorage = this->syncscope; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSyncscope(const ::mlir::StringAttr &propValue) { this->syncscope = propValue; } bool operator==(const Properties &rhs) const { return rhs.ordering == this->ordering && rhs.syncscope == this->syncscope && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FenceOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.fence", odsAttrs.getContext()); } FenceOpGenericAdaptorBase(FenceOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr() { auto attr = ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().ordering); return attr; } ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); return attr; } ::std::optional< ::llvm::StringRef > getSyncscope(); }; } // namespace detail template class FenceOpGenericAdaptor : public detail::FenceOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FenceOpGenericAdaptorBase; public: FenceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FenceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FenceOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FenceOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FenceOpGenericAdaptor(values, attrs, Properties{}, {}) {} FenceOpGenericAdaptor(RangeT values, const FenceOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FenceOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FenceOpAdaptor : public FenceOpGenericAdaptor<::mlir::ValueRange> { public: using FenceOpGenericAdaptor::FenceOpGenericAdaptor; FenceOpAdaptor(FenceOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FenceOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = FenceOpAdaptor; template using GenericAdaptor = FenceOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("ordering"), ::llvm::StringRef("syncscope")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getOrderingAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getOrderingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getSyncscopeAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getSyncscopeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.fence"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr() { return ::llvm::cast<::mlir::LLVM::AtomicOrderingAttr>(getProperties().ordering); } ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); } ::std::optional< ::llvm::StringRef > getSyncscope(); void setOrderingAttr(::mlir::LLVM::AtomicOrderingAttr attr) { getProperties().ordering = attr; } void setOrdering(::mlir::LLVM::AtomicOrdering attrValue); void setSyncscopeAttr(::mlir::StringAttr attr) { getProperties().syncscope = attr; } void setSyncscope(::std::optional<::llvm::StringRef> attrValue); ::mlir::Attribute removeSyncscopeAttr() { auto attr = getProperties().syncscope; getProperties().syncscope = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange operands, ArrayRef attributes = {}); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ValueRange operands, ArrayRef attributes = {}); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVM::AtomicOrdering ordering, StringRef syncscope = StringRef()); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVM::AtomicOrdering ordering, StringRef syncscope = StringRef()); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, LLVM::AtomicOrdering ordering, StringRef syncscope = StringRef()); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FenceOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FenceOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 2 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FenceOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::FenceOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::FreezeOp declarations //===----------------------------------------------------------------------===// namespace detail { class FreezeOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: FreezeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.freeze", odsAttrs.getContext()); } FreezeOpGenericAdaptorBase(FreezeOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class FreezeOpGenericAdaptor : public detail::FreezeOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::FreezeOpGenericAdaptorBase; static constexpr int odsIndex_val = 0; public: FreezeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} FreezeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : FreezeOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} FreezeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : FreezeOpGenericAdaptor(values, attrs, Properties{}, {}) {} FreezeOpGenericAdaptor(RangeT values, const FreezeOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> FreezeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getVal() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class FreezeOpAdaptor : public FreezeOpGenericAdaptor<::mlir::ValueRange> { public: using FreezeOpGenericAdaptor::FreezeOpGenericAdaptor; FreezeOpAdaptor(FreezeOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class FreezeOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = FreezeOpAdaptor; template using GenericAdaptor = FreezeOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_val = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.freeze"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getVal() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getValMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value val); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value val); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value val); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value val); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value val); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value val); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value val); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value val); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value val); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FreezeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static FreezeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::FreezeOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::GEPOp declarations //===----------------------------------------------------------------------===// namespace detail { class GEPOpGenericAdaptorBase { public: struct Properties { using elem_typeTy = ::mlir::TypeAttr; elem_typeTy elem_type; auto getElemType() const { auto &propStorage = this->elem_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setElemType(const ::mlir::TypeAttr &propValue) { this->elem_type = propValue; } using rawConstantIndicesTy = ::mlir::DenseI32ArrayAttr; rawConstantIndicesTy rawConstantIndices; auto getRawConstantIndices() const { auto &propStorage = this->rawConstantIndices; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setRawConstantIndices(const ::mlir::DenseI32ArrayAttr &propValue) { this->rawConstantIndices = propValue; } using noWrapFlagsTy = ::mlir::LLVM::GEPNoWrapFlags; noWrapFlagsTy noWrapFlags = ::mlir::LLVM::GEPNoWrapFlags::none; ::mlir::LLVM::GEPNoWrapFlags getNoWrapFlags() const { auto &propStorage = this->noWrapFlags; return propStorage; } void setNoWrapFlags(::mlir::LLVM::GEPNoWrapFlags propValue) { auto &propStorage = this->noWrapFlags; propStorage = propValue; } bool operator==(const Properties &rhs) const { return rhs.elem_type == this->elem_type && rhs.rawConstantIndices == this->rawConstantIndices && rhs.noWrapFlags == this->noWrapFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: GEPOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.getelementptr", odsAttrs.getContext()); } GEPOpGenericAdaptorBase(GEPOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::GEPNoWrapFlags getNoWrapFlags() { return getProperties().getNoWrapFlags(); } ::mlir::DenseI32ArrayAttr getRawConstantIndicesAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().rawConstantIndices); return attr; } ::llvm::ArrayRef getRawConstantIndices(); ::mlir::TypeAttr getElemTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().elem_type); return attr; } ::mlir::Type getElemType(); }; } // namespace detail template class GEPOpGenericAdaptor : public detail::GEPOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::GEPOpGenericAdaptorBase; static constexpr int odsIndex_base = 0; static constexpr int odsIndex_dynamicIndices = 1; public: GEPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} GEPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : GEPOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} GEPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : GEPOpGenericAdaptor(values, attrs, Properties{}, {}) {} GEPOpGenericAdaptor(RangeT values, const GEPOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> GEPOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getBase() { return (*getODSOperands(0).begin()); } RangeT getDynamicIndices() { return getODSOperands(1); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class GEPOpAdaptor : public GEPOpGenericAdaptor<::mlir::ValueRange> { public: using GEPOpGenericAdaptor::GEPOpGenericAdaptor; GEPOpAdaptor(GEPOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class GEPOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::PromotableOpInterface::Trait, ::mlir::SafeMemorySlotAccessOpInterface::Trait, ::mlir::DestructurableAccessorOpInterface::Trait, ::mlir::ViewLikeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = GEPOpAdaptor; template using GenericAdaptor = GEPOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_base = 0; static constexpr int odsIndex_dynamicIndices = 1; using Properties = FoldAdaptor::Properties; using ::mlir::PromotableOpInterface::Trait::requiresReplacedValues; using ::mlir::PromotableOpInterface::Trait::visitReplacedValues; using ::mlir::ViewLikeOpInterface::Trait::getViewDest; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("elem_type"), ::llvm::StringRef("rawConstantIndices")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getElemTypeAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getElemTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getRawConstantIndicesAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getRawConstantIndicesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.getelementptr"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getBase() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::Operation::operand_range getDynamicIndices() { return getODSOperands(1); } ::mlir::OpOperand &getBaseMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::MutableOperandRange getDynamicIndicesMutable(); std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::GEPNoWrapFlags getNoWrapFlags() { return getProperties().getNoWrapFlags(); } void setNoWrapFlags(::mlir::LLVM::GEPNoWrapFlags newNoWrapFlags) { getProperties().setNoWrapFlags(newNoWrapFlags); } ::mlir::DenseI32ArrayAttr getRawConstantIndicesAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().rawConstantIndices); } ::llvm::ArrayRef getRawConstantIndices(); ::mlir::TypeAttr getElemTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().elem_type); } ::mlir::Type getElemType(); void setRawConstantIndicesAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().rawConstantIndices = attr; } void setRawConstantIndices(::llvm::ArrayRef attrValue); void setElemTypeAttr(::mlir::TypeAttr attr) { getProperties().elem_type = attr; } void setElemType(::mlir::Type attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, Type elementType, Value basePtr, ValueRange indices, GEPNoWrapFlags noWrapFlags = GEPNoWrapFlags::none, ArrayRef attributes = {}); static GEPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, Type elementType, Value basePtr, ValueRange indices, GEPNoWrapFlags noWrapFlags = GEPNoWrapFlags::none, ArrayRef attributes = {}); static GEPOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, Type elementType, Value basePtr, ValueRange indices, GEPNoWrapFlags noWrapFlags = GEPNoWrapFlags::none, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, Type elementType, Value basePtr, ArrayRef indices, GEPNoWrapFlags noWrapFlags = GEPNoWrapFlags::none, ArrayRef attributes = {}); static GEPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, Type elementType, Value basePtr, ArrayRef indices, GEPNoWrapFlags noWrapFlags = GEPNoWrapFlags::none, ArrayRef attributes = {}); static GEPOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, Type elementType, Value basePtr, ArrayRef indices, GEPNoWrapFlags noWrapFlags = GEPNoWrapFlags::none, ArrayRef attributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); bool canUsesBeRemoved(const ::llvm::SmallPtrSetImpl<::mlir::OpOperand *> &blockingUses, ::llvm::SmallVectorImpl<::mlir::OpOperand *> &newBlockingUses, const ::mlir::DataLayout &datalayout); ::mlir::DeletionKind removeBlockingUses(const ::llvm::SmallPtrSetImpl &blockingUses, ::mlir::OpBuilder &builder); ::llvm::LogicalResult ensureOnlySafeAccesses(const ::mlir::MemorySlot &slot, ::mlir::SmallVectorImpl<::mlir::MemorySlot> &mustBeSafelyUsed, const ::mlir::DataLayout &dataLayout); 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); ::mlir::Value getViewSource(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 2 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: constexpr static int32_t kDynamicIndex = std::numeric_limits::min(); GEPIndicesAdaptor getIndices(); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::GEPOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::GEPOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::GlobalCtorsOp declarations //===----------------------------------------------------------------------===// namespace detail { class GlobalCtorsOpGenericAdaptorBase { public: struct Properties { using ctorsTy = ::mlir::ArrayAttr; ctorsTy ctors; auto getCtors() const { auto &propStorage = this->ctors; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setCtors(const ::mlir::ArrayAttr &propValue) { this->ctors = propValue; } using dataTy = ::mlir::ArrayAttr; dataTy data; auto getData() const { auto &propStorage = this->data; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setData(const ::mlir::ArrayAttr &propValue) { this->data = propValue; } using prioritiesTy = ::mlir::ArrayAttr; prioritiesTy priorities; auto getPriorities() const { auto &propStorage = this->priorities; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setPriorities(const ::mlir::ArrayAttr &propValue) { this->priorities = propValue; } bool operator==(const Properties &rhs) const { return rhs.ctors == this->ctors && rhs.data == this->data && rhs.priorities == this->priorities && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: GlobalCtorsOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.global_ctors", odsAttrs.getContext()); } GlobalCtorsOpGenericAdaptorBase(GlobalCtorsOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::ArrayAttr getCtorsAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().ctors); return attr; } ::mlir::ArrayAttr getCtors(); ::mlir::ArrayAttr getPrioritiesAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().priorities); return attr; } ::mlir::ArrayAttr getPriorities(); ::mlir::ArrayAttr getDataAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().data); return attr; } ::mlir::ArrayAttr getData(); }; } // namespace detail template class GlobalCtorsOpGenericAdaptor : public detail::GlobalCtorsOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::GlobalCtorsOpGenericAdaptorBase; public: GlobalCtorsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} GlobalCtorsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : GlobalCtorsOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} GlobalCtorsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : GlobalCtorsOpGenericAdaptor(values, attrs, Properties{}, {}) {} GlobalCtorsOpGenericAdaptor(RangeT values, const GlobalCtorsOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> GlobalCtorsOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class GlobalCtorsOpAdaptor : public GlobalCtorsOpGenericAdaptor<::mlir::ValueRange> { public: using GlobalCtorsOpGenericAdaptor::GlobalCtorsOpGenericAdaptor; GlobalCtorsOpAdaptor(GlobalCtorsOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class GlobalCtorsOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = GlobalCtorsOpAdaptor; template using GenericAdaptor = GlobalCtorsOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("ctors"), ::llvm::StringRef("data"), ::llvm::StringRef("priorities")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getCtorsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getCtorsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getDataAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getDataAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getPrioritiesAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getPrioritiesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.global_ctors"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::ArrayAttr getCtorsAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().ctors); } ::mlir::ArrayAttr getCtors(); ::mlir::ArrayAttr getPrioritiesAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().priorities); } ::mlir::ArrayAttr getPriorities(); ::mlir::ArrayAttr getDataAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().data); } ::mlir::ArrayAttr getData(); void setCtorsAttr(::mlir::ArrayAttr attr) { getProperties().ctors = attr; } void setPrioritiesAttr(::mlir::ArrayAttr attr) { getProperties().priorities = attr; } void setDataAttr(::mlir::ArrayAttr attr) { getProperties().data = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ArrayAttr ctors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalCtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ArrayAttr ctors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalCtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ArrayAttr ctors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr ctors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalCtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr ctors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalCtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr ctors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static GlobalCtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static GlobalCtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static GlobalCtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static GlobalCtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 3 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::GlobalCtorsOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::GlobalCtorsOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::GlobalDtorsOp declarations //===----------------------------------------------------------------------===// namespace detail { class GlobalDtorsOpGenericAdaptorBase { public: struct Properties { using dataTy = ::mlir::ArrayAttr; dataTy data; auto getData() const { auto &propStorage = this->data; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setData(const ::mlir::ArrayAttr &propValue) { this->data = propValue; } using dtorsTy = ::mlir::ArrayAttr; dtorsTy dtors; auto getDtors() const { auto &propStorage = this->dtors; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setDtors(const ::mlir::ArrayAttr &propValue) { this->dtors = propValue; } using prioritiesTy = ::mlir::ArrayAttr; prioritiesTy priorities; auto getPriorities() const { auto &propStorage = this->priorities; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setPriorities(const ::mlir::ArrayAttr &propValue) { this->priorities = propValue; } bool operator==(const Properties &rhs) const { return rhs.data == this->data && rhs.dtors == this->dtors && rhs.priorities == this->priorities && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: GlobalDtorsOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.global_dtors", odsAttrs.getContext()); } GlobalDtorsOpGenericAdaptorBase(GlobalDtorsOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::ArrayAttr getDtorsAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().dtors); return attr; } ::mlir::ArrayAttr getDtors(); ::mlir::ArrayAttr getPrioritiesAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().priorities); return attr; } ::mlir::ArrayAttr getPriorities(); ::mlir::ArrayAttr getDataAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().data); return attr; } ::mlir::ArrayAttr getData(); }; } // namespace detail template class GlobalDtorsOpGenericAdaptor : public detail::GlobalDtorsOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::GlobalDtorsOpGenericAdaptorBase; public: GlobalDtorsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} GlobalDtorsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : GlobalDtorsOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} GlobalDtorsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : GlobalDtorsOpGenericAdaptor(values, attrs, Properties{}, {}) {} GlobalDtorsOpGenericAdaptor(RangeT values, const GlobalDtorsOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> GlobalDtorsOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class GlobalDtorsOpAdaptor : public GlobalDtorsOpGenericAdaptor<::mlir::ValueRange> { public: using GlobalDtorsOpGenericAdaptor::GlobalDtorsOpGenericAdaptor; GlobalDtorsOpAdaptor(GlobalDtorsOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class GlobalDtorsOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = GlobalDtorsOpAdaptor; template using GenericAdaptor = GlobalDtorsOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("data"), ::llvm::StringRef("dtors"), ::llvm::StringRef("priorities")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getDataAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getDataAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getDtorsAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getDtorsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getPrioritiesAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getPrioritiesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.global_dtors"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::ArrayAttr getDtorsAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().dtors); } ::mlir::ArrayAttr getDtors(); ::mlir::ArrayAttr getPrioritiesAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().priorities); } ::mlir::ArrayAttr getPriorities(); ::mlir::ArrayAttr getDataAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().data); } ::mlir::ArrayAttr getData(); void setDtorsAttr(::mlir::ArrayAttr attr) { getProperties().dtors = attr; } void setPrioritiesAttr(::mlir::ArrayAttr attr) { getProperties().priorities = attr; } void setDataAttr(::mlir::ArrayAttr attr) { getProperties().data = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ArrayAttr dtors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalDtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ArrayAttr dtors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalDtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ArrayAttr dtors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr dtors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalDtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr dtors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static GlobalDtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr dtors, ::mlir::ArrayAttr priorities, ::mlir::ArrayAttr data); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static GlobalDtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static GlobalDtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static GlobalDtorsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static GlobalDtorsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 3 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::GlobalDtorsOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::GlobalDtorsOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::GlobalOp declarations //===----------------------------------------------------------------------===// namespace detail { class GlobalOpGenericAdaptorBase { public: struct Properties { using addr_spaceTy = ::mlir::IntegerAttr; addr_spaceTy addr_space; auto getAddrSpace() const { auto &propStorage = this->addr_space; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAddrSpace(const ::mlir::IntegerAttr &propValue) { this->addr_space = propValue; } using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using comdatTy = ::mlir::SymbolRefAttr; comdatTy comdat; auto getComdat() const { auto &propStorage = this->comdat; return ::llvm::dyn_cast_or_null<::mlir::SymbolRefAttr>(propStorage); } void setComdat(const ::mlir::SymbolRefAttr &propValue) { this->comdat = propValue; } using constantTy = ::mlir::UnitAttr; constantTy constant; auto getConstant() const { auto &propStorage = this->constant; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setConstant(const ::mlir::UnitAttr &propValue) { this->constant = propValue; } using dbg_exprsTy = ::mlir::ArrayAttr; dbg_exprsTy dbg_exprs; auto getDbgExprs() const { auto &propStorage = this->dbg_exprs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setDbgExprs(const ::mlir::ArrayAttr &propValue) { this->dbg_exprs = propValue; } using dso_localTy = ::mlir::UnitAttr; dso_localTy dso_local; auto getDsoLocal() const { auto &propStorage = this->dso_local; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setDsoLocal(const ::mlir::UnitAttr &propValue) { this->dso_local = propValue; } using externally_initializedTy = ::mlir::UnitAttr; externally_initializedTy externally_initialized; auto getExternallyInitialized() const { auto &propStorage = this->externally_initialized; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setExternallyInitialized(const ::mlir::UnitAttr &propValue) { this->externally_initialized = propValue; } using global_typeTy = ::mlir::TypeAttr; global_typeTy global_type; auto getGlobalType() const { auto &propStorage = this->global_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setGlobalType(const ::mlir::TypeAttr &propValue) { this->global_type = propValue; } using linkageTy = ::mlir::LLVM::LinkageAttr; linkageTy linkage; auto getLinkage() const { auto &propStorage = this->linkage; return ::llvm::cast<::mlir::LLVM::LinkageAttr>(propStorage); } void setLinkage(const ::mlir::LLVM::LinkageAttr &propValue) { this->linkage = propValue; } using sectionTy = ::mlir::StringAttr; sectionTy section; auto getSection() const { auto &propStorage = this->section; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSection(const ::mlir::StringAttr &propValue) { this->section = propValue; } using sym_nameTy = ::mlir::StringAttr; sym_nameTy sym_name; auto getSymName() const { auto &propStorage = this->sym_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setSymName(const ::mlir::StringAttr &propValue) { this->sym_name = propValue; } using target_specific_attrsTy = ::mlir::ArrayAttr; target_specific_attrsTy target_specific_attrs; auto getTargetSpecificAttrs() const { auto &propStorage = this->target_specific_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setTargetSpecificAttrs(const ::mlir::ArrayAttr &propValue) { this->target_specific_attrs = propValue; } using thread_local_Ty = ::mlir::UnitAttr; thread_local_Ty thread_local_; auto getThreadLocal_() const { auto &propStorage = this->thread_local_; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setThreadLocal_(const ::mlir::UnitAttr &propValue) { this->thread_local_ = propValue; } using unnamed_addrTy = ::mlir::LLVM::UnnamedAddrAttr; unnamed_addrTy unnamed_addr; auto getUnnamedAddr() const { auto &propStorage = this->unnamed_addr; return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(propStorage); } void setUnnamedAddr(const ::mlir::LLVM::UnnamedAddrAttr &propValue) { this->unnamed_addr = propValue; } using valueTy = ::mlir::Attribute; valueTy value; auto getValue() const { auto &propStorage = this->value; return ::llvm::dyn_cast_or_null<::mlir::Attribute>(propStorage); } void setValue(const ::mlir::Attribute &propValue) { this->value = propValue; } using visibility_Ty = ::mlir::LLVM::VisibilityAttr; visibility_Ty visibility_; auto getVisibility_() const { auto &propStorage = this->visibility_; return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(propStorage); } void setVisibility_(const ::mlir::LLVM::VisibilityAttr &propValue) { this->visibility_ = propValue; } bool operator==(const Properties &rhs) const { return rhs.addr_space == this->addr_space && rhs.alignment == this->alignment && rhs.comdat == this->comdat && rhs.constant == this->constant && rhs.dbg_exprs == this->dbg_exprs && rhs.dso_local == this->dso_local && rhs.externally_initialized == this->externally_initialized && rhs.global_type == this->global_type && rhs.linkage == this->linkage && rhs.section == this->section && rhs.sym_name == this->sym_name && rhs.target_specific_attrs == this->target_specific_attrs && rhs.thread_local_ == this->thread_local_ && rhs.unnamed_addr == this->unnamed_addr && rhs.value == this->value && rhs.visibility_ == this->visibility_ && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: GlobalOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.global", odsAttrs.getContext()); } GlobalOpGenericAdaptorBase(GlobalOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::TypeAttr getGlobalTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().global_type); return attr; } ::mlir::Type getGlobalType(); ::mlir::UnitAttr getConstantAttr(); bool getConstant(); ::mlir::StringAttr getSymNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); return attr; } ::llvm::StringRef getSymName(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { auto attr = ::llvm::cast<::mlir::LLVM::LinkageAttr>(getProperties().linkage); return attr; } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr(); bool getDsoLocal(); ::mlir::UnitAttr getThreadLocal_Attr(); bool getThreadLocal_(); ::mlir::UnitAttr getExternallyInitializedAttr(); bool getExternallyInitialized(); ::mlir::Attribute getValueAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::Attribute>(getProperties().value); return attr; } ::std::optional<::mlir::Attribute> getValue(); ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::IntegerAttr getAddrSpaceAttr(); uint32_t getAddrSpace(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); return attr; } ::std::optional<::mlir::LLVM::UnnamedAddr> getUnnamedAddr(); ::mlir::StringAttr getSectionAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().section); return attr; } ::std::optional< ::llvm::StringRef > getSection(); ::mlir::SymbolRefAttr getComdatAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::SymbolRefAttr>(getProperties().comdat); return attr; } ::std::optional< ::mlir::SymbolRefAttr > getComdat(); ::mlir::ArrayAttr getDbgExprsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().dbg_exprs); return attr; } ::std::optional< ::mlir::ArrayAttr > getDbgExprs(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr(); ::mlir::LLVM::Visibility getVisibility_(); ::mlir::ArrayAttr getTargetSpecificAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().target_specific_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getTargetSpecificAttrs(); ::mlir::Region &getInitializer() { return *odsRegions[0]; } ::mlir::RegionRange getRegions() { return odsRegions; } }; } // namespace detail template class GlobalOpGenericAdaptor : public detail::GlobalOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::GlobalOpGenericAdaptorBase; public: GlobalOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} GlobalOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : GlobalOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} GlobalOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : GlobalOpGenericAdaptor(values, attrs, Properties{}, {}) {} GlobalOpGenericAdaptor(RangeT values, const GlobalOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> GlobalOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class GlobalOpAdaptor : public GlobalOpGenericAdaptor<::mlir::ValueRange> { public: using GlobalOpGenericAdaptor::GlobalOpGenericAdaptor; GlobalOpAdaptor(GlobalOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class GlobalOp : public ::mlir::Op::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::IsIsolatedFromAbove, ::mlir::SymbolOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = GlobalOpAdaptor; template using GenericAdaptor = GlobalOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("addr_space"), ::llvm::StringRef("alignment"), ::llvm::StringRef("comdat"), ::llvm::StringRef("constant"), ::llvm::StringRef("dbg_exprs"), ::llvm::StringRef("dso_local"), ::llvm::StringRef("externally_initialized"), ::llvm::StringRef("global_type"), ::llvm::StringRef("linkage"), ::llvm::StringRef("section"), ::llvm::StringRef("sym_name"), ::llvm::StringRef("target_specific_attrs"), ::llvm::StringRef("thread_local_"), ::llvm::StringRef("unnamed_addr"), ::llvm::StringRef("value"), ::llvm::StringRef("visibility_")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAddrSpaceAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAddrSpaceAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getComdatAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getComdatAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getConstantAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getConstantAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getDbgExprsAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getDbgExprsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getDsoLocalAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getDsoLocalAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getExternallyInitializedAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getExternallyInitializedAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getGlobalTypeAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getGlobalTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getLinkageAttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getLinkageAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } ::mlir::StringAttr getSectionAttrName() { return getAttributeNameForIndex(9); } static ::mlir::StringAttr getSectionAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 9); } ::mlir::StringAttr getSymNameAttrName() { return getAttributeNameForIndex(10); } static ::mlir::StringAttr getSymNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 10); } ::mlir::StringAttr getTargetSpecificAttrsAttrName() { return getAttributeNameForIndex(11); } static ::mlir::StringAttr getTargetSpecificAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 11); } ::mlir::StringAttr getThreadLocal_AttrName() { return getAttributeNameForIndex(12); } static ::mlir::StringAttr getThreadLocal_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 12); } ::mlir::StringAttr getUnnamedAddrAttrName() { return getAttributeNameForIndex(13); } static ::mlir::StringAttr getUnnamedAddrAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 13); } ::mlir::StringAttr getValueAttrName() { return getAttributeNameForIndex(14); } static ::mlir::StringAttr getValueAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 14); } ::mlir::StringAttr getVisibility_AttrName() { return getAttributeNameForIndex(15); } static ::mlir::StringAttr getVisibility_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 15); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.global"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Region &getInitializer() { return (*this)->getRegion(0); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::TypeAttr getGlobalTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().global_type); } ::mlir::Type getGlobalType(); ::mlir::UnitAttr getConstantAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().constant); } bool getConstant(); ::mlir::StringAttr getSymNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); } ::llvm::StringRef getSymName(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { return ::llvm::cast<::mlir::LLVM::LinkageAttr>(getProperties().linkage); } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().dso_local); } bool getDsoLocal(); ::mlir::UnitAttr getThreadLocal_Attr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().thread_local_); } bool getThreadLocal_(); ::mlir::UnitAttr getExternallyInitializedAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().externally_initialized); } bool getExternallyInitialized(); ::mlir::Attribute getValueAttr() { return ::llvm::dyn_cast_or_null<::mlir::Attribute>(getProperties().value); } ::std::optional<::mlir::Attribute> getValue(); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::IntegerAttr getAddrSpaceAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().addr_space); } uint32_t getAddrSpace(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); } ::std::optional<::mlir::LLVM::UnnamedAddr> getUnnamedAddr(); ::mlir::StringAttr getSectionAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().section); } ::std::optional< ::llvm::StringRef > getSection(); ::mlir::SymbolRefAttr getComdatAttr() { return ::llvm::dyn_cast_or_null<::mlir::SymbolRefAttr>(getProperties().comdat); } ::std::optional< ::mlir::SymbolRefAttr > getComdat(); ::mlir::ArrayAttr getDbgExprsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().dbg_exprs); } ::std::optional< ::mlir::ArrayAttr > getDbgExprs(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(getProperties().visibility_); } ::mlir::LLVM::Visibility getVisibility_(); ::mlir::ArrayAttr getTargetSpecificAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().target_specific_attrs); } ::std::optional< ::mlir::ArrayAttr > getTargetSpecificAttrs(); void setGlobalTypeAttr(::mlir::TypeAttr attr) { getProperties().global_type = attr; } void setGlobalType(::mlir::Type attrValue); void setConstantAttr(::mlir::UnitAttr attr) { getProperties().constant = attr; } void setConstant(bool attrValue); void setSymNameAttr(::mlir::StringAttr attr) { getProperties().sym_name = attr; } void setSymName(::llvm::StringRef attrValue); void setLinkageAttr(::mlir::LLVM::LinkageAttr attr) { getProperties().linkage = attr; } void setLinkage(::mlir::LLVM::Linkage attrValue); void setDsoLocalAttr(::mlir::UnitAttr attr) { getProperties().dso_local = attr; } void setDsoLocal(bool attrValue); void setThreadLocal_Attr(::mlir::UnitAttr attr) { getProperties().thread_local_ = attr; } void setThreadLocal_(bool attrValue); void setExternallyInitializedAttr(::mlir::UnitAttr attr) { getProperties().externally_initialized = attr; } void setExternallyInitialized(bool attrValue); void setValueAttr(::mlir::Attribute attr) { getProperties().value = attr; } void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setAddrSpaceAttr(::mlir::IntegerAttr attr) { getProperties().addr_space = attr; } void setAddrSpace(uint32_t attrValue); void setUnnamedAddrAttr(::mlir::LLVM::UnnamedAddrAttr attr) { getProperties().unnamed_addr = attr; } void setUnnamedAddr(::std::optional<::mlir::LLVM::UnnamedAddr> attrValue); void setSectionAttr(::mlir::StringAttr attr) { getProperties().section = attr; } void setSection(::std::optional<::llvm::StringRef> attrValue); void setComdatAttr(::mlir::SymbolRefAttr attr) { getProperties().comdat = attr; } void setDbgExprsAttr(::mlir::ArrayAttr attr) { getProperties().dbg_exprs = attr; } void setVisibility_Attr(::mlir::LLVM::VisibilityAttr attr) { getProperties().visibility_ = attr; } void setVisibility_(::mlir::LLVM::Visibility attrValue); void setTargetSpecificAttrsAttr(::mlir::ArrayAttr attr) { getProperties().target_specific_attrs = attr; } ::mlir::Attribute removeConstantAttr() { auto attr = getProperties().constant; getProperties().constant = {}; return attr; } ::mlir::Attribute removeDsoLocalAttr() { auto attr = getProperties().dso_local; getProperties().dso_local = {}; return attr; } ::mlir::Attribute removeThreadLocal_Attr() { auto attr = getProperties().thread_local_; getProperties().thread_local_ = {}; return attr; } ::mlir::Attribute removeExternallyInitializedAttr() { auto attr = getProperties().externally_initialized; getProperties().externally_initialized = {}; return attr; } ::mlir::Attribute removeValueAttr() { auto attr = getProperties().value; getProperties().value = {}; return attr; } ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeUnnamedAddrAttr() { auto attr = getProperties().unnamed_addr; getProperties().unnamed_addr = {}; return attr; } ::mlir::Attribute removeSectionAttr() { auto attr = getProperties().section; getProperties().section = {}; return attr; } ::mlir::Attribute removeComdatAttr() { auto attr = getProperties().comdat; getProperties().comdat = {}; return attr; } ::mlir::Attribute removeDbgExprsAttr() { auto attr = getProperties().dbg_exprs; getProperties().dbg_exprs = {}; return attr; } ::mlir::Attribute removeTargetSpecificAttrsAttr() { auto attr = getProperties().target_specific_attrs; getProperties().target_specific_attrs = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type type, bool isConstant, Linkage linkage, StringRef name, Attribute value, uint64_t alignment = 0, unsigned addrSpace = 0, bool dsoLocal = false, bool thread_local_ = false, SymbolRefAttr comdat = {}, ArrayRef attrs = {}, ArrayRef dbgExprs = {}); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type type, bool isConstant, Linkage linkage, StringRef name, Attribute value, uint64_t alignment = 0, unsigned addrSpace = 0, bool dsoLocal = false, bool thread_local_ = false, SymbolRefAttr comdat = {}, ArrayRef attrs = {}, ArrayRef dbgExprs = {}); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, Type type, bool isConstant, Linkage linkage, StringRef name, Attribute value, uint64_t alignment = 0, unsigned addrSpace = 0, bool dsoLocal = false, bool thread_local_ = false, SymbolRefAttr comdat = {}, ArrayRef attrs = {}, ArrayRef dbgExprs = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeAttr global_type, /*optional*/::mlir::UnitAttr constant, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::UnitAttr externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, ::mlir::IntegerAttr addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::VisibilityAttr visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeAttr global_type, /*optional*/::mlir::UnitAttr constant, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::UnitAttr externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, ::mlir::IntegerAttr addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::VisibilityAttr visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeAttr global_type, /*optional*/::mlir::UnitAttr constant, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::UnitAttr externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, ::mlir::IntegerAttr addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::VisibilityAttr visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::TypeAttr global_type, /*optional*/::mlir::UnitAttr constant, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::UnitAttr externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, ::mlir::IntegerAttr addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::VisibilityAttr visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::TypeAttr global_type, /*optional*/::mlir::UnitAttr constant, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::UnitAttr externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, ::mlir::IntegerAttr addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::VisibilityAttr visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::TypeAttr global_type, /*optional*/::mlir::UnitAttr constant, ::mlir::StringAttr sym_name, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local, /*optional*/::mlir::UnitAttr thread_local_, /*optional*/::mlir::UnitAttr externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, ::mlir::IntegerAttr addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::VisibilityAttr visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type global_type, /*optional*/bool constant, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/bool externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, uint32_t addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::Visibility visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type global_type, /*optional*/bool constant, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/bool externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, uint32_t addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::Visibility visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type global_type, /*optional*/bool constant, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/bool externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, uint32_t addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::Visibility visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Type global_type, /*optional*/bool constant, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/bool externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, uint32_t addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::Visibility visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Type global_type, /*optional*/bool constant, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/bool externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, uint32_t addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::Visibility visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Type global_type, /*optional*/bool constant, ::llvm::StringRef sym_name, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local, /*optional*/bool thread_local_, /*optional*/bool externally_initialized, /*optional*/::mlir::Attribute value, /*optional*/::mlir::IntegerAttr alignment, uint32_t addr_space, /*optional*/::mlir::LLVM::UnnamedAddrAttr unnamed_addr, /*optional*/::mlir::StringAttr section, /*optional*/::mlir::SymbolRefAttr comdat, /*optional*/::mlir::ArrayAttr dbg_exprs, ::mlir::LLVM::Visibility visibility_, /*optional*/::mlir::ArrayAttr target_specific_attrs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static GlobalOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static GlobalOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::LogicalResult verifyRegions(); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 16 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Return the LLVM type of the global. Type getType() { return getGlobalType(); } /// Return the initializer attribute if it exists, or a null attribute. Attribute getValueOrNull() { return getValue().value_or(Attribute()); } /// Return the initializer region. This may be empty, but if it is not it /// terminates in an `llvm.return` op with the initializer value. Region &getInitializerRegion() { return getOperation()->getRegion(0); } /// Return the initializer block. If the initializer region is empty this /// is nullptr. If it is not nullptr, it terminates with an `llvm.return` /// op with the initializer value. Block *getInitializerBlock() { return getInitializerRegion().empty() ? nullptr : &getInitializerRegion().front(); } }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::GlobalOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::GlobalOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ICmpOp declarations //===----------------------------------------------------------------------===// namespace detail { class ICmpOpGenericAdaptorBase { public: struct Properties { using predicateTy = ::mlir::LLVM::ICmpPredicateAttr; predicateTy predicate; auto getPredicate() const { auto &propStorage = this->predicate; return ::llvm::cast<::mlir::LLVM::ICmpPredicateAttr>(propStorage); } void setPredicate(const ::mlir::LLVM::ICmpPredicateAttr &propValue) { this->predicate = propValue; } bool operator==(const Properties &rhs) const { return rhs.predicate == this->predicate && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ICmpOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.icmp", odsAttrs.getContext()); } ICmpOpGenericAdaptorBase(ICmpOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::ICmpPredicateAttr getPredicateAttr() { auto attr = ::llvm::cast<::mlir::LLVM::ICmpPredicateAttr>(getProperties().predicate); return attr; } ::mlir::LLVM::ICmpPredicate getPredicate(); }; } // namespace detail template class ICmpOpGenericAdaptor : public detail::ICmpOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ICmpOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: ICmpOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ICmpOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ICmpOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ICmpOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ICmpOpGenericAdaptor(values, attrs, Properties{}, {}) {} ICmpOpGenericAdaptor(RangeT values, const ICmpOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ICmpOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ICmpOpAdaptor : public ICmpOpGenericAdaptor<::mlir::ValueRange> { public: using ICmpOpGenericAdaptor::ICmpOpGenericAdaptor; ICmpOpAdaptor(ICmpOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ICmpOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::SameTypeOperands, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = ICmpOpAdaptor; template using GenericAdaptor = ICmpOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("predicate")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getPredicateAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getPredicateAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.icmp"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::ICmpPredicateAttr getPredicateAttr() { return ::llvm::cast<::mlir::LLVM::ICmpPredicateAttr>(getProperties().predicate); } ::mlir::LLVM::ICmpPredicate getPredicate(); void setPredicateAttr(::mlir::LLVM::ICmpPredicateAttr attr) { getProperties().predicate = attr; } void setPredicate(::mlir::LLVM::ICmpPredicate attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::ICmpPredicateAttr predicate, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::LLVM::ICmpPredicate predicate, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ICmpOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ICmpOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ICmpOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ICmpOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::IFuncOp declarations //===----------------------------------------------------------------------===// namespace detail { class IFuncOpGenericAdaptorBase { public: struct Properties { using address_spaceTy = ::mlir::IntegerAttr; address_spaceTy address_space; auto getAddressSpace() const { auto &propStorage = this->address_space; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAddressSpace(const ::mlir::IntegerAttr &propValue) { this->address_space = propValue; } using dso_localTy = ::mlir::UnitAttr; dso_localTy dso_local; auto getDsoLocal() const { auto &propStorage = this->dso_local; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setDsoLocal(const ::mlir::UnitAttr &propValue) { this->dso_local = propValue; } using i_func_typeTy = ::mlir::TypeAttr; i_func_typeTy i_func_type; auto getIFuncType() const { auto &propStorage = this->i_func_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setIFuncType(const ::mlir::TypeAttr &propValue) { this->i_func_type = propValue; } using linkageTy = ::mlir::LLVM::LinkageAttr; linkageTy linkage; auto getLinkage() const { auto &propStorage = this->linkage; return ::llvm::cast<::mlir::LLVM::LinkageAttr>(propStorage); } void setLinkage(const ::mlir::LLVM::LinkageAttr &propValue) { this->linkage = propValue; } using resolverTy = ::mlir::FlatSymbolRefAttr; resolverTy resolver; auto getResolver() const { auto &propStorage = this->resolver; return ::llvm::cast<::mlir::FlatSymbolRefAttr>(propStorage); } void setResolver(const ::mlir::FlatSymbolRefAttr &propValue) { this->resolver = propValue; } using resolver_typeTy = ::mlir::TypeAttr; resolver_typeTy resolver_type; auto getResolverType() const { auto &propStorage = this->resolver_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setResolverType(const ::mlir::TypeAttr &propValue) { this->resolver_type = propValue; } using sym_nameTy = ::mlir::StringAttr; sym_nameTy sym_name; auto getSymName() const { auto &propStorage = this->sym_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setSymName(const ::mlir::StringAttr &propValue) { this->sym_name = propValue; } using unnamed_addrTy = ::mlir::LLVM::UnnamedAddrAttr; unnamed_addrTy unnamed_addr; auto getUnnamedAddr() const { auto &propStorage = this->unnamed_addr; return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(propStorage); } void setUnnamedAddr(const ::mlir::LLVM::UnnamedAddrAttr &propValue) { this->unnamed_addr = propValue; } using visibility_Ty = ::mlir::LLVM::VisibilityAttr; visibility_Ty visibility_; auto getVisibility_() const { auto &propStorage = this->visibility_; return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(propStorage); } void setVisibility_(const ::mlir::LLVM::VisibilityAttr &propValue) { this->visibility_ = propValue; } bool operator==(const Properties &rhs) const { return rhs.address_space == this->address_space && rhs.dso_local == this->dso_local && rhs.i_func_type == this->i_func_type && rhs.linkage == this->linkage && rhs.resolver == this->resolver && rhs.resolver_type == this->resolver_type && rhs.sym_name == this->sym_name && rhs.unnamed_addr == this->unnamed_addr && rhs.visibility_ == this->visibility_ && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: IFuncOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.ifunc", odsAttrs.getContext()); } IFuncOpGenericAdaptorBase(IFuncOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getSymNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); return attr; } ::llvm::StringRef getSymName(); ::mlir::TypeAttr getIFuncTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().i_func_type); return attr; } ::mlir::Type getIFuncType(); ::mlir::FlatSymbolRefAttr getResolverAttr() { auto attr = ::llvm::cast<::mlir::FlatSymbolRefAttr>(getProperties().resolver); return attr; } ::llvm::StringRef getResolver(); ::mlir::TypeAttr getResolverTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().resolver_type); return attr; } ::mlir::Type getResolverType(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { auto attr = ::llvm::cast<::mlir::LLVM::LinkageAttr>(getProperties().linkage); return attr; } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr(); bool getDsoLocal(); ::mlir::IntegerAttr getAddressSpaceAttr(); uint32_t getAddressSpace(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr(); ::mlir::LLVM::UnnamedAddr getUnnamedAddr(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr(); ::mlir::LLVM::Visibility getVisibility_(); }; } // namespace detail template class IFuncOpGenericAdaptor : public detail::IFuncOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::IFuncOpGenericAdaptorBase; public: IFuncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} IFuncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : IFuncOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} IFuncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : IFuncOpGenericAdaptor(values, attrs, Properties{}, {}) {} IFuncOpGenericAdaptor(RangeT values, const IFuncOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> IFuncOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class IFuncOpAdaptor : public IFuncOpGenericAdaptor<::mlir::ValueRange> { public: using IFuncOpGenericAdaptor::IFuncOpGenericAdaptor; IFuncOpAdaptor(IFuncOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class IFuncOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = IFuncOpAdaptor; template using GenericAdaptor = IFuncOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("address_space"), ::llvm::StringRef("dso_local"), ::llvm::StringRef("i_func_type"), ::llvm::StringRef("linkage"), ::llvm::StringRef("resolver"), ::llvm::StringRef("resolver_type"), ::llvm::StringRef("sym_name"), ::llvm::StringRef("unnamed_addr"), ::llvm::StringRef("visibility_")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAddressSpaceAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAddressSpaceAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getDsoLocalAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getDsoLocalAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getIFuncTypeAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getIFuncTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getLinkageAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getLinkageAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getResolverAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getResolverAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getResolverTypeAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getResolverTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getSymNameAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getSymNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getUnnamedAddrAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getUnnamedAddrAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getVisibility_AttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getVisibility_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.ifunc"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getSymNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); } ::llvm::StringRef getSymName(); ::mlir::TypeAttr getIFuncTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().i_func_type); } ::mlir::Type getIFuncType(); ::mlir::FlatSymbolRefAttr getResolverAttr() { return ::llvm::cast<::mlir::FlatSymbolRefAttr>(getProperties().resolver); } ::llvm::StringRef getResolver(); ::mlir::TypeAttr getResolverTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().resolver_type); } ::mlir::Type getResolverType(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { return ::llvm::cast<::mlir::LLVM::LinkageAttr>(getProperties().linkage); } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().dso_local); } bool getDsoLocal(); ::mlir::IntegerAttr getAddressSpaceAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().address_space); } uint32_t getAddressSpace(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); } ::mlir::LLVM::UnnamedAddr getUnnamedAddr(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(getProperties().visibility_); } ::mlir::LLVM::Visibility getVisibility_(); void setSymNameAttr(::mlir::StringAttr attr) { getProperties().sym_name = attr; } void setSymName(::llvm::StringRef attrValue); void setIFuncTypeAttr(::mlir::TypeAttr attr) { getProperties().i_func_type = attr; } void setIFuncType(::mlir::Type attrValue); void setResolverAttr(::mlir::FlatSymbolRefAttr attr) { getProperties().resolver = attr; } void setResolver(::llvm::StringRef attrValue); void setResolverTypeAttr(::mlir::TypeAttr attr) { getProperties().resolver_type = attr; } void setResolverType(::mlir::Type attrValue); void setLinkageAttr(::mlir::LLVM::LinkageAttr attr) { getProperties().linkage = attr; } void setLinkage(::mlir::LLVM::Linkage attrValue); void setDsoLocalAttr(::mlir::UnitAttr attr) { getProperties().dso_local = attr; } void setDsoLocal(bool attrValue); void setAddressSpaceAttr(::mlir::IntegerAttr attr) { getProperties().address_space = attr; } void setAddressSpace(uint32_t attrValue); void setUnnamedAddrAttr(::mlir::LLVM::UnnamedAddrAttr attr) { getProperties().unnamed_addr = attr; } void setUnnamedAddr(::mlir::LLVM::UnnamedAddr attrValue); void setVisibility_Attr(::mlir::LLVM::VisibilityAttr attr) { getProperties().visibility_ = attr; } void setVisibility_(::mlir::LLVM::Visibility attrValue); ::mlir::Attribute removeDsoLocalAttr() { auto attr = getProperties().dso_local; getProperties().dso_local = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, StringRef name, Type i_func_type, StringRef resolver, Type resolver_type, Linkage linkage, LLVM::Visibility visibility); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, StringRef name, Type i_func_type, StringRef resolver, Type resolver_type, Linkage linkage, LLVM::Visibility visibility); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, StringRef name, Type i_func_type, StringRef resolver, Type resolver_type, Linkage linkage, LLVM::Visibility visibility); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::StringAttr sym_name, ::mlir::TypeAttr i_func_type, ::mlir::FlatSymbolRefAttr resolver, ::mlir::TypeAttr resolver_type, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local = nullptr, ::mlir::IntegerAttr address_space = nullptr, ::mlir::LLVM::UnnamedAddrAttr unnamed_addr = nullptr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::StringAttr sym_name, ::mlir::TypeAttr i_func_type, ::mlir::FlatSymbolRefAttr resolver, ::mlir::TypeAttr resolver_type, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local = nullptr, ::mlir::IntegerAttr address_space = nullptr, ::mlir::LLVM::UnnamedAddrAttr unnamed_addr = nullptr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::StringAttr sym_name, ::mlir::TypeAttr i_func_type, ::mlir::FlatSymbolRefAttr resolver, ::mlir::TypeAttr resolver_type, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local = nullptr, ::mlir::IntegerAttr address_space = nullptr, ::mlir::LLVM::UnnamedAddrAttr unnamed_addr = nullptr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::StringAttr sym_name, ::mlir::TypeAttr i_func_type, ::mlir::FlatSymbolRefAttr resolver, ::mlir::TypeAttr resolver_type, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local = nullptr, ::mlir::IntegerAttr address_space = nullptr, ::mlir::LLVM::UnnamedAddrAttr unnamed_addr = nullptr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::StringAttr sym_name, ::mlir::TypeAttr i_func_type, ::mlir::FlatSymbolRefAttr resolver, ::mlir::TypeAttr resolver_type, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local = nullptr, ::mlir::IntegerAttr address_space = nullptr, ::mlir::LLVM::UnnamedAddrAttr unnamed_addr = nullptr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::StringAttr sym_name, ::mlir::TypeAttr i_func_type, ::mlir::FlatSymbolRefAttr resolver, ::mlir::TypeAttr resolver_type, ::mlir::LLVM::LinkageAttr linkage, /*optional*/::mlir::UnitAttr dso_local = nullptr, ::mlir::IntegerAttr address_space = nullptr, ::mlir::LLVM::UnnamedAddrAttr unnamed_addr = nullptr, ::mlir::LLVM::VisibilityAttr visibility_ = nullptr); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::StringRef sym_name, ::mlir::Type i_func_type, ::llvm::StringRef resolver, ::mlir::Type resolver_type, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local = false, uint32_t address_space = 0, ::mlir::LLVM::UnnamedAddr unnamed_addr = mlir::LLVM::UnnamedAddr::None, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::llvm::StringRef sym_name, ::mlir::Type i_func_type, ::llvm::StringRef resolver, ::mlir::Type resolver_type, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local = false, uint32_t address_space = 0, ::mlir::LLVM::UnnamedAddr unnamed_addr = mlir::LLVM::UnnamedAddr::None, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, ::llvm::StringRef sym_name, ::mlir::Type i_func_type, ::llvm::StringRef resolver, ::mlir::Type resolver_type, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local = false, uint32_t address_space = 0, ::mlir::LLVM::UnnamedAddr unnamed_addr = mlir::LLVM::UnnamedAddr::None, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef sym_name, ::mlir::Type i_func_type, ::llvm::StringRef resolver, ::mlir::Type resolver_type, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local = false, uint32_t address_space = 0, ::mlir::LLVM::UnnamedAddr unnamed_addr = mlir::LLVM::UnnamedAddr::None, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::llvm::StringRef sym_name, ::mlir::Type i_func_type, ::llvm::StringRef resolver, ::mlir::Type resolver_type, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local = false, uint32_t address_space = 0, ::mlir::LLVM::UnnamedAddr unnamed_addr = mlir::LLVM::UnnamedAddr::None, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::llvm::StringRef sym_name, ::mlir::Type i_func_type, ::llvm::StringRef resolver, ::mlir::Type resolver_type, ::mlir::LLVM::Linkage linkage, /*optional*/bool dso_local = false, uint32_t address_space = 0, ::mlir::LLVM::UnnamedAddr unnamed_addr = mlir::LLVM::UnnamedAddr::None, ::mlir::LLVM::Visibility visibility_ = mlir::LLVM::Visibility::Default); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static IFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static IFuncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::LogicalResult verifySymbolUses(::mlir::SymbolTableCollection &symbolTable); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 9 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::IFuncOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::IFuncOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::IndirectBrOp declarations //===----------------------------------------------------------------------===// namespace detail { class IndirectBrOpGenericAdaptorBase { public: struct Properties { using indbr_operand_segmentsTy = ::mlir::DenseI32ArrayAttr; indbr_operand_segmentsTy indbr_operand_segments; auto getIndbrOperandSegments() const { auto &propStorage = this->indbr_operand_segments; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setIndbrOperandSegments(const ::mlir::DenseI32ArrayAttr &propValue) { this->indbr_operand_segments = propValue; } bool operator==(const Properties &rhs) const { return rhs.indbr_operand_segments == this->indbr_operand_segments && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: IndirectBrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.indirectbr", odsAttrs.getContext()); } IndirectBrOpGenericAdaptorBase(IndirectBrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::DenseI32ArrayAttr getIndbrOperandSegmentsAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().indbr_operand_segments); return attr; } ::llvm::ArrayRef getIndbrOperandSegments(); }; } // namespace detail template class IndirectBrOpGenericAdaptor : public detail::IndirectBrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::IndirectBrOpGenericAdaptorBase; static constexpr int odsIndex_addr = 0; static constexpr int odsIndex_succOperands = 1; public: IndirectBrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} IndirectBrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : IndirectBrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} IndirectBrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : IndirectBrOpGenericAdaptor(values, attrs, Properties{}, {}) {} IndirectBrOpGenericAdaptor(RangeT values, const IndirectBrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> IndirectBrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getAddr() { return (*getODSOperands(0).begin()); } ::llvm::SmallVector getSuccOperands() { auto tblgenTmpOperands = getODSOperands(1); auto sizes = getIndbrOperandSegments(); ::llvm::SmallVector tblgenTmpOperandGroups; for (int i = 0, e = sizes.size(); i < e; ++i) { tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i])); tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]); } return tblgenTmpOperandGroups; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class IndirectBrOpAdaptor : public IndirectBrOpGenericAdaptor<::mlir::ValueRange> { public: using IndirectBrOpGenericAdaptor::IndirectBrOpGenericAdaptor; IndirectBrOpAdaptor(IndirectBrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class IndirectBrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::BranchOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { public: using Op::Op; using Op::print; using Adaptor = IndirectBrOpAdaptor; template using GenericAdaptor = IndirectBrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_addr = 0; static constexpr int odsIndex_succOperands = 1; using Properties = FoldAdaptor::Properties; using ::mlir::BranchOpInterface::Trait::getSuccessorForOperands; using ::mlir::BranchOpInterface::Trait::areTypesCompatible; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("indbr_operand_segments")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getIndbrOperandSegmentsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getIndbrOperandSegmentsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.indirectbr"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAddr() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSOperands(0).begin()); } ::mlir::OperandRangeRange getSuccOperands() { return getODSOperands(1).split(getIndbrOperandSegmentsAttr()); } ::mlir::OpOperand &getAddrMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::MutableOperandRangeRange getSuccOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::SuccessorRange getSuccessors() { return {std::next((*this)->successor_begin(), 0), (*this)->successor_end()}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::DenseI32ArrayAttr getIndbrOperandSegmentsAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().indbr_operand_segments); } ::llvm::ArrayRef getIndbrOperandSegments(); void setIndbrOperandSegmentsAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().indbr_operand_segments = attr; } void setIndbrOperandSegments(::llvm::ArrayRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value addr, ArrayRef succOperands = {}, BlockRange successors = {}); static IndirectBrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value addr, ArrayRef succOperands = {}, BlockRange successors = {}); static IndirectBrOp create(::mlir::ImplicitLocOpBuilder &builder, Value addr, ArrayRef succOperands = {}, BlockRange successors = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::SuccessorOperands getSuccessorOperands(unsigned index); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::IndirectBrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::IndirectBrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::InlineAsmOp declarations //===----------------------------------------------------------------------===// namespace detail { class InlineAsmOpGenericAdaptorBase { public: struct Properties { using asm_dialectTy = ::mlir::LLVM::AsmDialectAttr; asm_dialectTy asm_dialect; auto getAsmDialect() const { auto &propStorage = this->asm_dialect; return ::llvm::dyn_cast_or_null<::mlir::LLVM::AsmDialectAttr>(propStorage); } void setAsmDialect(const ::mlir::LLVM::AsmDialectAttr &propValue) { this->asm_dialect = propValue; } using asm_stringTy = ::mlir::StringAttr; asm_stringTy asm_string; auto getAsmString() const { auto &propStorage = this->asm_string; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setAsmString(const ::mlir::StringAttr &propValue) { this->asm_string = propValue; } using constraintsTy = ::mlir::StringAttr; constraintsTy constraints; auto getConstraints() const { auto &propStorage = this->constraints; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setConstraints(const ::mlir::StringAttr &propValue) { this->constraints = propValue; } using has_side_effectsTy = ::mlir::UnitAttr; has_side_effectsTy has_side_effects; auto getHasSideEffects() const { auto &propStorage = this->has_side_effects; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setHasSideEffects(const ::mlir::UnitAttr &propValue) { this->has_side_effects = propValue; } using is_align_stackTy = ::mlir::UnitAttr; is_align_stackTy is_align_stack; auto getIsAlignStack() const { auto &propStorage = this->is_align_stack; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setIsAlignStack(const ::mlir::UnitAttr &propValue) { this->is_align_stack = propValue; } using operand_attrsTy = ::mlir::ArrayAttr; operand_attrsTy operand_attrs; auto getOperandAttrs() const { auto &propStorage = this->operand_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setOperandAttrs(const ::mlir::ArrayAttr &propValue) { this->operand_attrs = propValue; } using tail_call_kindTy = ::mlir::LLVM::TailCallKindAttr; tail_call_kindTy tail_call_kind; auto getTailCallKind() const { auto &propStorage = this->tail_call_kind; return ::llvm::dyn_cast_or_null<::mlir::LLVM::TailCallKindAttr>(propStorage); } void setTailCallKind(const ::mlir::LLVM::TailCallKindAttr &propValue) { this->tail_call_kind = propValue; } bool operator==(const Properties &rhs) const { return rhs.asm_dialect == this->asm_dialect && rhs.asm_string == this->asm_string && rhs.constraints == this->constraints && rhs.has_side_effects == this->has_side_effects && rhs.is_align_stack == this->is_align_stack && rhs.operand_attrs == this->operand_attrs && rhs.tail_call_kind == this->tail_call_kind && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: InlineAsmOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.inline_asm", odsAttrs.getContext()); } InlineAsmOpGenericAdaptorBase(InlineAsmOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getAsmStringAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().asm_string); return attr; } ::llvm::StringRef getAsmString(); ::mlir::StringAttr getConstraintsAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().constraints); return attr; } ::llvm::StringRef getConstraints(); ::mlir::UnitAttr getHasSideEffectsAttr(); bool getHasSideEffects(); ::mlir::UnitAttr getIsAlignStackAttr(); bool getIsAlignStack(); ::mlir::LLVM::TailCallKindAttr getTailCallKindAttr(); ::mlir::LLVM::tailcallkind::TailCallKind getTailCallKind(); ::mlir::LLVM::AsmDialectAttr getAsmDialectAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::AsmDialectAttr>(getProperties().asm_dialect); return attr; } ::std::optional<::mlir::LLVM::AsmDialect> getAsmDialect(); ::mlir::ArrayAttr getOperandAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().operand_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getOperandAttrs(); }; } // namespace detail template class InlineAsmOpGenericAdaptor : public detail::InlineAsmOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::InlineAsmOpGenericAdaptorBase; static constexpr int odsIndex_operands = 0; public: InlineAsmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} InlineAsmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : InlineAsmOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} InlineAsmOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : InlineAsmOpGenericAdaptor(values, attrs, Properties{}, {}) {} InlineAsmOpGenericAdaptor(RangeT values, const InlineAsmOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> InlineAsmOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return getODSOperands(0); } private: RangeT odsOperands; }; class InlineAsmOpAdaptor : public InlineAsmOpGenericAdaptor<::mlir::ValueRange> { public: using InlineAsmOpGenericAdaptor::InlineAsmOpGenericAdaptor; InlineAsmOpAdaptor(InlineAsmOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class InlineAsmOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = InlineAsmOpAdaptor; template using GenericAdaptor = InlineAsmOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_operands = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("asm_dialect"), ::llvm::StringRef("asm_string"), ::llvm::StringRef("constraints"), ::llvm::StringRef("has_side_effects"), ::llvm::StringRef("is_align_stack"), ::llvm::StringRef("operand_attrs"), ::llvm::StringRef("tail_call_kind")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAsmDialectAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAsmDialectAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAsmStringAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAsmStringAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getConstraintsAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getConstraintsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getHasSideEffectsAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getHasSideEffectsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getIsAlignStackAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getIsAlignStackAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getOperandAttrsAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getOperandAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getTailCallKindAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getTailCallKindAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.inline_asm"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::Operation::operand_range getOperands() { return getODSOperands(0); } ::mlir::MutableOperandRange getOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index); ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { auto results = getODSResults(0); return results.empty() ? ::mlir::TypedValue<::mlir::Type>() : ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*results.begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getAsmStringAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().asm_string); } ::llvm::StringRef getAsmString(); ::mlir::StringAttr getConstraintsAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().constraints); } ::llvm::StringRef getConstraints(); ::mlir::UnitAttr getHasSideEffectsAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().has_side_effects); } bool getHasSideEffects(); ::mlir::UnitAttr getIsAlignStackAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().is_align_stack); } bool getIsAlignStack(); ::mlir::LLVM::TailCallKindAttr getTailCallKindAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::TailCallKindAttr>(getProperties().tail_call_kind); } ::mlir::LLVM::tailcallkind::TailCallKind getTailCallKind(); ::mlir::LLVM::AsmDialectAttr getAsmDialectAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::AsmDialectAttr>(getProperties().asm_dialect); } ::std::optional<::mlir::LLVM::AsmDialect> getAsmDialect(); ::mlir::ArrayAttr getOperandAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().operand_attrs); } ::std::optional< ::mlir::ArrayAttr > getOperandAttrs(); void setAsmStringAttr(::mlir::StringAttr attr) { getProperties().asm_string = attr; } void setAsmString(::llvm::StringRef attrValue); void setConstraintsAttr(::mlir::StringAttr attr) { getProperties().constraints = attr; } void setConstraints(::llvm::StringRef attrValue); void setHasSideEffectsAttr(::mlir::UnitAttr attr) { getProperties().has_side_effects = attr; } void setHasSideEffects(bool attrValue); void setIsAlignStackAttr(::mlir::UnitAttr attr) { getProperties().is_align_stack = attr; } void setIsAlignStack(bool attrValue); void setTailCallKindAttr(::mlir::LLVM::TailCallKindAttr attr) { getProperties().tail_call_kind = attr; } void setTailCallKind(::mlir::LLVM::tailcallkind::TailCallKind attrValue); void setAsmDialectAttr(::mlir::LLVM::AsmDialectAttr attr) { getProperties().asm_dialect = attr; } void setAsmDialect(::std::optional<::mlir::LLVM::AsmDialect> attrValue); void setOperandAttrsAttr(::mlir::ArrayAttr attr) { getProperties().operand_attrs = attr; } ::mlir::Attribute removeHasSideEffectsAttr() { auto attr = getProperties().has_side_effects; getProperties().has_side_effects = {}; return attr; } ::mlir::Attribute removeIsAlignStackAttr() { auto attr = getProperties().is_align_stack; getProperties().is_align_stack = {}; return attr; } ::mlir::Attribute removeAsmDialectAttr() { auto attr = getProperties().asm_dialect; getProperties().asm_dialect = {}; return attr; } ::mlir::Attribute removeOperandAttrsAttr() { auto attr = getProperties().operand_attrs; getProperties().operand_attrs = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type res, ::mlir::ValueRange operands, ::mlir::StringAttr asm_string, ::mlir::StringAttr constraints, /*optional*/::mlir::UnitAttr has_side_effects, /*optional*/::mlir::UnitAttr is_align_stack, ::mlir::LLVM::TailCallKindAttr tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type res, ::mlir::ValueRange operands, ::mlir::StringAttr asm_string, ::mlir::StringAttr constraints, /*optional*/::mlir::UnitAttr has_side_effects, /*optional*/::mlir::UnitAttr is_align_stack, ::mlir::LLVM::TailCallKindAttr tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type res, ::mlir::ValueRange operands, ::mlir::StringAttr asm_string, ::mlir::StringAttr constraints, /*optional*/::mlir::UnitAttr has_side_effects, /*optional*/::mlir::UnitAttr is_align_stack, ::mlir::LLVM::TailCallKindAttr tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::StringAttr asm_string, ::mlir::StringAttr constraints, /*optional*/::mlir::UnitAttr has_side_effects, /*optional*/::mlir::UnitAttr is_align_stack, ::mlir::LLVM::TailCallKindAttr tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::StringAttr asm_string, ::mlir::StringAttr constraints, /*optional*/::mlir::UnitAttr has_side_effects, /*optional*/::mlir::UnitAttr is_align_stack, ::mlir::LLVM::TailCallKindAttr tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::mlir::StringAttr asm_string, ::mlir::StringAttr constraints, /*optional*/::mlir::UnitAttr has_side_effects, /*optional*/::mlir::UnitAttr is_align_stack, ::mlir::LLVM::TailCallKindAttr tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type res, ::mlir::ValueRange operands, ::llvm::StringRef asm_string, ::llvm::StringRef constraints, /*optional*/bool has_side_effects, /*optional*/bool is_align_stack, ::mlir::LLVM::tailcallkind::TailCallKind tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type res, ::mlir::ValueRange operands, ::llvm::StringRef asm_string, ::llvm::StringRef constraints, /*optional*/bool has_side_effects, /*optional*/bool is_align_stack, ::mlir::LLVM::tailcallkind::TailCallKind tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type res, ::mlir::ValueRange operands, ::llvm::StringRef asm_string, ::llvm::StringRef constraints, /*optional*/bool has_side_effects, /*optional*/bool is_align_stack, ::mlir::LLVM::tailcallkind::TailCallKind tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::StringRef asm_string, ::llvm::StringRef constraints, /*optional*/bool has_side_effects, /*optional*/bool is_align_stack, ::mlir::LLVM::tailcallkind::TailCallKind tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::StringRef asm_string, ::llvm::StringRef constraints, /*optional*/bool has_side_effects, /*optional*/bool is_align_stack, ::mlir::LLVM::tailcallkind::TailCallKind tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static InlineAsmOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::StringRef asm_string, ::llvm::StringRef constraints, /*optional*/bool has_side_effects, /*optional*/bool is_align_stack, ::mlir::LLVM::tailcallkind::TailCallKind tail_call_kind, /*optional*/::mlir::LLVM::AsmDialectAttr asm_dialect, /*optional*/::mlir::ArrayAttr operand_attrs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InlineAsmOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InlineAsmOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InlineAsmOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InlineAsmOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 7 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: static StringRef getElementTypeAttrName() { return "elementtype"; } }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::InlineAsmOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::InlineAsmOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::InsertElementOp declarations //===----------------------------------------------------------------------===// namespace detail { class InsertElementOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: InsertElementOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.insertelement", odsAttrs.getContext()); } InsertElementOpGenericAdaptorBase(InsertElementOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class InsertElementOpGenericAdaptor : public detail::InsertElementOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::InsertElementOpGenericAdaptorBase; static constexpr int odsIndex_vector = 0; static constexpr int odsIndex_value = 1; static constexpr int odsIndex_position = 2; public: InsertElementOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} InsertElementOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : InsertElementOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} InsertElementOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : InsertElementOpGenericAdaptor(values, attrs, Properties{}, {}) {} InsertElementOpGenericAdaptor(RangeT values, const InsertElementOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> InsertElementOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getVector() { return (*getODSOperands(0).begin()); } ValueT getValue() { return (*getODSOperands(1).begin()); } ValueT getPosition() { return (*getODSOperands(2).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class InsertElementOpAdaptor : public InsertElementOpGenericAdaptor<::mlir::ValueRange> { public: using InsertElementOpGenericAdaptor::InsertElementOpGenericAdaptor; InsertElementOpAdaptor(InsertElementOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class InsertElementOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = InsertElementOpAdaptor; template using GenericAdaptor = InsertElementOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_vector = 0; static constexpr int odsIndex_value = 1; static constexpr int odsIndex_position = 2; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.insertelement"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::VectorType> getVector() { return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::TypedValue<::mlir::IntegerType> getPosition() { return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(2).begin()); } ::mlir::OpOperand &getVectorMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getValueMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getPositionMutable() { auto range = getODSOperandIndexAndLength(2); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::VectorType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value vector, ::mlir::Value value, ::mlir::Value position); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertElementOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertElementOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::InsertElementOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::InsertValueOp declarations //===----------------------------------------------------------------------===// namespace detail { class InsertValueOpGenericAdaptorBase { public: struct Properties { using positionTy = ::mlir::DenseI64ArrayAttr; positionTy position; auto getPosition() const { auto &propStorage = this->position; return ::llvm::cast<::mlir::DenseI64ArrayAttr>(propStorage); } void setPosition(const ::mlir::DenseI64ArrayAttr &propValue) { this->position = propValue; } bool operator==(const Properties &rhs) const { return rhs.position == this->position && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: InsertValueOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.insertvalue", odsAttrs.getContext()); } InsertValueOpGenericAdaptorBase(InsertValueOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::DenseI64ArrayAttr getPositionAttr() { auto attr = ::llvm::cast<::mlir::DenseI64ArrayAttr>(getProperties().position); return attr; } ::llvm::ArrayRef getPosition(); }; } // namespace detail template class InsertValueOpGenericAdaptor : public detail::InsertValueOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::InsertValueOpGenericAdaptorBase; static constexpr int odsIndex_container = 0; static constexpr int odsIndex_value = 1; public: InsertValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} InsertValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : InsertValueOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} InsertValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : InsertValueOpGenericAdaptor(values, attrs, Properties{}, {}) {} InsertValueOpGenericAdaptor(RangeT values, const InsertValueOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> InsertValueOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getContainer() { return (*getODSOperands(0).begin()); } ValueT getValue() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class InsertValueOpAdaptor : public InsertValueOpGenericAdaptor<::mlir::ValueRange> { public: using InsertValueOpGenericAdaptor::InsertValueOpGenericAdaptor; InsertValueOpAdaptor(InsertValueOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class InsertValueOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = InsertValueOpAdaptor; template using GenericAdaptor = InsertValueOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_container = 0; static constexpr int odsIndex_value = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("position")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getPositionAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getPositionAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.insertvalue"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getContainer() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getContainerMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getValueMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::DenseI64ArrayAttr getPositionAttr() { return ::llvm::cast<::mlir::DenseI64ArrayAttr>(getProperties().position); } ::llvm::ArrayRef getPosition(); void setPositionAttr(::mlir::DenseI64ArrayAttr attr) { getProperties().position = attr; } void setPosition(::llvm::ArrayRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::mlir::DenseI64ArrayAttr position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value container, ::mlir::Value value, ::llvm::ArrayRef position); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InsertValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static void getCanonicalizationPatterns(::mlir::RewritePatternSet &results, ::mlir::MLIRContext *context); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::InsertValueOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::InsertValueOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::IntToPtrOp declarations //===----------------------------------------------------------------------===// namespace detail { class IntToPtrOpGenericAdaptorBase { public: struct Properties { using dereferenceableTy = ::mlir::LLVM::DereferenceableAttr; dereferenceableTy dereferenceable; auto getDereferenceable() const { auto &propStorage = this->dereferenceable; return ::llvm::dyn_cast_or_null<::mlir::LLVM::DereferenceableAttr>(propStorage); } void setDereferenceable(const ::mlir::LLVM::DereferenceableAttr &propValue) { this->dereferenceable = propValue; } bool operator==(const Properties &rhs) const { return rhs.dereferenceable == this->dereferenceable && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: IntToPtrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.inttoptr", odsAttrs.getContext()); } IntToPtrOpGenericAdaptorBase(IntToPtrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::DereferenceableAttr getDereferenceableAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::DereferenceableAttr>(getProperties().dereferenceable); return attr; } ::std::optional<::mlir::LLVM::DereferenceableAttr> getDereferenceable(); }; } // namespace detail template class IntToPtrOpGenericAdaptor : public detail::IntToPtrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::IntToPtrOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: IntToPtrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} IntToPtrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : IntToPtrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} IntToPtrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : IntToPtrOpGenericAdaptor(values, attrs, Properties{}, {}) {} IntToPtrOpGenericAdaptor(RangeT values, const IntToPtrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> IntToPtrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class IntToPtrOpAdaptor : public IntToPtrOpGenericAdaptor<::mlir::ValueRange> { public: using IntToPtrOpGenericAdaptor::IntToPtrOpGenericAdaptor; IntToPtrOpAdaptor(IntToPtrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class IntToPtrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::DereferenceableOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = IntToPtrOpAdaptor; template using GenericAdaptor = IntToPtrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::DereferenceableOpInterface::Trait::getDereferenceableOrNull; using ::mlir::LLVM::DereferenceableOpInterface::Trait::setDereferenceable; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("dereferenceable")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getDereferenceableAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getDereferenceableAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.inttoptr"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::DereferenceableAttr getDereferenceableAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::DereferenceableAttr>(getProperties().dereferenceable); } ::std::optional<::mlir::LLVM::DereferenceableAttr> getDereferenceable(); void setDereferenceableAttr(::mlir::LLVM::DereferenceableAttr attr) { getProperties().dereferenceable = attr; } ::mlir::Attribute removeDereferenceableAttr() { auto attr = getProperties().dereferenceable; getProperties().dereferenceable = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static IntToPtrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static IntToPtrOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable); static IntToPtrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable); static IntToPtrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable); static IntToPtrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable); static IntToPtrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static IntToPtrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static IntToPtrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static IntToPtrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static IntToPtrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::IntToPtrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::IntToPtrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::InvokeOp declarations //===----------------------------------------------------------------------===// namespace detail { class InvokeOpGenericAdaptorBase { public: struct Properties { using CConvTy = ::mlir::LLVM::CConvAttr; CConvTy CConv; auto getCConv() const { auto &propStorage = this->CConv; return ::llvm::dyn_cast_or_null<::mlir::LLVM::CConvAttr>(propStorage); } void setCConv(const ::mlir::LLVM::CConvAttr &propValue) { this->CConv = propValue; } using arg_attrsTy = ::mlir::ArrayAttr; arg_attrsTy arg_attrs; auto getArgAttrs() const { auto &propStorage = this->arg_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setArgAttrs(const ::mlir::ArrayAttr &propValue) { this->arg_attrs = propValue; } using branch_weightsTy = ::mlir::DenseI32ArrayAttr; branch_weightsTy branch_weights; auto getBranchWeights() const { auto &propStorage = this->branch_weights; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setBranchWeights(const ::mlir::DenseI32ArrayAttr &propValue) { this->branch_weights = propValue; } using calleeTy = ::mlir::FlatSymbolRefAttr; calleeTy callee; auto getCallee() const { auto &propStorage = this->callee; return ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(propStorage); } void setCallee(const ::mlir::FlatSymbolRefAttr &propValue) { this->callee = propValue; } using op_bundle_sizesTy = ::mlir::DenseI32ArrayAttr; op_bundle_sizesTy op_bundle_sizes; auto getOpBundleSizes() const { auto &propStorage = this->op_bundle_sizes; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setOpBundleSizes(const ::mlir::DenseI32ArrayAttr &propValue) { this->op_bundle_sizes = propValue; } using op_bundle_tagsTy = ::mlir::ArrayAttr; op_bundle_tagsTy op_bundle_tags; auto getOpBundleTags() const { auto &propStorage = this->op_bundle_tags; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setOpBundleTags(const ::mlir::ArrayAttr &propValue) { this->op_bundle_tags = propValue; } using res_attrsTy = ::mlir::ArrayAttr; res_attrsTy res_attrs; auto getResAttrs() const { auto &propStorage = this->res_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setResAttrs(const ::mlir::ArrayAttr &propValue) { this->res_attrs = propValue; } using var_callee_typeTy = ::mlir::TypeAttr; var_callee_typeTy var_callee_type; auto getVarCalleeType() const { auto &propStorage = this->var_callee_type; return ::llvm::dyn_cast_or_null<::mlir::TypeAttr>(propStorage); } void setVarCalleeType(const ::mlir::TypeAttr &propValue) { this->var_callee_type = propValue; } using operandSegmentSizesTy = std::array; operandSegmentSizesTy operandSegmentSizes; ::llvm::ArrayRef getOperandSegmentSizes() const { auto &propStorage = this->operandSegmentSizes; return propStorage; } void setOperandSegmentSizes(::llvm::ArrayRef propValue) { auto &propStorage = this->operandSegmentSizes; ::llvm::copy(propValue, propStorage.begin()); } bool operator==(const Properties &rhs) const { return rhs.CConv == this->CConv && rhs.arg_attrs == this->arg_attrs && rhs.branch_weights == this->branch_weights && rhs.callee == this->callee && rhs.op_bundle_sizes == this->op_bundle_sizes && rhs.op_bundle_tags == this->op_bundle_tags && rhs.res_attrs == this->res_attrs && rhs.var_callee_type == this->var_callee_type && rhs.operandSegmentSizes == this->operandSegmentSizes && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: InvokeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.invoke", odsAttrs.getContext()); } InvokeOpGenericAdaptorBase(InvokeOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::TypeAttr getVarCalleeTypeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::TypeAttr>(getProperties().var_callee_type); return attr; } ::std::optional<::mlir::LLVM::LLVMFunctionType> getVarCalleeType(); ::mlir::FlatSymbolRefAttr getCalleeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(getProperties().callee); return attr; } ::std::optional< ::llvm::StringRef > getCallee(); ::mlir::ArrayAttr getArgAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); ::mlir::DenseI32ArrayAttr getBranchWeightsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().branch_weights); return attr; } ::std::optional<::llvm::ArrayRef> getBranchWeights(); ::mlir::LLVM::CConvAttr getCConvAttr(); ::mlir::LLVM::cconv::CConv getCConv(); ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().op_bundle_sizes); return attr; } ::llvm::ArrayRef getOpBundleSizes(); ::mlir::ArrayAttr getOpBundleTagsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().op_bundle_tags); return attr; } ::std::optional< ::mlir::ArrayAttr > getOpBundleTags(); }; } // namespace detail template class InvokeOpGenericAdaptor : public detail::InvokeOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::InvokeOpGenericAdaptorBase; static constexpr int odsIndex_callee_operands = 0; static constexpr int odsIndex_normalDestOperands = 1; static constexpr int odsIndex_unwindDestOperands = 2; static constexpr int odsIndex_op_bundle_operands = 3; public: InvokeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} InvokeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : InvokeOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} InvokeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs) : InvokeOpGenericAdaptor(values, attrs, Properties{}, {}) {} InvokeOpGenericAdaptor(RangeT values, const InvokeOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> InvokeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getCalleeOperands() { return getODSOperands(0); } RangeT getNormalDestOperands() { return getODSOperands(1); } RangeT getUnwindDestOperands() { return getODSOperands(2); } ::llvm::SmallVector getOpBundleOperands() { auto tblgenTmpOperands = getODSOperands(3); auto sizes = getOpBundleSizes(); ::llvm::SmallVector tblgenTmpOperandGroups; for (int i = 0, e = sizes.size(); i < e; ++i) { tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i])); tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]); } return tblgenTmpOperandGroups; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class InvokeOpAdaptor : public InvokeOpGenericAdaptor<::mlir::ValueRange> { public: using InvokeOpGenericAdaptor::InvokeOpGenericAdaptor; InvokeOpAdaptor(InvokeOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class InvokeOp : public ::mlir::Op::Impl, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::BranchOpInterface::Trait, ::mlir::ArgAndResultAttrsOpInterface::Trait, ::mlir::CallOpInterface::Trait, ::mlir::WeightedBranchOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { public: using Op::Op; using Op::print; using Adaptor = InvokeOpAdaptor; template using GenericAdaptor = InvokeOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_callee_operands = 0; static constexpr int odsIndex_normalDestOperands = 1; static constexpr int odsIndex_unwindDestOperands = 2; static constexpr int odsIndex_op_bundle_operands = 3; using Properties = FoldAdaptor::Properties; using ::mlir::BranchOpInterface::Trait::getSuccessorForOperands; using ::mlir::BranchOpInterface::Trait::areTypesCompatible; using ::mlir::CallOpInterface::Trait::resolveCallableInTable; using ::mlir::CallOpInterface::Trait::resolveCallable; using ::mlir::WeightedBranchOpInterface::Trait::getWeights; using ::mlir::WeightedBranchOpInterface::Trait::setWeights; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("CConv"), ::llvm::StringRef("arg_attrs"), ::llvm::StringRef("branch_weights"), ::llvm::StringRef("callee"), ::llvm::StringRef("op_bundle_sizes"), ::llvm::StringRef("op_bundle_tags"), ::llvm::StringRef("res_attrs"), ::llvm::StringRef("var_callee_type"), ::llvm::StringRef("operandSegmentSizes")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getCConvAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getCConvAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getArgAttrsAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getArgAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getBranchWeightsAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getBranchWeightsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getCalleeAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getCalleeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getOpBundleSizesAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getOpBundleSizesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getOpBundleTagsAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getOpBundleTagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getResAttrsAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getResAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getVarCalleeTypeAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getVarCalleeTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getOperandSegmentSizesAttrName() { return (*this)->getName().getAttributeNames().back(); } static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) { return name.getAttributeNames().back(); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.invoke"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::Operation::operand_range getCalleeOperands() { return getODSOperands(0); } ::mlir::Operation::operand_range getNormalDestOperands() { return getODSOperands(1); } ::mlir::Operation::operand_range getUnwindDestOperands() { return getODSOperands(2); } ::mlir::OperandRangeRange getOpBundleOperands() { return getODSOperands(3).split(getOpBundleSizesAttr()); } ::mlir::MutableOperandRange getCalleeOperandsMutable(); ::mlir::MutableOperandRange getNormalDestOperandsMutable(); ::mlir::MutableOperandRange getUnwindDestOperandsMutable(); ::mlir::MutableOperandRangeRange getOpBundleOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index); ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getResult() { auto results = getODSResults(0); return results.empty() ? ::mlir::TypedValue<::mlir::Type>() : ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*results.begin()); } ::mlir::Block *getNormalDest() { return (*this)->getSuccessor(0); } ::mlir::Block *getUnwindDest() { return (*this)->getSuccessor(1); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::TypeAttr getVarCalleeTypeAttr() { return ::llvm::dyn_cast_or_null<::mlir::TypeAttr>(getProperties().var_callee_type); } ::std::optional<::mlir::LLVM::LLVMFunctionType> getVarCalleeType(); ::mlir::FlatSymbolRefAttr getCalleeAttr() { return ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(getProperties().callee); } ::std::optional< ::llvm::StringRef > getCallee(); ::mlir::ArrayAttr getArgAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); ::mlir::DenseI32ArrayAttr getBranchWeightsAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().branch_weights); } ::std::optional<::llvm::ArrayRef> getBranchWeights(); ::mlir::LLVM::CConvAttr getCConvAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::CConvAttr>(getProperties().CConv); } ::mlir::LLVM::cconv::CConv getCConv(); ::mlir::DenseI32ArrayAttr getOpBundleSizesAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().op_bundle_sizes); } ::llvm::ArrayRef getOpBundleSizes(); ::mlir::ArrayAttr getOpBundleTagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().op_bundle_tags); } ::std::optional< ::mlir::ArrayAttr > getOpBundleTags(); void setVarCalleeTypeAttr(::mlir::TypeAttr attr) { getProperties().var_callee_type = attr; } void setVarCalleeType(::std::optional<::mlir::LLVM::LLVMFunctionType> attrValue); void setCalleeAttr(::mlir::FlatSymbolRefAttr attr) { getProperties().callee = attr; } void setCallee(::std::optional<::llvm::StringRef> attrValue); void setArgAttrsAttr(::mlir::ArrayAttr attr) { getProperties().arg_attrs = attr; } void setResAttrsAttr(::mlir::ArrayAttr attr) { getProperties().res_attrs = attr; } void setBranchWeightsAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().branch_weights = attr; } void setBranchWeights(::std::optional<::llvm::ArrayRef> attrValue); void setCConvAttr(::mlir::LLVM::CConvAttr attr) { getProperties().CConv = attr; } void setCConv(::mlir::LLVM::cconv::CConv attrValue); void setOpBundleSizesAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().op_bundle_sizes = attr; } void setOpBundleSizes(::llvm::ArrayRef attrValue); void setOpBundleTagsAttr(::mlir::ArrayAttr attr) { getProperties().op_bundle_tags = attr; } ::mlir::Attribute removeVarCalleeTypeAttr() { auto attr = getProperties().var_callee_type; getProperties().var_callee_type = {}; return attr; } ::mlir::Attribute removeCalleeAttr() { auto attr = getProperties().callee; getProperties().callee = {}; return attr; } ::mlir::Attribute removeArgAttrsAttr() { auto attr = getProperties().arg_attrs; getProperties().arg_attrs = {}; return attr; } ::mlir::Attribute removeResAttrsAttr() { auto attr = getProperties().res_attrs; getProperties().res_attrs = {}; return attr; } ::mlir::Attribute removeBranchWeightsAttr() { auto attr = getProperties().branch_weights; getProperties().branch_weights = {}; return attr; } ::mlir::Attribute removeOpBundleTagsAttr() { auto attr = getProperties().op_bundle_tags; getProperties().op_bundle_tags = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFuncOp func, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFuncOp func, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFuncOp func, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, TypeRange tys, FlatSymbolRefAttr callee, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, TypeRange tys, FlatSymbolRefAttr callee, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, TypeRange tys, FlatSymbolRefAttr callee, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange ops, Block*normal, ValueRange normalOps, Block*unwind, ValueRange unwindOps); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::CConvAttr CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::CConvAttr CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::CConvAttr CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::CConvAttr CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::CConvAttr CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::CConvAttr CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::cconv::CConv CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::cconv::CConv CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Type result, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::cconv::CConv CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::cconv::CConv CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::cconv::CConv CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/::mlir::TypeAttr var_callee_type, /*optional*/::mlir::FlatSymbolRefAttr callee, ::mlir::ValueRange callee_operands, /*optional*/::mlir::ArrayAttr arg_attrs, /*optional*/::mlir::ArrayAttr res_attrs, ::mlir::ValueRange normalDestOperands, ::mlir::ValueRange unwindDestOperands, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::LLVM::cconv::CConv CConv, ::llvm::ArrayRef<::mlir::ValueRange> op_bundle_operands, /*optional*/::mlir::ArrayAttr op_bundle_tags, ::mlir::Block *normalDest, ::mlir::Block *unwindDest); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InvokeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static InvokeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::SuccessorOperands getSuccessorOperands(unsigned index); ::mlir::CallInterfaceCallable getCallableForCallee(); void setCalleeFromCallable(::mlir::CallInterfaceCallable callee); ::mlir::Operation::operand_range getArgOperands(); ::mlir::MutableOperandRange getArgOperandsMutable(); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 8 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Returns the callee function type. LLVMFunctionType getCalleeFunctionType(); }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::InvokeOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::InvokeOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::LLVMFuncOp declarations //===----------------------------------------------------------------------===// namespace detail { class LLVMFuncOpGenericAdaptorBase { public: struct Properties { using CConvTy = ::mlir::LLVM::CConvAttr; CConvTy CConv; auto getCConv() const { auto &propStorage = this->CConv; return ::llvm::dyn_cast_or_null<::mlir::LLVM::CConvAttr>(propStorage); } void setCConv(const ::mlir::LLVM::CConvAttr &propValue) { this->CConv = propValue; } using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using allocsizeTy = ::mlir::DenseI32ArrayAttr; allocsizeTy allocsize; auto getAllocsize() const { auto &propStorage = this->allocsize; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setAllocsize(const ::mlir::DenseI32ArrayAttr &propValue) { this->allocsize = propValue; } using always_inlineTy = ::mlir::UnitAttr; always_inlineTy always_inline; auto getAlwaysInline() const { auto &propStorage = this->always_inline; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setAlwaysInline(const ::mlir::UnitAttr &propValue) { this->always_inline = propValue; } using arg_attrsTy = ::mlir::ArrayAttr; arg_attrsTy arg_attrs; auto getArgAttrs() const { auto &propStorage = this->arg_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setArgAttrs(const ::mlir::ArrayAttr &propValue) { this->arg_attrs = propValue; } using arm_in_zaTy = ::mlir::UnitAttr; arm_in_zaTy arm_in_za; auto getArmInZa() const { auto &propStorage = this->arm_in_za; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmInZa(const ::mlir::UnitAttr &propValue) { this->arm_in_za = propValue; } using arm_inout_zaTy = ::mlir::UnitAttr; arm_inout_zaTy arm_inout_za; auto getArmInoutZa() const { auto &propStorage = this->arm_inout_za; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmInoutZa(const ::mlir::UnitAttr &propValue) { this->arm_inout_za = propValue; } using arm_locally_streamingTy = ::mlir::UnitAttr; arm_locally_streamingTy arm_locally_streaming; auto getArmLocallyStreaming() const { auto &propStorage = this->arm_locally_streaming; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmLocallyStreaming(const ::mlir::UnitAttr &propValue) { this->arm_locally_streaming = propValue; } using arm_new_zaTy = ::mlir::UnitAttr; arm_new_zaTy arm_new_za; auto getArmNewZa() const { auto &propStorage = this->arm_new_za; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmNewZa(const ::mlir::UnitAttr &propValue) { this->arm_new_za = propValue; } using arm_out_zaTy = ::mlir::UnitAttr; arm_out_zaTy arm_out_za; auto getArmOutZa() const { auto &propStorage = this->arm_out_za; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmOutZa(const ::mlir::UnitAttr &propValue) { this->arm_out_za = propValue; } using arm_preserves_zaTy = ::mlir::UnitAttr; arm_preserves_zaTy arm_preserves_za; auto getArmPreservesZa() const { auto &propStorage = this->arm_preserves_za; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmPreservesZa(const ::mlir::UnitAttr &propValue) { this->arm_preserves_za = propValue; } using arm_streamingTy = ::mlir::UnitAttr; arm_streamingTy arm_streaming; auto getArmStreaming() const { auto &propStorage = this->arm_streaming; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmStreaming(const ::mlir::UnitAttr &propValue) { this->arm_streaming = propValue; } using arm_streaming_compatibleTy = ::mlir::UnitAttr; arm_streaming_compatibleTy arm_streaming_compatible; auto getArmStreamingCompatible() const { auto &propStorage = this->arm_streaming_compatible; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setArmStreamingCompatible(const ::mlir::UnitAttr &propValue) { this->arm_streaming_compatible = propValue; } using coldTy = ::mlir::UnitAttr; coldTy cold; auto getCold() const { auto &propStorage = this->cold; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setCold(const ::mlir::UnitAttr &propValue) { this->cold = propValue; } using comdatTy = ::mlir::SymbolRefAttr; comdatTy comdat; auto getComdat() const { auto &propStorage = this->comdat; return ::llvm::dyn_cast_or_null<::mlir::SymbolRefAttr>(propStorage); } void setComdat(const ::mlir::SymbolRefAttr &propValue) { this->comdat = propValue; } using convergentTy = ::mlir::UnitAttr; convergentTy convergent; auto getConvergent() const { auto &propStorage = this->convergent; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setConvergent(const ::mlir::UnitAttr &propValue) { this->convergent = propValue; } using default_func_attrsTy = ::mlir::DictionaryAttr; default_func_attrsTy default_func_attrs; auto getDefaultFuncAttrs() const { auto &propStorage = this->default_func_attrs; return ::llvm::dyn_cast_or_null<::mlir::DictionaryAttr>(propStorage); } void setDefaultFuncAttrs(const ::mlir::DictionaryAttr &propValue) { this->default_func_attrs = propValue; } using denormal_fpenvTy = ::mlir::LLVM::DenormalFPEnvAttr; denormal_fpenvTy denormal_fpenv; auto getDenormalFpenv() const { auto &propStorage = this->denormal_fpenv; return ::llvm::dyn_cast_or_null<::mlir::LLVM::DenormalFPEnvAttr>(propStorage); } void setDenormalFpenv(const ::mlir::LLVM::DenormalFPEnvAttr &propValue) { this->denormal_fpenv = propValue; } using dso_localTy = ::mlir::UnitAttr; dso_localTy dso_local; auto getDsoLocal() const { auto &propStorage = this->dso_local; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setDsoLocal(const ::mlir::UnitAttr &propValue) { this->dso_local = propValue; } using fp_contractTy = ::mlir::StringAttr; fp_contractTy fp_contract; auto getFpContract() const { auto &propStorage = this->fp_contract; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setFpContract(const ::mlir::StringAttr &propValue) { this->fp_contract = propValue; } using frame_pointerTy = ::mlir::LLVM::FramePointerKindAttr; frame_pointerTy frame_pointer; auto getFramePointer() const { auto &propStorage = this->frame_pointer; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FramePointerKindAttr>(propStorage); } void setFramePointer(const ::mlir::LLVM::FramePointerKindAttr &propValue) { this->frame_pointer = propValue; } using function_entry_countTy = ::mlir::IntegerAttr; function_entry_countTy function_entry_count; auto getFunctionEntryCount() const { auto &propStorage = this->function_entry_count; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setFunctionEntryCount(const ::mlir::IntegerAttr &propValue) { this->function_entry_count = propValue; } using function_typeTy = ::mlir::TypeAttr; function_typeTy function_type; auto getFunctionType() const { auto &propStorage = this->function_type; return ::llvm::cast<::mlir::TypeAttr>(propStorage); } void setFunctionType(const ::mlir::TypeAttr &propValue) { this->function_type = propValue; } using garbageCollectorTy = ::mlir::StringAttr; garbageCollectorTy garbageCollector; auto getGarbageCollector() const { auto &propStorage = this->garbageCollector; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setGarbageCollector(const ::mlir::StringAttr &propValue) { this->garbageCollector = propValue; } using hotTy = ::mlir::UnitAttr; hotTy hot; auto getHot() const { auto &propStorage = this->hot; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setHot(const ::mlir::UnitAttr &propValue) { this->hot = propValue; } using inline_hintTy = ::mlir::UnitAttr; inline_hintTy inline_hint; auto getInlineHint() const { auto &propStorage = this->inline_hint; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setInlineHint(const ::mlir::UnitAttr &propValue) { this->inline_hint = propValue; } using instrument_function_entryTy = ::mlir::StringAttr; instrument_function_entryTy instrument_function_entry; auto getInstrumentFunctionEntry() const { auto &propStorage = this->instrument_function_entry; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setInstrumentFunctionEntry(const ::mlir::StringAttr &propValue) { this->instrument_function_entry = propValue; } using instrument_function_exitTy = ::mlir::StringAttr; instrument_function_exitTy instrument_function_exit; auto getInstrumentFunctionExit() const { auto &propStorage = this->instrument_function_exit; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setInstrumentFunctionExit(const ::mlir::StringAttr &propValue) { this->instrument_function_exit = propValue; } using intel_reqd_sub_group_sizeTy = ::mlir::IntegerAttr; intel_reqd_sub_group_sizeTy intel_reqd_sub_group_size; auto getIntelReqdSubGroupSize() const { auto &propStorage = this->intel_reqd_sub_group_size; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setIntelReqdSubGroupSize(const ::mlir::IntegerAttr &propValue) { this->intel_reqd_sub_group_size = propValue; } using linkageTy = ::mlir::LLVM::LinkageAttr; linkageTy linkage; auto getLinkage() const { auto &propStorage = this->linkage; return ::llvm::dyn_cast_or_null<::mlir::LLVM::LinkageAttr>(propStorage); } void setLinkage(const ::mlir::LLVM::LinkageAttr &propValue) { this->linkage = propValue; } using memory_effectsTy = ::mlir::LLVM::MemoryEffectsAttr; memory_effectsTy memory_effects; auto getMemoryEffects() const { auto &propStorage = this->memory_effects; return ::llvm::dyn_cast_or_null<::mlir::LLVM::MemoryEffectsAttr>(propStorage); } void setMemoryEffects(const ::mlir::LLVM::MemoryEffectsAttr &propValue) { this->memory_effects = propValue; } using minsizeTy = ::mlir::UnitAttr; minsizeTy minsize; auto getMinsize() const { auto &propStorage = this->minsize; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setMinsize(const ::mlir::UnitAttr &propValue) { this->minsize = propValue; } using modular_formatTy = ::mlir::StringAttr; modular_formatTy modular_format; auto getModularFormat() const { auto &propStorage = this->modular_format; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setModularFormat(const ::mlir::StringAttr &propValue) { this->modular_format = propValue; } using no_caller_saved_registersTy = ::mlir::UnitAttr; no_caller_saved_registersTy no_caller_saved_registers; auto getNoCallerSavedRegisters() const { auto &propStorage = this->no_caller_saved_registers; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoCallerSavedRegisters(const ::mlir::UnitAttr &propValue) { this->no_caller_saved_registers = propValue; } using no_inlineTy = ::mlir::UnitAttr; no_inlineTy no_inline; auto getNoInline() const { auto &propStorage = this->no_inline; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoInline(const ::mlir::UnitAttr &propValue) { this->no_inline = propValue; } using no_signed_zeros_fp_mathTy = ::mlir::BoolAttr; no_signed_zeros_fp_mathTy no_signed_zeros_fp_math; auto getNoSignedZerosFpMath() const { auto &propStorage = this->no_signed_zeros_fp_math; return ::llvm::dyn_cast_or_null<::mlir::BoolAttr>(propStorage); } void setNoSignedZerosFpMath(const ::mlir::BoolAttr &propValue) { this->no_signed_zeros_fp_math = propValue; } using no_unwindTy = ::mlir::UnitAttr; no_unwindTy no_unwind; auto getNoUnwind() const { auto &propStorage = this->no_unwind; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoUnwind(const ::mlir::UnitAttr &propValue) { this->no_unwind = propValue; } using nobuiltinsTy = ::mlir::ArrayAttr; nobuiltinsTy nobuiltins; auto getNobuiltins() const { auto &propStorage = this->nobuiltins; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNobuiltins(const ::mlir::ArrayAttr &propValue) { this->nobuiltins = propValue; } using nocallbackTy = ::mlir::UnitAttr; nocallbackTy nocallback; auto getNocallback() const { auto &propStorage = this->nocallback; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNocallback(const ::mlir::UnitAttr &propValue) { this->nocallback = propValue; } using noduplicateTy = ::mlir::UnitAttr; noduplicateTy noduplicate; auto getNoduplicate() const { auto &propStorage = this->noduplicate; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoduplicate(const ::mlir::UnitAttr &propValue) { this->noduplicate = propValue; } using noreturnTy = ::mlir::UnitAttr; noreturnTy noreturn; auto getNoreturn() const { auto &propStorage = this->noreturn; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNoreturn(const ::mlir::UnitAttr &propValue) { this->noreturn = propValue; } using optimize_noneTy = ::mlir::UnitAttr; optimize_noneTy optimize_none; auto getOptimizeNone() const { auto &propStorage = this->optimize_none; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setOptimizeNone(const ::mlir::UnitAttr &propValue) { this->optimize_none = propValue; } using optsizeTy = ::mlir::UnitAttr; optsizeTy optsize; auto getOptsize() const { auto &propStorage = this->optsize; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setOptsize(const ::mlir::UnitAttr &propValue) { this->optsize = propValue; } using passthroughTy = ::mlir::ArrayAttr; passthroughTy passthrough; auto getPassthrough() const { auto &propStorage = this->passthrough; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setPassthrough(const ::mlir::ArrayAttr &propValue) { this->passthrough = propValue; } using personalityTy = ::mlir::FlatSymbolRefAttr; personalityTy personality; auto getPersonality() const { auto &propStorage = this->personality; return ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(propStorage); } void setPersonality(const ::mlir::FlatSymbolRefAttr &propValue) { this->personality = propValue; } using prefer_vector_widthTy = ::mlir::StringAttr; prefer_vector_widthTy prefer_vector_width; auto getPreferVectorWidth() const { auto &propStorage = this->prefer_vector_width; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setPreferVectorWidth(const ::mlir::StringAttr &propValue) { this->prefer_vector_width = propValue; } using reciprocal_estimatesTy = ::mlir::StringAttr; reciprocal_estimatesTy reciprocal_estimates; auto getReciprocalEstimates() const { auto &propStorage = this->reciprocal_estimates; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setReciprocalEstimates(const ::mlir::StringAttr &propValue) { this->reciprocal_estimates = propValue; } using reqd_work_group_sizeTy = ::mlir::DenseI32ArrayAttr; reqd_work_group_sizeTy reqd_work_group_size; auto getReqdWorkGroupSize() const { auto &propStorage = this->reqd_work_group_size; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setReqdWorkGroupSize(const ::mlir::DenseI32ArrayAttr &propValue) { this->reqd_work_group_size = propValue; } using res_attrsTy = ::mlir::ArrayAttr; res_attrsTy res_attrs; auto getResAttrs() const { auto &propStorage = this->res_attrs; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setResAttrs(const ::mlir::ArrayAttr &propValue) { this->res_attrs = propValue; } using returns_twiceTy = ::mlir::UnitAttr; returns_twiceTy returns_twice; auto getReturnsTwice() const { auto &propStorage = this->returns_twice; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setReturnsTwice(const ::mlir::UnitAttr &propValue) { this->returns_twice = propValue; } using save_reg_paramsTy = ::mlir::UnitAttr; save_reg_paramsTy save_reg_params; auto getSaveRegParams() const { auto &propStorage = this->save_reg_params; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setSaveRegParams(const ::mlir::UnitAttr &propValue) { this->save_reg_params = propValue; } using sectionTy = ::mlir::StringAttr; sectionTy section; auto getSection() const { auto &propStorage = this->section; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSection(const ::mlir::StringAttr &propValue) { this->section = propValue; } using sym_nameTy = ::mlir::StringAttr; sym_nameTy sym_name; auto getSymName() const { auto &propStorage = this->sym_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setSymName(const ::mlir::StringAttr &propValue) { this->sym_name = propValue; } using sym_visibilityTy = ::mlir::StringAttr; sym_visibilityTy sym_visibility; auto getSymVisibility() const { auto &propStorage = this->sym_visibility; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSymVisibility(const ::mlir::StringAttr &propValue) { this->sym_visibility = propValue; } using target_cpuTy = ::mlir::StringAttr; target_cpuTy target_cpu; auto getTargetCpu() const { auto &propStorage = this->target_cpu; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setTargetCpu(const ::mlir::StringAttr &propValue) { this->target_cpu = propValue; } using target_featuresTy = ::mlir::LLVM::TargetFeaturesAttr; target_featuresTy target_features; auto getTargetFeatures() const { auto &propStorage = this->target_features; return ::llvm::dyn_cast_or_null<::mlir::LLVM::TargetFeaturesAttr>(propStorage); } void setTargetFeatures(const ::mlir::LLVM::TargetFeaturesAttr &propValue) { this->target_features = propValue; } using tune_cpuTy = ::mlir::StringAttr; tune_cpuTy tune_cpu; auto getTuneCpu() const { auto &propStorage = this->tune_cpu; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setTuneCpu(const ::mlir::StringAttr &propValue) { this->tune_cpu = propValue; } using unnamed_addrTy = ::mlir::LLVM::UnnamedAddrAttr; unnamed_addrTy unnamed_addr; auto getUnnamedAddr() const { auto &propStorage = this->unnamed_addr; return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(propStorage); } void setUnnamedAddr(const ::mlir::LLVM::UnnamedAddrAttr &propValue) { this->unnamed_addr = propValue; } using use_sample_profileTy = ::mlir::BoolAttr; use_sample_profileTy use_sample_profile; auto getUseSampleProfile() const { auto &propStorage = this->use_sample_profile; return ::llvm::dyn_cast_or_null<::mlir::BoolAttr>(propStorage); } void setUseSampleProfile(const ::mlir::BoolAttr &propValue) { this->use_sample_profile = propValue; } using uwtable_kindTy = ::mlir::LLVM::UWTableKindAttr; uwtable_kindTy uwtable_kind; auto getUwtableKind() const { auto &propStorage = this->uwtable_kind; return ::llvm::dyn_cast_or_null<::mlir::LLVM::UWTableKindAttr>(propStorage); } void setUwtableKind(const ::mlir::LLVM::UWTableKindAttr &propValue) { this->uwtable_kind = propValue; } using vec_type_hintTy = ::mlir::LLVM::VecTypeHintAttr; vec_type_hintTy vec_type_hint; auto getVecTypeHint() const { auto &propStorage = this->vec_type_hint; return ::llvm::dyn_cast_or_null<::mlir::LLVM::VecTypeHintAttr>(propStorage); } void setVecTypeHint(const ::mlir::LLVM::VecTypeHintAttr &propValue) { this->vec_type_hint = propValue; } using visibility_Ty = ::mlir::LLVM::VisibilityAttr; visibility_Ty visibility_; auto getVisibility_() const { auto &propStorage = this->visibility_; return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(propStorage); } void setVisibility_(const ::mlir::LLVM::VisibilityAttr &propValue) { this->visibility_ = propValue; } using vscale_rangeTy = ::mlir::LLVM::VScaleRangeAttr; vscale_rangeTy vscale_range; auto getVscaleRange() const { auto &propStorage = this->vscale_range; return ::llvm::dyn_cast_or_null<::mlir::LLVM::VScaleRangeAttr>(propStorage); } void setVscaleRange(const ::mlir::LLVM::VScaleRangeAttr &propValue) { this->vscale_range = propValue; } using will_returnTy = ::mlir::UnitAttr; will_returnTy will_return; auto getWillReturn() const { auto &propStorage = this->will_return; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setWillReturn(const ::mlir::UnitAttr &propValue) { this->will_return = propValue; } using work_group_size_hintTy = ::mlir::DenseI32ArrayAttr; work_group_size_hintTy work_group_size_hint; auto getWorkGroupSizeHint() const { auto &propStorage = this->work_group_size_hint; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setWorkGroupSizeHint(const ::mlir::DenseI32ArrayAttr &propValue) { this->work_group_size_hint = propValue; } using zero_call_used_regsTy = ::mlir::StringAttr; zero_call_used_regsTy zero_call_used_regs; auto getZeroCallUsedRegs() const { auto &propStorage = this->zero_call_used_regs; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setZeroCallUsedRegs(const ::mlir::StringAttr &propValue) { this->zero_call_used_regs = propValue; } bool operator==(const Properties &rhs) const { return rhs.CConv == this->CConv && rhs.alignment == this->alignment && rhs.allocsize == this->allocsize && rhs.always_inline == this->always_inline && rhs.arg_attrs == this->arg_attrs && rhs.arm_in_za == this->arm_in_za && rhs.arm_inout_za == this->arm_inout_za && rhs.arm_locally_streaming == this->arm_locally_streaming && rhs.arm_new_za == this->arm_new_za && rhs.arm_out_za == this->arm_out_za && rhs.arm_preserves_za == this->arm_preserves_za && rhs.arm_streaming == this->arm_streaming && rhs.arm_streaming_compatible == this->arm_streaming_compatible && rhs.cold == this->cold && rhs.comdat == this->comdat && rhs.convergent == this->convergent && rhs.default_func_attrs == this->default_func_attrs && rhs.denormal_fpenv == this->denormal_fpenv && rhs.dso_local == this->dso_local && rhs.fp_contract == this->fp_contract && rhs.frame_pointer == this->frame_pointer && rhs.function_entry_count == this->function_entry_count && rhs.function_type == this->function_type && rhs.garbageCollector == this->garbageCollector && rhs.hot == this->hot && rhs.inline_hint == this->inline_hint && rhs.instrument_function_entry == this->instrument_function_entry && rhs.instrument_function_exit == this->instrument_function_exit && rhs.intel_reqd_sub_group_size == this->intel_reqd_sub_group_size && rhs.linkage == this->linkage && rhs.memory_effects == this->memory_effects && rhs.minsize == this->minsize && rhs.modular_format == this->modular_format && rhs.no_caller_saved_registers == this->no_caller_saved_registers && rhs.no_inline == this->no_inline && rhs.no_signed_zeros_fp_math == this->no_signed_zeros_fp_math && rhs.no_unwind == this->no_unwind && rhs.nobuiltins == this->nobuiltins && rhs.nocallback == this->nocallback && rhs.noduplicate == this->noduplicate && rhs.noreturn == this->noreturn && rhs.optimize_none == this->optimize_none && rhs.optsize == this->optsize && rhs.passthrough == this->passthrough && rhs.personality == this->personality && rhs.prefer_vector_width == this->prefer_vector_width && rhs.reciprocal_estimates == this->reciprocal_estimates && rhs.reqd_work_group_size == this->reqd_work_group_size && rhs.res_attrs == this->res_attrs && rhs.returns_twice == this->returns_twice && rhs.save_reg_params == this->save_reg_params && rhs.section == this->section && rhs.sym_name == this->sym_name && rhs.sym_visibility == this->sym_visibility && rhs.target_cpu == this->target_cpu && rhs.target_features == this->target_features && rhs.tune_cpu == this->tune_cpu && rhs.unnamed_addr == this->unnamed_addr && rhs.use_sample_profile == this->use_sample_profile && rhs.uwtable_kind == this->uwtable_kind && rhs.vec_type_hint == this->vec_type_hint && rhs.visibility_ == this->visibility_ && rhs.vscale_range == this->vscale_range && rhs.will_return == this->will_return && rhs.work_group_size_hint == this->work_group_size_hint && rhs.zero_call_used_regs == this->zero_call_used_regs && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: LLVMFuncOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.func", odsAttrs.getContext()); } LLVMFuncOpGenericAdaptorBase(LLVMFuncOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getSymNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); return attr; } ::llvm::StringRef getSymName(); ::mlir::StringAttr getSymVisibilityAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().sym_visibility); return attr; } ::std::optional< ::llvm::StringRef > getSymVisibility(); ::mlir::TypeAttr getFunctionTypeAttr() { auto attr = ::llvm::cast<::mlir::TypeAttr>(getProperties().function_type); return attr; } ::mlir::LLVM::LLVMFunctionType getFunctionType(); ::mlir::LLVM::LinkageAttr getLinkageAttr(); ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr(); bool getDsoLocal(); ::mlir::LLVM::CConvAttr getCConvAttr(); ::mlir::LLVM::cconv::CConv getCConv(); ::mlir::SymbolRefAttr getComdatAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::SymbolRefAttr>(getProperties().comdat); return attr; } ::std::optional< ::mlir::SymbolRefAttr > getComdat(); ::mlir::UnitAttr getConvergentAttr(); bool getConvergent(); ::mlir::FlatSymbolRefAttr getPersonalityAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(getProperties().personality); return attr; } ::std::optional< ::llvm::StringRef > getPersonality(); ::mlir::StringAttr getGarbageCollectorAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().garbageCollector); return attr; } ::std::optional< ::llvm::StringRef > getGarbageCollector(); ::mlir::ArrayAttr getPassthroughAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().passthrough); return attr; } ::std::optional< ::mlir::ArrayAttr > getPassthrough(); ::mlir::ArrayAttr getArgAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); return attr; } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); ::mlir::IntegerAttr getFunctionEntryCountAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().function_entry_count); return attr; } ::std::optional getFunctionEntryCount(); ::mlir::LLVM::MemoryEffectsAttr getMemoryEffectsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::MemoryEffectsAttr>(getProperties().memory_effects); return attr; } ::std::optional<::mlir::LLVM::MemoryEffectsAttr> getMemoryEffects(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr(); ::mlir::LLVM::Visibility getVisibility_(); ::mlir::UnitAttr getArmStreamingAttr(); bool getArmStreaming(); ::mlir::UnitAttr getArmLocallyStreamingAttr(); bool getArmLocallyStreaming(); ::mlir::UnitAttr getArmStreamingCompatibleAttr(); bool getArmStreamingCompatible(); ::mlir::UnitAttr getArmNewZaAttr(); bool getArmNewZa(); ::mlir::UnitAttr getArmInZaAttr(); bool getArmInZa(); ::mlir::UnitAttr getArmOutZaAttr(); bool getArmOutZa(); ::mlir::UnitAttr getArmInoutZaAttr(); bool getArmInoutZa(); ::mlir::UnitAttr getArmPreservesZaAttr(); bool getArmPreservesZa(); ::mlir::StringAttr getSectionAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().section); return attr; } ::std::optional< ::llvm::StringRef > getSection(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); return attr; } ::std::optional<::mlir::LLVM::UnnamedAddr> getUnnamedAddr(); ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::LLVM::VScaleRangeAttr getVscaleRangeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::VScaleRangeAttr>(getProperties().vscale_range); return attr; } ::std::optional<::mlir::LLVM::VScaleRangeAttr> getVscaleRange(); ::mlir::LLVM::FramePointerKindAttr getFramePointerAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::FramePointerKindAttr>(getProperties().frame_pointer); return attr; } ::std::optional<::mlir::LLVM::FramePointerKindAttr> getFramePointer(); ::mlir::StringAttr getTargetCpuAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().target_cpu); return attr; } ::std::optional< ::llvm::StringRef > getTargetCpu(); ::mlir::StringAttr getTuneCpuAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().tune_cpu); return attr; } ::std::optional< ::llvm::StringRef > getTuneCpu(); ::mlir::StringAttr getReciprocalEstimatesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().reciprocal_estimates); return attr; } ::std::optional< ::llvm::StringRef > getReciprocalEstimates(); ::mlir::StringAttr getPreferVectorWidthAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().prefer_vector_width); return attr; } ::std::optional< ::llvm::StringRef > getPreferVectorWidth(); ::mlir::LLVM::TargetFeaturesAttr getTargetFeaturesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::TargetFeaturesAttr>(getProperties().target_features); return attr; } ::std::optional<::mlir::LLVM::TargetFeaturesAttr> getTargetFeatures(); ::mlir::BoolAttr getNoSignedZerosFpMathAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::BoolAttr>(getProperties().no_signed_zeros_fp_math); return attr; } ::std::optional< bool > getNoSignedZerosFpMath(); ::mlir::LLVM::DenormalFPEnvAttr getDenormalFpenvAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::DenormalFPEnvAttr>(getProperties().denormal_fpenv); return attr; } ::std::optional<::mlir::LLVM::DenormalFPEnvAttr> getDenormalFpenv(); ::mlir::StringAttr getFpContractAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().fp_contract); return attr; } ::std::optional< ::llvm::StringRef > getFpContract(); ::mlir::StringAttr getInstrumentFunctionEntryAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().instrument_function_entry); return attr; } ::std::optional< ::llvm::StringRef > getInstrumentFunctionEntry(); ::mlir::StringAttr getInstrumentFunctionExitAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().instrument_function_exit); return attr; } ::std::optional< ::llvm::StringRef > getInstrumentFunctionExit(); ::mlir::UnitAttr getNoInlineAttr(); bool getNoInline(); ::mlir::UnitAttr getAlwaysInlineAttr(); bool getAlwaysInline(); ::mlir::UnitAttr getInlineHintAttr(); bool getInlineHint(); ::mlir::UnitAttr getNoUnwindAttr(); bool getNoUnwind(); ::mlir::UnitAttr getWillReturnAttr(); bool getWillReturn(); ::mlir::UnitAttr getNoreturnAttr(); bool getNoreturn(); ::mlir::UnitAttr getOptimizeNoneAttr(); bool getOptimizeNone(); ::mlir::UnitAttr getReturnsTwiceAttr(); bool getReturnsTwice(); ::mlir::UnitAttr getHotAttr(); bool getHot(); ::mlir::UnitAttr getColdAttr(); bool getCold(); ::mlir::UnitAttr getNoduplicateAttr(); bool getNoduplicate(); ::mlir::UnitAttr getNoCallerSavedRegistersAttr(); bool getNoCallerSavedRegisters(); ::mlir::UnitAttr getNocallbackAttr(); bool getNocallback(); ::mlir::StringAttr getModularFormatAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().modular_format); return attr; } ::std::optional< ::llvm::StringRef > getModularFormat(); ::mlir::ArrayAttr getNobuiltinsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().nobuiltins); return attr; } ::std::optional< ::mlir::ArrayAttr > getNobuiltins(); ::mlir::DenseI32ArrayAttr getAllocsizeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().allocsize); return attr; } ::std::optional<::llvm::ArrayRef> getAllocsize(); ::mlir::UnitAttr getOptsizeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().optsize); return attr; } ::std::optional getOptsize(); ::mlir::UnitAttr getMinsizeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().minsize); return attr; } ::std::optional getMinsize(); ::mlir::UnitAttr getSaveRegParamsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().save_reg_params); return attr; } ::std::optional getSaveRegParams(); ::mlir::StringAttr getZeroCallUsedRegsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().zero_call_used_regs); return attr; } ::std::optional< ::llvm::StringRef > getZeroCallUsedRegs(); ::mlir::DictionaryAttr getDefaultFuncAttrsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DictionaryAttr>(getProperties().default_func_attrs); return attr; } ::std::optional< ::mlir::DictionaryAttr > getDefaultFuncAttrs(); ::mlir::LLVM::VecTypeHintAttr getVecTypeHintAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::VecTypeHintAttr>(getProperties().vec_type_hint); return attr; } ::std::optional<::mlir::LLVM::VecTypeHintAttr> getVecTypeHint(); ::mlir::DenseI32ArrayAttr getWorkGroupSizeHintAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().work_group_size_hint); return attr; } ::std::optional<::llvm::ArrayRef> getWorkGroupSizeHint(); ::mlir::DenseI32ArrayAttr getReqdWorkGroupSizeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().reqd_work_group_size); return attr; } ::std::optional<::llvm::ArrayRef> getReqdWorkGroupSize(); ::mlir::IntegerAttr getIntelReqdSubGroupSizeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().intel_reqd_sub_group_size); return attr; } ::std::optional getIntelReqdSubGroupSize(); ::mlir::LLVM::UWTableKindAttr getUwtableKindAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::UWTableKindAttr>(getProperties().uwtable_kind); return attr; } ::std::optional<::mlir::LLVM::UWTableKindAttr> getUwtableKind(); ::mlir::BoolAttr getUseSampleProfileAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::BoolAttr>(getProperties().use_sample_profile); return attr; } ::std::optional< bool > getUseSampleProfile(); ::mlir::Region &getBody() { return *odsRegions[0]; } ::mlir::RegionRange getRegions() { return odsRegions; } }; } // namespace detail template class LLVMFuncOpGenericAdaptor : public detail::LLVMFuncOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::LLVMFuncOpGenericAdaptorBase; public: LLVMFuncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} LLVMFuncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : LLVMFuncOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} LLVMFuncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : LLVMFuncOpGenericAdaptor(values, attrs, Properties{}, {}) {} LLVMFuncOpGenericAdaptor(RangeT values, const LLVMFuncOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> LLVMFuncOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class LLVMFuncOpAdaptor : public LLVMFuncOpGenericAdaptor<::mlir::ValueRange> { public: using LLVMFuncOpGenericAdaptor::LLVMFuncOpGenericAdaptor; LLVMFuncOpAdaptor(LLVMFuncOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class LLVMFuncOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = LLVMFuncOpAdaptor; template using GenericAdaptor = LLVMFuncOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("CConv"), ::llvm::StringRef("alignment"), ::llvm::StringRef("allocsize"), ::llvm::StringRef("always_inline"), ::llvm::StringRef("arg_attrs"), ::llvm::StringRef("arm_in_za"), ::llvm::StringRef("arm_inout_za"), ::llvm::StringRef("arm_locally_streaming"), ::llvm::StringRef("arm_new_za"), ::llvm::StringRef("arm_out_za"), ::llvm::StringRef("arm_preserves_za"), ::llvm::StringRef("arm_streaming"), ::llvm::StringRef("arm_streaming_compatible"), ::llvm::StringRef("cold"), ::llvm::StringRef("comdat"), ::llvm::StringRef("convergent"), ::llvm::StringRef("default_func_attrs"), ::llvm::StringRef("denormal_fpenv"), ::llvm::StringRef("dso_local"), ::llvm::StringRef("fp_contract"), ::llvm::StringRef("frame_pointer"), ::llvm::StringRef("function_entry_count"), ::llvm::StringRef("function_type"), ::llvm::StringRef("garbageCollector"), ::llvm::StringRef("hot"), ::llvm::StringRef("inline_hint"), ::llvm::StringRef("instrument_function_entry"), ::llvm::StringRef("instrument_function_exit"), ::llvm::StringRef("intel_reqd_sub_group_size"), ::llvm::StringRef("linkage"), ::llvm::StringRef("memory_effects"), ::llvm::StringRef("minsize"), ::llvm::StringRef("modular_format"), ::llvm::StringRef("no_caller_saved_registers"), ::llvm::StringRef("no_inline"), ::llvm::StringRef("no_signed_zeros_fp_math"), ::llvm::StringRef("no_unwind"), ::llvm::StringRef("nobuiltins"), ::llvm::StringRef("nocallback"), ::llvm::StringRef("noduplicate"), ::llvm::StringRef("noreturn"), ::llvm::StringRef("optimize_none"), ::llvm::StringRef("optsize"), ::llvm::StringRef("passthrough"), ::llvm::StringRef("personality"), ::llvm::StringRef("prefer_vector_width"), ::llvm::StringRef("reciprocal_estimates"), ::llvm::StringRef("reqd_work_group_size"), ::llvm::StringRef("res_attrs"), ::llvm::StringRef("returns_twice"), ::llvm::StringRef("save_reg_params"), ::llvm::StringRef("section"), ::llvm::StringRef("sym_name"), ::llvm::StringRef("sym_visibility"), ::llvm::StringRef("target_cpu"), ::llvm::StringRef("target_features"), ::llvm::StringRef("tune_cpu"), ::llvm::StringRef("unnamed_addr"), ::llvm::StringRef("use_sample_profile"), ::llvm::StringRef("uwtable_kind"), ::llvm::StringRef("vec_type_hint"), ::llvm::StringRef("visibility_"), ::llvm::StringRef("vscale_range"), ::llvm::StringRef("will_return"), ::llvm::StringRef("work_group_size_hint"), ::llvm::StringRef("zero_call_used_regs")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getCConvAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getCConvAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getAllocsizeAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getAllocsizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getAlwaysInlineAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getAlwaysInlineAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getArgAttrsAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getArgAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getArmInZaAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getArmInZaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getArmInoutZaAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getArmInoutZaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getArmLocallyStreamingAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getArmLocallyStreamingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getArmNewZaAttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getArmNewZaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } ::mlir::StringAttr getArmOutZaAttrName() { return getAttributeNameForIndex(9); } static ::mlir::StringAttr getArmOutZaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 9); } ::mlir::StringAttr getArmPreservesZaAttrName() { return getAttributeNameForIndex(10); } static ::mlir::StringAttr getArmPreservesZaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 10); } ::mlir::StringAttr getArmStreamingAttrName() { return getAttributeNameForIndex(11); } static ::mlir::StringAttr getArmStreamingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 11); } ::mlir::StringAttr getArmStreamingCompatibleAttrName() { return getAttributeNameForIndex(12); } static ::mlir::StringAttr getArmStreamingCompatibleAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 12); } ::mlir::StringAttr getColdAttrName() { return getAttributeNameForIndex(13); } static ::mlir::StringAttr getColdAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 13); } ::mlir::StringAttr getComdatAttrName() { return getAttributeNameForIndex(14); } static ::mlir::StringAttr getComdatAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 14); } ::mlir::StringAttr getConvergentAttrName() { return getAttributeNameForIndex(15); } static ::mlir::StringAttr getConvergentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 15); } ::mlir::StringAttr getDefaultFuncAttrsAttrName() { return getAttributeNameForIndex(16); } static ::mlir::StringAttr getDefaultFuncAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 16); } ::mlir::StringAttr getDenormalFpenvAttrName() { return getAttributeNameForIndex(17); } static ::mlir::StringAttr getDenormalFpenvAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 17); } ::mlir::StringAttr getDsoLocalAttrName() { return getAttributeNameForIndex(18); } static ::mlir::StringAttr getDsoLocalAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 18); } ::mlir::StringAttr getFpContractAttrName() { return getAttributeNameForIndex(19); } static ::mlir::StringAttr getFpContractAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 19); } ::mlir::StringAttr getFramePointerAttrName() { return getAttributeNameForIndex(20); } static ::mlir::StringAttr getFramePointerAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 20); } ::mlir::StringAttr getFunctionEntryCountAttrName() { return getAttributeNameForIndex(21); } static ::mlir::StringAttr getFunctionEntryCountAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 21); } ::mlir::StringAttr getFunctionTypeAttrName() { return getAttributeNameForIndex(22); } static ::mlir::StringAttr getFunctionTypeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 22); } ::mlir::StringAttr getGarbageCollectorAttrName() { return getAttributeNameForIndex(23); } static ::mlir::StringAttr getGarbageCollectorAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 23); } ::mlir::StringAttr getHotAttrName() { return getAttributeNameForIndex(24); } static ::mlir::StringAttr getHotAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 24); } ::mlir::StringAttr getInlineHintAttrName() { return getAttributeNameForIndex(25); } static ::mlir::StringAttr getInlineHintAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 25); } ::mlir::StringAttr getInstrumentFunctionEntryAttrName() { return getAttributeNameForIndex(26); } static ::mlir::StringAttr getInstrumentFunctionEntryAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 26); } ::mlir::StringAttr getInstrumentFunctionExitAttrName() { return getAttributeNameForIndex(27); } static ::mlir::StringAttr getInstrumentFunctionExitAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 27); } ::mlir::StringAttr getIntelReqdSubGroupSizeAttrName() { return getAttributeNameForIndex(28); } static ::mlir::StringAttr getIntelReqdSubGroupSizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 28); } ::mlir::StringAttr getLinkageAttrName() { return getAttributeNameForIndex(29); } static ::mlir::StringAttr getLinkageAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 29); } ::mlir::StringAttr getMemoryEffectsAttrName() { return getAttributeNameForIndex(30); } static ::mlir::StringAttr getMemoryEffectsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 30); } ::mlir::StringAttr getMinsizeAttrName() { return getAttributeNameForIndex(31); } static ::mlir::StringAttr getMinsizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 31); } ::mlir::StringAttr getModularFormatAttrName() { return getAttributeNameForIndex(32); } static ::mlir::StringAttr getModularFormatAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 32); } ::mlir::StringAttr getNoCallerSavedRegistersAttrName() { return getAttributeNameForIndex(33); } static ::mlir::StringAttr getNoCallerSavedRegistersAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 33); } ::mlir::StringAttr getNoInlineAttrName() { return getAttributeNameForIndex(34); } static ::mlir::StringAttr getNoInlineAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 34); } ::mlir::StringAttr getNoSignedZerosFpMathAttrName() { return getAttributeNameForIndex(35); } static ::mlir::StringAttr getNoSignedZerosFpMathAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 35); } ::mlir::StringAttr getNoUnwindAttrName() { return getAttributeNameForIndex(36); } static ::mlir::StringAttr getNoUnwindAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 36); } ::mlir::StringAttr getNobuiltinsAttrName() { return getAttributeNameForIndex(37); } static ::mlir::StringAttr getNobuiltinsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 37); } ::mlir::StringAttr getNocallbackAttrName() { return getAttributeNameForIndex(38); } static ::mlir::StringAttr getNocallbackAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 38); } ::mlir::StringAttr getNoduplicateAttrName() { return getAttributeNameForIndex(39); } static ::mlir::StringAttr getNoduplicateAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 39); } ::mlir::StringAttr getNoreturnAttrName() { return getAttributeNameForIndex(40); } static ::mlir::StringAttr getNoreturnAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 40); } ::mlir::StringAttr getOptimizeNoneAttrName() { return getAttributeNameForIndex(41); } static ::mlir::StringAttr getOptimizeNoneAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 41); } ::mlir::StringAttr getOptsizeAttrName() { return getAttributeNameForIndex(42); } static ::mlir::StringAttr getOptsizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 42); } ::mlir::StringAttr getPassthroughAttrName() { return getAttributeNameForIndex(43); } static ::mlir::StringAttr getPassthroughAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 43); } ::mlir::StringAttr getPersonalityAttrName() { return getAttributeNameForIndex(44); } static ::mlir::StringAttr getPersonalityAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 44); } ::mlir::StringAttr getPreferVectorWidthAttrName() { return getAttributeNameForIndex(45); } static ::mlir::StringAttr getPreferVectorWidthAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 45); } ::mlir::StringAttr getReciprocalEstimatesAttrName() { return getAttributeNameForIndex(46); } static ::mlir::StringAttr getReciprocalEstimatesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 46); } ::mlir::StringAttr getReqdWorkGroupSizeAttrName() { return getAttributeNameForIndex(47); } static ::mlir::StringAttr getReqdWorkGroupSizeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 47); } ::mlir::StringAttr getResAttrsAttrName() { return getAttributeNameForIndex(48); } static ::mlir::StringAttr getResAttrsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 48); } ::mlir::StringAttr getReturnsTwiceAttrName() { return getAttributeNameForIndex(49); } static ::mlir::StringAttr getReturnsTwiceAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 49); } ::mlir::StringAttr getSaveRegParamsAttrName() { return getAttributeNameForIndex(50); } static ::mlir::StringAttr getSaveRegParamsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 50); } ::mlir::StringAttr getSectionAttrName() { return getAttributeNameForIndex(51); } static ::mlir::StringAttr getSectionAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 51); } ::mlir::StringAttr getSymNameAttrName() { return getAttributeNameForIndex(52); } static ::mlir::StringAttr getSymNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 52); } ::mlir::StringAttr getSymVisibilityAttrName() { return getAttributeNameForIndex(53); } static ::mlir::StringAttr getSymVisibilityAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 53); } ::mlir::StringAttr getTargetCpuAttrName() { return getAttributeNameForIndex(54); } static ::mlir::StringAttr getTargetCpuAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 54); } ::mlir::StringAttr getTargetFeaturesAttrName() { return getAttributeNameForIndex(55); } static ::mlir::StringAttr getTargetFeaturesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 55); } ::mlir::StringAttr getTuneCpuAttrName() { return getAttributeNameForIndex(56); } static ::mlir::StringAttr getTuneCpuAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 56); } ::mlir::StringAttr getUnnamedAddrAttrName() { return getAttributeNameForIndex(57); } static ::mlir::StringAttr getUnnamedAddrAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 57); } ::mlir::StringAttr getUseSampleProfileAttrName() { return getAttributeNameForIndex(58); } static ::mlir::StringAttr getUseSampleProfileAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 58); } ::mlir::StringAttr getUwtableKindAttrName() { return getAttributeNameForIndex(59); } static ::mlir::StringAttr getUwtableKindAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 59); } ::mlir::StringAttr getVecTypeHintAttrName() { return getAttributeNameForIndex(60); } static ::mlir::StringAttr getVecTypeHintAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 60); } ::mlir::StringAttr getVisibility_AttrName() { return getAttributeNameForIndex(61); } static ::mlir::StringAttr getVisibility_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 61); } ::mlir::StringAttr getVscaleRangeAttrName() { return getAttributeNameForIndex(62); } static ::mlir::StringAttr getVscaleRangeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 62); } ::mlir::StringAttr getWillReturnAttrName() { return getAttributeNameForIndex(63); } static ::mlir::StringAttr getWillReturnAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 63); } ::mlir::StringAttr getWorkGroupSizeHintAttrName() { return getAttributeNameForIndex(64); } static ::mlir::StringAttr getWorkGroupSizeHintAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 64); } ::mlir::StringAttr getZeroCallUsedRegsAttrName() { return getAttributeNameForIndex(65); } static ::mlir::StringAttr getZeroCallUsedRegsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 65); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.func"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Region &getBody() { return (*this)->getRegion(0); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getSymNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().sym_name); } ::llvm::StringRef getSymName(); ::mlir::StringAttr getSymVisibilityAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().sym_visibility); } ::std::optional< ::llvm::StringRef > getSymVisibility(); ::mlir::TypeAttr getFunctionTypeAttr() { return ::llvm::cast<::mlir::TypeAttr>(getProperties().function_type); } ::mlir::LLVM::LLVMFunctionType getFunctionType(); ::mlir::LLVM::LinkageAttr getLinkageAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::LinkageAttr>(getProperties().linkage); } ::mlir::LLVM::Linkage getLinkage(); ::mlir::UnitAttr getDsoLocalAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().dso_local); } bool getDsoLocal(); ::mlir::LLVM::CConvAttr getCConvAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::CConvAttr>(getProperties().CConv); } ::mlir::LLVM::cconv::CConv getCConv(); ::mlir::SymbolRefAttr getComdatAttr() { return ::llvm::dyn_cast_or_null<::mlir::SymbolRefAttr>(getProperties().comdat); } ::std::optional< ::mlir::SymbolRefAttr > getComdat(); ::mlir::UnitAttr getConvergentAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().convergent); } bool getConvergent(); ::mlir::FlatSymbolRefAttr getPersonalityAttr() { return ::llvm::dyn_cast_or_null<::mlir::FlatSymbolRefAttr>(getProperties().personality); } ::std::optional< ::llvm::StringRef > getPersonality(); ::mlir::StringAttr getGarbageCollectorAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().garbageCollector); } ::std::optional< ::llvm::StringRef > getGarbageCollector(); ::mlir::ArrayAttr getPassthroughAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().passthrough); } ::std::optional< ::mlir::ArrayAttr > getPassthrough(); ::mlir::ArrayAttr getArgAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().arg_attrs); } ::std::optional< ::mlir::ArrayAttr > getArgAttrs(); ::mlir::ArrayAttr getResAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().res_attrs); } ::std::optional< ::mlir::ArrayAttr > getResAttrs(); ::mlir::IntegerAttr getFunctionEntryCountAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().function_entry_count); } ::std::optional getFunctionEntryCount(); ::mlir::LLVM::MemoryEffectsAttr getMemoryEffectsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::MemoryEffectsAttr>(getProperties().memory_effects); } ::std::optional<::mlir::LLVM::MemoryEffectsAttr> getMemoryEffects(); ::mlir::LLVM::VisibilityAttr getVisibility_Attr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::VisibilityAttr>(getProperties().visibility_); } ::mlir::LLVM::Visibility getVisibility_(); ::mlir::UnitAttr getArmStreamingAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_streaming); } bool getArmStreaming(); ::mlir::UnitAttr getArmLocallyStreamingAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_locally_streaming); } bool getArmLocallyStreaming(); ::mlir::UnitAttr getArmStreamingCompatibleAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_streaming_compatible); } bool getArmStreamingCompatible(); ::mlir::UnitAttr getArmNewZaAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_new_za); } bool getArmNewZa(); ::mlir::UnitAttr getArmInZaAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_in_za); } bool getArmInZa(); ::mlir::UnitAttr getArmOutZaAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_out_za); } bool getArmOutZa(); ::mlir::UnitAttr getArmInoutZaAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_inout_za); } bool getArmInoutZa(); ::mlir::UnitAttr getArmPreservesZaAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().arm_preserves_za); } bool getArmPreservesZa(); ::mlir::StringAttr getSectionAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().section); } ::std::optional< ::llvm::StringRef > getSection(); ::mlir::LLVM::UnnamedAddrAttr getUnnamedAddrAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::UnnamedAddrAttr>(getProperties().unnamed_addr); } ::std::optional<::mlir::LLVM::UnnamedAddr> getUnnamedAddr(); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::LLVM::VScaleRangeAttr getVscaleRangeAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::VScaleRangeAttr>(getProperties().vscale_range); } ::std::optional<::mlir::LLVM::VScaleRangeAttr> getVscaleRange(); ::mlir::LLVM::FramePointerKindAttr getFramePointerAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FramePointerKindAttr>(getProperties().frame_pointer); } ::std::optional<::mlir::LLVM::FramePointerKindAttr> getFramePointer(); ::mlir::StringAttr getTargetCpuAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().target_cpu); } ::std::optional< ::llvm::StringRef > getTargetCpu(); ::mlir::StringAttr getTuneCpuAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().tune_cpu); } ::std::optional< ::llvm::StringRef > getTuneCpu(); ::mlir::StringAttr getReciprocalEstimatesAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().reciprocal_estimates); } ::std::optional< ::llvm::StringRef > getReciprocalEstimates(); ::mlir::StringAttr getPreferVectorWidthAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().prefer_vector_width); } ::std::optional< ::llvm::StringRef > getPreferVectorWidth(); ::mlir::LLVM::TargetFeaturesAttr getTargetFeaturesAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::TargetFeaturesAttr>(getProperties().target_features); } ::std::optional<::mlir::LLVM::TargetFeaturesAttr> getTargetFeatures(); ::mlir::BoolAttr getNoSignedZerosFpMathAttr() { return ::llvm::dyn_cast_or_null<::mlir::BoolAttr>(getProperties().no_signed_zeros_fp_math); } ::std::optional< bool > getNoSignedZerosFpMath(); ::mlir::LLVM::DenormalFPEnvAttr getDenormalFpenvAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::DenormalFPEnvAttr>(getProperties().denormal_fpenv); } ::std::optional<::mlir::LLVM::DenormalFPEnvAttr> getDenormalFpenv(); ::mlir::StringAttr getFpContractAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().fp_contract); } ::std::optional< ::llvm::StringRef > getFpContract(); ::mlir::StringAttr getInstrumentFunctionEntryAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().instrument_function_entry); } ::std::optional< ::llvm::StringRef > getInstrumentFunctionEntry(); ::mlir::StringAttr getInstrumentFunctionExitAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().instrument_function_exit); } ::std::optional< ::llvm::StringRef > getInstrumentFunctionExit(); ::mlir::UnitAttr getNoInlineAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().no_inline); } bool getNoInline(); ::mlir::UnitAttr getAlwaysInlineAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().always_inline); } bool getAlwaysInline(); ::mlir::UnitAttr getInlineHintAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().inline_hint); } bool getInlineHint(); ::mlir::UnitAttr getNoUnwindAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().no_unwind); } bool getNoUnwind(); ::mlir::UnitAttr getWillReturnAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().will_return); } bool getWillReturn(); ::mlir::UnitAttr getNoreturnAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().noreturn); } bool getNoreturn(); ::mlir::UnitAttr getOptimizeNoneAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().optimize_none); } bool getOptimizeNone(); ::mlir::UnitAttr getReturnsTwiceAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().returns_twice); } bool getReturnsTwice(); ::mlir::UnitAttr getHotAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().hot); } bool getHot(); ::mlir::UnitAttr getColdAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().cold); } bool getCold(); ::mlir::UnitAttr getNoduplicateAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().noduplicate); } bool getNoduplicate(); ::mlir::UnitAttr getNoCallerSavedRegistersAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().no_caller_saved_registers); } bool getNoCallerSavedRegisters(); ::mlir::UnitAttr getNocallbackAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nocallback); } bool getNocallback(); ::mlir::StringAttr getModularFormatAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().modular_format); } ::std::optional< ::llvm::StringRef > getModularFormat(); ::mlir::ArrayAttr getNobuiltinsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().nobuiltins); } ::std::optional< ::mlir::ArrayAttr > getNobuiltins(); ::mlir::DenseI32ArrayAttr getAllocsizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().allocsize); } ::std::optional<::llvm::ArrayRef> getAllocsize(); ::mlir::UnitAttr getOptsizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().optsize); } ::std::optional getOptsize(); ::mlir::UnitAttr getMinsizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().minsize); } ::std::optional getMinsize(); ::mlir::UnitAttr getSaveRegParamsAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().save_reg_params); } ::std::optional getSaveRegParams(); ::mlir::StringAttr getZeroCallUsedRegsAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().zero_call_used_regs); } ::std::optional< ::llvm::StringRef > getZeroCallUsedRegs(); ::mlir::DictionaryAttr getDefaultFuncAttrsAttr() { return ::llvm::dyn_cast_or_null<::mlir::DictionaryAttr>(getProperties().default_func_attrs); } ::std::optional< ::mlir::DictionaryAttr > getDefaultFuncAttrs(); ::mlir::LLVM::VecTypeHintAttr getVecTypeHintAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::VecTypeHintAttr>(getProperties().vec_type_hint); } ::std::optional<::mlir::LLVM::VecTypeHintAttr> getVecTypeHint(); ::mlir::DenseI32ArrayAttr getWorkGroupSizeHintAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().work_group_size_hint); } ::std::optional<::llvm::ArrayRef> getWorkGroupSizeHint(); ::mlir::DenseI32ArrayAttr getReqdWorkGroupSizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().reqd_work_group_size); } ::std::optional<::llvm::ArrayRef> getReqdWorkGroupSize(); ::mlir::IntegerAttr getIntelReqdSubGroupSizeAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().intel_reqd_sub_group_size); } ::std::optional getIntelReqdSubGroupSize(); ::mlir::LLVM::UWTableKindAttr getUwtableKindAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::UWTableKindAttr>(getProperties().uwtable_kind); } ::std::optional<::mlir::LLVM::UWTableKindAttr> getUwtableKind(); ::mlir::BoolAttr getUseSampleProfileAttr() { return ::llvm::dyn_cast_or_null<::mlir::BoolAttr>(getProperties().use_sample_profile); } ::std::optional< bool > getUseSampleProfile(); void setSymNameAttr(::mlir::StringAttr attr) { getProperties().sym_name = attr; } void setSymName(::llvm::StringRef attrValue); void setSymVisibilityAttr(::mlir::StringAttr attr) { getProperties().sym_visibility = attr; } void setSymVisibility(::std::optional<::llvm::StringRef> attrValue); void setFunctionTypeAttr(::mlir::TypeAttr attr) { getProperties().function_type = attr; } void setFunctionType(::mlir::LLVM::LLVMFunctionType attrValue); void setLinkageAttr(::mlir::LLVM::LinkageAttr attr) { getProperties().linkage = attr; } void setLinkage(::mlir::LLVM::Linkage attrValue); void setDsoLocalAttr(::mlir::UnitAttr attr) { getProperties().dso_local = attr; } void setDsoLocal(bool attrValue); void setCConvAttr(::mlir::LLVM::CConvAttr attr) { getProperties().CConv = attr; } void setCConv(::mlir::LLVM::cconv::CConv attrValue); void setComdatAttr(::mlir::SymbolRefAttr attr) { getProperties().comdat = attr; } void setConvergentAttr(::mlir::UnitAttr attr) { getProperties().convergent = attr; } void setConvergent(bool attrValue); void setPersonalityAttr(::mlir::FlatSymbolRefAttr attr) { getProperties().personality = attr; } void setPersonality(::std::optional<::llvm::StringRef> attrValue); void setGarbageCollectorAttr(::mlir::StringAttr attr) { getProperties().garbageCollector = attr; } void setGarbageCollector(::std::optional<::llvm::StringRef> attrValue); void setPassthroughAttr(::mlir::ArrayAttr attr) { getProperties().passthrough = attr; } void setArgAttrsAttr(::mlir::ArrayAttr attr) { getProperties().arg_attrs = attr; } void setResAttrsAttr(::mlir::ArrayAttr attr) { getProperties().res_attrs = attr; } void setFunctionEntryCountAttr(::mlir::IntegerAttr attr) { getProperties().function_entry_count = attr; } void setFunctionEntryCount(::std::optional attrValue); void setMemoryEffectsAttr(::mlir::LLVM::MemoryEffectsAttr attr) { getProperties().memory_effects = attr; } void setVisibility_Attr(::mlir::LLVM::VisibilityAttr attr) { getProperties().visibility_ = attr; } void setVisibility_(::mlir::LLVM::Visibility attrValue); void setArmStreamingAttr(::mlir::UnitAttr attr) { getProperties().arm_streaming = attr; } void setArmStreaming(bool attrValue); void setArmLocallyStreamingAttr(::mlir::UnitAttr attr) { getProperties().arm_locally_streaming = attr; } void setArmLocallyStreaming(bool attrValue); void setArmStreamingCompatibleAttr(::mlir::UnitAttr attr) { getProperties().arm_streaming_compatible = attr; } void setArmStreamingCompatible(bool attrValue); void setArmNewZaAttr(::mlir::UnitAttr attr) { getProperties().arm_new_za = attr; } void setArmNewZa(bool attrValue); void setArmInZaAttr(::mlir::UnitAttr attr) { getProperties().arm_in_za = attr; } void setArmInZa(bool attrValue); void setArmOutZaAttr(::mlir::UnitAttr attr) { getProperties().arm_out_za = attr; } void setArmOutZa(bool attrValue); void setArmInoutZaAttr(::mlir::UnitAttr attr) { getProperties().arm_inout_za = attr; } void setArmInoutZa(bool attrValue); void setArmPreservesZaAttr(::mlir::UnitAttr attr) { getProperties().arm_preserves_za = attr; } void setArmPreservesZa(bool attrValue); void setSectionAttr(::mlir::StringAttr attr) { getProperties().section = attr; } void setSection(::std::optional<::llvm::StringRef> attrValue); void setUnnamedAddrAttr(::mlir::LLVM::UnnamedAddrAttr attr) { getProperties().unnamed_addr = attr; } void setUnnamedAddr(::std::optional<::mlir::LLVM::UnnamedAddr> attrValue); void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setVscaleRangeAttr(::mlir::LLVM::VScaleRangeAttr attr) { getProperties().vscale_range = attr; } void setFramePointerAttr(::mlir::LLVM::FramePointerKindAttr attr) { getProperties().frame_pointer = attr; } void setTargetCpuAttr(::mlir::StringAttr attr) { getProperties().target_cpu = attr; } void setTargetCpu(::std::optional<::llvm::StringRef> attrValue); void setTuneCpuAttr(::mlir::StringAttr attr) { getProperties().tune_cpu = attr; } void setTuneCpu(::std::optional<::llvm::StringRef> attrValue); void setReciprocalEstimatesAttr(::mlir::StringAttr attr) { getProperties().reciprocal_estimates = attr; } void setReciprocalEstimates(::std::optional<::llvm::StringRef> attrValue); void setPreferVectorWidthAttr(::mlir::StringAttr attr) { getProperties().prefer_vector_width = attr; } void setPreferVectorWidth(::std::optional<::llvm::StringRef> attrValue); void setTargetFeaturesAttr(::mlir::LLVM::TargetFeaturesAttr attr) { getProperties().target_features = attr; } void setNoSignedZerosFpMathAttr(::mlir::BoolAttr attr) { getProperties().no_signed_zeros_fp_math = attr; } void setNoSignedZerosFpMath(::std::optional attrValue); void setDenormalFpenvAttr(::mlir::LLVM::DenormalFPEnvAttr attr) { getProperties().denormal_fpenv = attr; } void setFpContractAttr(::mlir::StringAttr attr) { getProperties().fp_contract = attr; } void setFpContract(::std::optional<::llvm::StringRef> attrValue); void setInstrumentFunctionEntryAttr(::mlir::StringAttr attr) { getProperties().instrument_function_entry = attr; } void setInstrumentFunctionEntry(::std::optional<::llvm::StringRef> attrValue); void setInstrumentFunctionExitAttr(::mlir::StringAttr attr) { getProperties().instrument_function_exit = attr; } void setInstrumentFunctionExit(::std::optional<::llvm::StringRef> attrValue); void setNoInlineAttr(::mlir::UnitAttr attr) { getProperties().no_inline = attr; } void setNoInline(bool attrValue); void setAlwaysInlineAttr(::mlir::UnitAttr attr) { getProperties().always_inline = attr; } void setAlwaysInline(bool attrValue); void setInlineHintAttr(::mlir::UnitAttr attr) { getProperties().inline_hint = attr; } void setInlineHint(bool attrValue); void setNoUnwindAttr(::mlir::UnitAttr attr) { getProperties().no_unwind = attr; } void setNoUnwind(bool attrValue); void setWillReturnAttr(::mlir::UnitAttr attr) { getProperties().will_return = attr; } void setWillReturn(bool attrValue); void setNoreturnAttr(::mlir::UnitAttr attr) { getProperties().noreturn = attr; } void setNoreturn(bool attrValue); void setOptimizeNoneAttr(::mlir::UnitAttr attr) { getProperties().optimize_none = attr; } void setOptimizeNone(bool attrValue); void setReturnsTwiceAttr(::mlir::UnitAttr attr) { getProperties().returns_twice = attr; } void setReturnsTwice(bool attrValue); void setHotAttr(::mlir::UnitAttr attr) { getProperties().hot = attr; } void setHot(bool attrValue); void setColdAttr(::mlir::UnitAttr attr) { getProperties().cold = attr; } void setCold(bool attrValue); void setNoduplicateAttr(::mlir::UnitAttr attr) { getProperties().noduplicate = attr; } void setNoduplicate(bool attrValue); void setNoCallerSavedRegistersAttr(::mlir::UnitAttr attr) { getProperties().no_caller_saved_registers = attr; } void setNoCallerSavedRegisters(bool attrValue); void setNocallbackAttr(::mlir::UnitAttr attr) { getProperties().nocallback = attr; } void setNocallback(bool attrValue); void setModularFormatAttr(::mlir::StringAttr attr) { getProperties().modular_format = attr; } void setModularFormat(::std::optional<::llvm::StringRef> attrValue); void setNobuiltinsAttr(::mlir::ArrayAttr attr) { getProperties().nobuiltins = attr; } void setAllocsizeAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().allocsize = attr; } void setAllocsize(::std::optional<::llvm::ArrayRef> attrValue); void setOptsizeAttr(::mlir::UnitAttr attr) { getProperties().optsize = attr; } void setOptsize(bool attrValue); void setMinsizeAttr(::mlir::UnitAttr attr) { getProperties().minsize = attr; } void setMinsize(bool attrValue); void setSaveRegParamsAttr(::mlir::UnitAttr attr) { getProperties().save_reg_params = attr; } void setSaveRegParams(bool attrValue); void setZeroCallUsedRegsAttr(::mlir::StringAttr attr) { getProperties().zero_call_used_regs = attr; } void setZeroCallUsedRegs(::std::optional<::llvm::StringRef> attrValue); void setDefaultFuncAttrsAttr(::mlir::DictionaryAttr attr) { getProperties().default_func_attrs = attr; } void setVecTypeHintAttr(::mlir::LLVM::VecTypeHintAttr attr) { getProperties().vec_type_hint = attr; } void setWorkGroupSizeHintAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().work_group_size_hint = attr; } void setWorkGroupSizeHint(::std::optional<::llvm::ArrayRef> attrValue); void setReqdWorkGroupSizeAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().reqd_work_group_size = attr; } void setReqdWorkGroupSize(::std::optional<::llvm::ArrayRef> attrValue); void setIntelReqdSubGroupSizeAttr(::mlir::IntegerAttr attr) { getProperties().intel_reqd_sub_group_size = attr; } void setIntelReqdSubGroupSize(::std::optional attrValue); void setUwtableKindAttr(::mlir::LLVM::UWTableKindAttr attr) { getProperties().uwtable_kind = attr; } void setUseSampleProfileAttr(::mlir::BoolAttr attr) { getProperties().use_sample_profile = attr; } void setUseSampleProfile(::std::optional attrValue); ::mlir::Attribute removeSymVisibilityAttr() { auto attr = getProperties().sym_visibility; getProperties().sym_visibility = {}; return attr; } ::mlir::Attribute removeDsoLocalAttr() { auto attr = getProperties().dso_local; getProperties().dso_local = {}; return attr; } ::mlir::Attribute removeComdatAttr() { auto attr = getProperties().comdat; getProperties().comdat = {}; return attr; } ::mlir::Attribute removeConvergentAttr() { auto attr = getProperties().convergent; getProperties().convergent = {}; return attr; } ::mlir::Attribute removePersonalityAttr() { auto attr = getProperties().personality; getProperties().personality = {}; return attr; } ::mlir::Attribute removeGarbageCollectorAttr() { auto attr = getProperties().garbageCollector; getProperties().garbageCollector = {}; return attr; } ::mlir::Attribute removePassthroughAttr() { auto attr = getProperties().passthrough; getProperties().passthrough = {}; return attr; } ::mlir::Attribute removeArgAttrsAttr() { auto attr = getProperties().arg_attrs; getProperties().arg_attrs = {}; return attr; } ::mlir::Attribute removeResAttrsAttr() { auto attr = getProperties().res_attrs; getProperties().res_attrs = {}; return attr; } ::mlir::Attribute removeFunctionEntryCountAttr() { auto attr = getProperties().function_entry_count; getProperties().function_entry_count = {}; return attr; } ::mlir::Attribute removeMemoryEffectsAttr() { auto attr = getProperties().memory_effects; getProperties().memory_effects = {}; return attr; } ::mlir::Attribute removeArmStreamingAttr() { auto attr = getProperties().arm_streaming; getProperties().arm_streaming = {}; return attr; } ::mlir::Attribute removeArmLocallyStreamingAttr() { auto attr = getProperties().arm_locally_streaming; getProperties().arm_locally_streaming = {}; return attr; } ::mlir::Attribute removeArmStreamingCompatibleAttr() { auto attr = getProperties().arm_streaming_compatible; getProperties().arm_streaming_compatible = {}; return attr; } ::mlir::Attribute removeArmNewZaAttr() { auto attr = getProperties().arm_new_za; getProperties().arm_new_za = {}; return attr; } ::mlir::Attribute removeArmInZaAttr() { auto attr = getProperties().arm_in_za; getProperties().arm_in_za = {}; return attr; } ::mlir::Attribute removeArmOutZaAttr() { auto attr = getProperties().arm_out_za; getProperties().arm_out_za = {}; return attr; } ::mlir::Attribute removeArmInoutZaAttr() { auto attr = getProperties().arm_inout_za; getProperties().arm_inout_za = {}; return attr; } ::mlir::Attribute removeArmPreservesZaAttr() { auto attr = getProperties().arm_preserves_za; getProperties().arm_preserves_za = {}; return attr; } ::mlir::Attribute removeSectionAttr() { auto attr = getProperties().section; getProperties().section = {}; return attr; } ::mlir::Attribute removeUnnamedAddrAttr() { auto attr = getProperties().unnamed_addr; getProperties().unnamed_addr = {}; return attr; } ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeVscaleRangeAttr() { auto attr = getProperties().vscale_range; getProperties().vscale_range = {}; return attr; } ::mlir::Attribute removeFramePointerAttr() { auto attr = getProperties().frame_pointer; getProperties().frame_pointer = {}; return attr; } ::mlir::Attribute removeTargetCpuAttr() { auto attr = getProperties().target_cpu; getProperties().target_cpu = {}; return attr; } ::mlir::Attribute removeTuneCpuAttr() { auto attr = getProperties().tune_cpu; getProperties().tune_cpu = {}; return attr; } ::mlir::Attribute removeReciprocalEstimatesAttr() { auto attr = getProperties().reciprocal_estimates; getProperties().reciprocal_estimates = {}; return attr; } ::mlir::Attribute removePreferVectorWidthAttr() { auto attr = getProperties().prefer_vector_width; getProperties().prefer_vector_width = {}; return attr; } ::mlir::Attribute removeTargetFeaturesAttr() { auto attr = getProperties().target_features; getProperties().target_features = {}; return attr; } ::mlir::Attribute removeNoSignedZerosFpMathAttr() { auto attr = getProperties().no_signed_zeros_fp_math; getProperties().no_signed_zeros_fp_math = {}; return attr; } ::mlir::Attribute removeDenormalFpenvAttr() { auto attr = getProperties().denormal_fpenv; getProperties().denormal_fpenv = {}; return attr; } ::mlir::Attribute removeFpContractAttr() { auto attr = getProperties().fp_contract; getProperties().fp_contract = {}; return attr; } ::mlir::Attribute removeInstrumentFunctionEntryAttr() { auto attr = getProperties().instrument_function_entry; getProperties().instrument_function_entry = {}; return attr; } ::mlir::Attribute removeInstrumentFunctionExitAttr() { auto attr = getProperties().instrument_function_exit; getProperties().instrument_function_exit = {}; return attr; } ::mlir::Attribute removeNoInlineAttr() { auto attr = getProperties().no_inline; getProperties().no_inline = {}; return attr; } ::mlir::Attribute removeAlwaysInlineAttr() { auto attr = getProperties().always_inline; getProperties().always_inline = {}; return attr; } ::mlir::Attribute removeInlineHintAttr() { auto attr = getProperties().inline_hint; getProperties().inline_hint = {}; return attr; } ::mlir::Attribute removeNoUnwindAttr() { auto attr = getProperties().no_unwind; getProperties().no_unwind = {}; return attr; } ::mlir::Attribute removeWillReturnAttr() { auto attr = getProperties().will_return; getProperties().will_return = {}; return attr; } ::mlir::Attribute removeNoreturnAttr() { auto attr = getProperties().noreturn; getProperties().noreturn = {}; return attr; } ::mlir::Attribute removeOptimizeNoneAttr() { auto attr = getProperties().optimize_none; getProperties().optimize_none = {}; return attr; } ::mlir::Attribute removeReturnsTwiceAttr() { auto attr = getProperties().returns_twice; getProperties().returns_twice = {}; return attr; } ::mlir::Attribute removeHotAttr() { auto attr = getProperties().hot; getProperties().hot = {}; return attr; } ::mlir::Attribute removeColdAttr() { auto attr = getProperties().cold; getProperties().cold = {}; return attr; } ::mlir::Attribute removeNoduplicateAttr() { auto attr = getProperties().noduplicate; getProperties().noduplicate = {}; return attr; } ::mlir::Attribute removeNoCallerSavedRegistersAttr() { auto attr = getProperties().no_caller_saved_registers; getProperties().no_caller_saved_registers = {}; return attr; } ::mlir::Attribute removeNocallbackAttr() { auto attr = getProperties().nocallback; getProperties().nocallback = {}; return attr; } ::mlir::Attribute removeModularFormatAttr() { auto attr = getProperties().modular_format; getProperties().modular_format = {}; return attr; } ::mlir::Attribute removeNobuiltinsAttr() { auto attr = getProperties().nobuiltins; getProperties().nobuiltins = {}; return attr; } ::mlir::Attribute removeAllocsizeAttr() { auto attr = getProperties().allocsize; getProperties().allocsize = {}; return attr; } ::mlir::Attribute removeOptsizeAttr() { auto attr = getProperties().optsize; getProperties().optsize = {}; return attr; } ::mlir::Attribute removeMinsizeAttr() { auto attr = getProperties().minsize; getProperties().minsize = {}; return attr; } ::mlir::Attribute removeSaveRegParamsAttr() { auto attr = getProperties().save_reg_params; getProperties().save_reg_params = {}; return attr; } ::mlir::Attribute removeZeroCallUsedRegsAttr() { auto attr = getProperties().zero_call_used_regs; getProperties().zero_call_used_regs = {}; return attr; } ::mlir::Attribute removeDefaultFuncAttrsAttr() { auto attr = getProperties().default_func_attrs; getProperties().default_func_attrs = {}; return attr; } ::mlir::Attribute removeVecTypeHintAttr() { auto attr = getProperties().vec_type_hint; getProperties().vec_type_hint = {}; return attr; } ::mlir::Attribute removeWorkGroupSizeHintAttr() { auto attr = getProperties().work_group_size_hint; getProperties().work_group_size_hint = {}; return attr; } ::mlir::Attribute removeReqdWorkGroupSizeAttr() { auto attr = getProperties().reqd_work_group_size; getProperties().reqd_work_group_size = {}; return attr; } ::mlir::Attribute removeIntelReqdSubGroupSizeAttr() { auto attr = getProperties().intel_reqd_sub_group_size; getProperties().intel_reqd_sub_group_size = {}; return attr; } ::mlir::Attribute removeUwtableKindAttr() { auto attr = getProperties().uwtable_kind; getProperties().uwtable_kind = {}; return attr; } ::mlir::Attribute removeUseSampleProfileAttr() { auto attr = getProperties().use_sample_profile; getProperties().use_sample_profile = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, StringRef name, Type type, Linkage linkage = Linkage::External, bool dsoLocal = false, CConv cconv = CConv::C, SymbolRefAttr comdat = {}, ArrayRef attrs = {}, ArrayRef argAttrs = {}, std::optional functionEntryCount = {}); static LLVMFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, StringRef name, Type type, Linkage linkage = Linkage::External, bool dsoLocal = false, CConv cconv = CConv::C, SymbolRefAttr comdat = {}, ArrayRef attrs = {}, ArrayRef argAttrs = {}, std::optional functionEntryCount = {}); static LLVMFuncOp create(::mlir::ImplicitLocOpBuilder &builder, StringRef name, Type type, Linkage linkage = Linkage::External, bool dsoLocal = false, CConv cconv = CConv::C, SymbolRefAttr comdat = {}, ArrayRef attrs = {}, ArrayRef argAttrs = {}, std::optional functionEntryCount = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, const Properties &properties, ArrayRef discardableAttributes = {}); static LLVMFuncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, const Properties &properties, ArrayRef discardableAttributes = {}); static LLVMFuncOp create(::mlir::ImplicitLocOpBuilder &builder, const Properties &properties, ArrayRef discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::LogicalResult verifyRegions(); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 66 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: // Add an entry block to an empty function, and set up the block arguments // to match the signature of the function. Block *addEntryBlock(OpBuilder &builder); bool isVarArg() { return getFunctionType().isVarArg(); } /// Returns the argument types of this function. ArrayRef getArgumentTypes() { return getFunctionType().getParams(); } /// Returns the result types of this function. ArrayRef getResultTypes() { if (::llvm::isa(getFunctionType().getReturnType())) return {}; return getFunctionType().getReturnTypes(); } /// Returns the callable region, which is the function body. If the function /// is external, returns null. Region *getCallableRegion(); /// Returns true if the `no_inline` attribute is set, false otherwise. bool isNoInline() { return bool(getNoInlineAttr()); } /// Returns true if the `always_inline` attribute is set, false otherwise. bool isAlwaysInline() { return bool(getAlwaysInlineAttr()); } /// Returns true if the `inline_hint` attribute is set, false otherwise. bool isInlineHint() { return bool(getInlineHintAttr()); } /// Returns true if the `optimize_none` attribute is set, false otherwise. bool isOptimizeNone() { return bool(getOptimizeNoneAttr()); } }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::LLVMFuncOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::LLVMFuncOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::LShrOp declarations //===----------------------------------------------------------------------===// namespace detail { class LShrOpGenericAdaptorBase { public: struct Properties { using isExactTy = ::mlir::UnitAttr; isExactTy isExact; auto getIsExact() const { auto &propStorage = this->isExact; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setIsExact(const ::mlir::UnitAttr &propValue) { this->isExact = propValue; } bool operator==(const Properties &rhs) const { return rhs.isExact == this->isExact && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: LShrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.lshr", odsAttrs.getContext()); } LShrOpGenericAdaptorBase(LShrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getIsExactAttr(); bool getIsExact(); }; } // namespace detail template class LShrOpGenericAdaptor : public detail::LShrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::LShrOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: LShrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} LShrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : LShrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} LShrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : LShrOpGenericAdaptor(values, attrs, Properties{}, {}) {} LShrOpGenericAdaptor(RangeT values, const LShrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> LShrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class LShrOpAdaptor : public LShrOpGenericAdaptor<::mlir::ValueRange> { public: using LShrOpGenericAdaptor::LShrOpGenericAdaptor; LShrOpAdaptor(LShrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class LShrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::ExactFlagInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = LShrOpAdaptor; template using GenericAdaptor = LShrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::setIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExactName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("isExact")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getIsExactAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getIsExactAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.lshr"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getIsExactAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().isExact); } bool getIsExact(); void setIsExactAttr(::mlir::UnitAttr attr) { getProperties().isExact = attr; } void setIsExact(bool attrValue); ::mlir::Attribute removeIsExactAttr() { auto attr = getProperties().isExact; getProperties().isExact = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LShrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LShrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::LShrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::LShrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::LandingpadOp declarations //===----------------------------------------------------------------------===// namespace detail { class LandingpadOpGenericAdaptorBase { public: struct Properties { using cleanupTy = ::mlir::UnitAttr; cleanupTy cleanup; auto getCleanup() const { auto &propStorage = this->cleanup; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setCleanup(const ::mlir::UnitAttr &propValue) { this->cleanup = propValue; } bool operator==(const Properties &rhs) const { return rhs.cleanup == this->cleanup && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: LandingpadOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.landingpad", odsAttrs.getContext()); } LandingpadOpGenericAdaptorBase(LandingpadOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getCleanupAttr(); bool getCleanup(); }; } // namespace detail template class LandingpadOpGenericAdaptor : public detail::LandingpadOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::LandingpadOpGenericAdaptorBase; public: LandingpadOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} LandingpadOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : LandingpadOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} LandingpadOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : LandingpadOpGenericAdaptor(values, attrs, Properties{}, {}) {} LandingpadOpGenericAdaptor(RangeT values, const LandingpadOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> LandingpadOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class LandingpadOpAdaptor : public LandingpadOpGenericAdaptor<::mlir::ValueRange> { public: using LandingpadOpGenericAdaptor::LandingpadOpGenericAdaptor; LandingpadOpAdaptor(LandingpadOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class LandingpadOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = LandingpadOpAdaptor; template using GenericAdaptor = LandingpadOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("cleanup")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getCleanupAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getCleanupAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.landingpad"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getCleanupAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().cleanup); } bool getCleanup(); void setCleanupAttr(::mlir::UnitAttr attr) { getProperties().cleanup = attr; } void setCleanup(bool attrValue); ::mlir::Attribute removeCleanupAttr() { auto attr = getProperties().cleanup; getProperties().cleanup = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, /*optional*/::mlir::UnitAttr cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, /*optional*/::mlir::UnitAttr cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, /*optional*/::mlir::UnitAttr cleanup, ::mlir::ValueRange odsArg_0); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/::mlir::UnitAttr cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/::mlir::UnitAttr cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/::mlir::UnitAttr cleanup, ::mlir::ValueRange odsArg_0); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, /*optional*/bool cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, /*optional*/bool cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, /*optional*/bool cleanup, ::mlir::ValueRange odsArg_0); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/bool cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/bool cleanup, ::mlir::ValueRange odsArg_0); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/bool cleanup, ::mlir::ValueRange odsArg_0); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LandingpadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LandingpadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &p); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::llvm::LogicalResult setPropertiesFromParsedAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::LandingpadOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::LandingpadOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::LinkerOptionsOp declarations //===----------------------------------------------------------------------===// namespace detail { class LinkerOptionsOpGenericAdaptorBase { public: struct Properties { using optionsTy = ::mlir::ArrayAttr; optionsTy options; auto getOptions() const { auto &propStorage = this->options; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setOptions(const ::mlir::ArrayAttr &propValue) { this->options = propValue; } bool operator==(const Properties &rhs) const { return rhs.options == this->options && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: LinkerOptionsOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.linker_options", odsAttrs.getContext()); } LinkerOptionsOpGenericAdaptorBase(LinkerOptionsOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::ArrayAttr getOptionsAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().options); return attr; } ::mlir::ArrayAttr getOptions(); }; } // namespace detail template class LinkerOptionsOpGenericAdaptor : public detail::LinkerOptionsOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::LinkerOptionsOpGenericAdaptorBase; public: LinkerOptionsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} LinkerOptionsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : LinkerOptionsOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} LinkerOptionsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : LinkerOptionsOpGenericAdaptor(values, attrs, Properties{}, {}) {} LinkerOptionsOpGenericAdaptor(RangeT values, const LinkerOptionsOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> LinkerOptionsOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class LinkerOptionsOpAdaptor : public LinkerOptionsOpGenericAdaptor<::mlir::ValueRange> { public: using LinkerOptionsOpGenericAdaptor::LinkerOptionsOpGenericAdaptor; LinkerOptionsOpAdaptor(LinkerOptionsOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class LinkerOptionsOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = LinkerOptionsOpAdaptor; template using GenericAdaptor = LinkerOptionsOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("options")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getOptionsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getOptionsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.linker_options"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::ArrayAttr getOptionsAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().options); } ::mlir::ArrayAttr getOptions(); void setOptionsAttr(::mlir::ArrayAttr attr) { getProperties().options = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ArrayAttr options); static LinkerOptionsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ArrayAttr options); static LinkerOptionsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ArrayAttr options); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr options); static LinkerOptionsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr options); static LinkerOptionsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr options); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LinkerOptionsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LinkerOptionsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LinkerOptionsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LinkerOptionsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::LinkerOptionsOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::LinkerOptionsOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::LoadOp declarations //===----------------------------------------------------------------------===// namespace detail { class LoadOpGenericAdaptorBase { public: struct Properties { using access_groupsTy = ::mlir::ArrayAttr; access_groupsTy access_groups; auto getAccessGroups() const { auto &propStorage = this->access_groups; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAccessGroups(const ::mlir::ArrayAttr &propValue) { this->access_groups = propValue; } using alias_scopesTy = ::mlir::ArrayAttr; alias_scopesTy alias_scopes; auto getAliasScopes() const { auto &propStorage = this->alias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAliasScopes(const ::mlir::ArrayAttr &propValue) { this->alias_scopes = propValue; } using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using dereferenceableTy = ::mlir::LLVM::DereferenceableAttr; dereferenceableTy dereferenceable; auto getDereferenceable() const { auto &propStorage = this->dereferenceable; return ::llvm::dyn_cast_or_null<::mlir::LLVM::DereferenceableAttr>(propStorage); } void setDereferenceable(const ::mlir::LLVM::DereferenceableAttr &propValue) { this->dereferenceable = propValue; } using invariantTy = ::mlir::UnitAttr; invariantTy invariant; auto getInvariant() const { auto &propStorage = this->invariant; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setInvariant(const ::mlir::UnitAttr &propValue) { this->invariant = propValue; } using invariantGroupTy = ::mlir::UnitAttr; invariantGroupTy invariantGroup; auto getInvariantGroup() const { auto &propStorage = this->invariantGroup; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setInvariantGroup(const ::mlir::UnitAttr &propValue) { this->invariantGroup = propValue; } using noalias_scopesTy = ::mlir::ArrayAttr; noalias_scopesTy noalias_scopes; auto getNoaliasScopes() const { auto &propStorage = this->noalias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNoaliasScopes(const ::mlir::ArrayAttr &propValue) { this->noalias_scopes = propValue; } using nontemporalTy = ::mlir::UnitAttr; nontemporalTy nontemporal; auto getNontemporal() const { auto &propStorage = this->nontemporal; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNontemporal(const ::mlir::UnitAttr &propValue) { this->nontemporal = propValue; } using orderingTy = ::mlir::LLVM::AtomicOrderingAttr; orderingTy ordering; auto getOrdering() const { auto &propStorage = this->ordering; return ::llvm::dyn_cast_or_null<::mlir::LLVM::AtomicOrderingAttr>(propStorage); } void setOrdering(const ::mlir::LLVM::AtomicOrderingAttr &propValue) { this->ordering = propValue; } using syncscopeTy = ::mlir::StringAttr; syncscopeTy syncscope; auto getSyncscope() const { auto &propStorage = this->syncscope; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSyncscope(const ::mlir::StringAttr &propValue) { this->syncscope = propValue; } using tbaaTy = ::mlir::ArrayAttr; tbaaTy tbaa; auto getTbaa() const { auto &propStorage = this->tbaa; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setTbaa(const ::mlir::ArrayAttr &propValue) { this->tbaa = propValue; } using volatile_Ty = ::mlir::UnitAttr; volatile_Ty volatile_; auto getVolatile_() const { auto &propStorage = this->volatile_; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setVolatile_(const ::mlir::UnitAttr &propValue) { this->volatile_ = propValue; } bool operator==(const Properties &rhs) const { return rhs.access_groups == this->access_groups && rhs.alias_scopes == this->alias_scopes && rhs.alignment == this->alignment && rhs.dereferenceable == this->dereferenceable && rhs.invariant == this->invariant && rhs.invariantGroup == this->invariantGroup && rhs.noalias_scopes == this->noalias_scopes && rhs.nontemporal == this->nontemporal && rhs.ordering == this->ordering && rhs.syncscope == this->syncscope && rhs.tbaa == this->tbaa && rhs.volatile_ == this->volatile_ && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: LoadOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.load", odsAttrs.getContext()); } LoadOpGenericAdaptorBase(LoadOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::UnitAttr getVolatile_Attr(); bool getVolatile_(); ::mlir::UnitAttr getNontemporalAttr(); bool getNontemporal(); ::mlir::UnitAttr getInvariantAttr(); bool getInvariant(); ::mlir::UnitAttr getInvariantGroupAttr(); bool getInvariantGroup(); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr(); ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); return attr; } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::LLVM::DereferenceableAttr getDereferenceableAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::LLVM::DereferenceableAttr>(getProperties().dereferenceable); return attr; } ::std::optional<::mlir::LLVM::DereferenceableAttr> getDereferenceable(); ::mlir::ArrayAttr getAccessGroupsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); return attr; } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); return attr; } ::std::optional< ::mlir::ArrayAttr > getTbaa(); }; } // namespace detail template class LoadOpGenericAdaptor : public detail::LoadOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::LoadOpGenericAdaptorBase; static constexpr int odsIndex_addr = 0; public: LoadOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} LoadOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : LoadOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} LoadOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : LoadOpGenericAdaptor(values, attrs, Properties{}, {}) {} LoadOpGenericAdaptor(RangeT values, const LoadOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> LoadOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getAddr() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class LoadOpAdaptor : public LoadOpGenericAdaptor<::mlir::ValueRange> { public: using LoadOpGenericAdaptor::LoadOpGenericAdaptor; LoadOpAdaptor(LoadOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class LoadOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::LLVM::AccessGroupOpInterface::Trait, ::mlir::LLVM::AliasAnalysisOpInterface::Trait, ::mlir::DestructurableAccessorOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::PromotableMemOpInterface::Trait, ::mlir::SafeMemorySlotAccessOpInterface::Trait, ::mlir::LLVM::DereferenceableOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = LoadOpAdaptor; template using GenericAdaptor = LoadOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_addr = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::AccessGroupOpInterface::Trait::getAccessGroupsOrNull; using ::mlir::LLVM::AccessGroupOpInterface::Trait::setAccessGroups; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getNoAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setNoAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getTBAATagsOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setTBAATags; using ::mlir::LLVM::DereferenceableOpInterface::Trait::getDereferenceableOrNull; using ::mlir::LLVM::DereferenceableOpInterface::Trait::setDereferenceable; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("access_groups"), ::llvm::StringRef("alias_scopes"), ::llvm::StringRef("alignment"), ::llvm::StringRef("dereferenceable"), ::llvm::StringRef("invariant"), ::llvm::StringRef("invariantGroup"), ::llvm::StringRef("noalias_scopes"), ::llvm::StringRef("nontemporal"), ::llvm::StringRef("ordering"), ::llvm::StringRef("syncscope"), ::llvm::StringRef("tbaa"), ::llvm::StringRef("volatile_")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAccessGroupsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAccessGroupsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAliasScopesAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getDereferenceableAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getDereferenceableAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getInvariantAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getInvariantAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getInvariantGroupAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getInvariantGroupAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getNoaliasScopesAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getNoaliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getNontemporalAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getNontemporalAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getOrderingAttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getOrderingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } ::mlir::StringAttr getSyncscopeAttrName() { return getAttributeNameForIndex(9); } static ::mlir::StringAttr getSyncscopeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 9); } ::mlir::StringAttr getTbaaAttrName() { return getAttributeNameForIndex(10); } static ::mlir::StringAttr getTbaaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 10); } ::mlir::StringAttr getVolatile_AttrName() { return getAttributeNameForIndex(11); } static ::mlir::StringAttr getVolatile_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 11); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.load"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAddr() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getAddrMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::UnitAttr getVolatile_Attr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().volatile_); } bool getVolatile_(); ::mlir::UnitAttr getNontemporalAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nontemporal); } bool getNontemporal(); ::mlir::UnitAttr getInvariantAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().invariant); } bool getInvariant(); ::mlir::UnitAttr getInvariantGroupAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().invariantGroup); } bool getInvariantGroup(); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::AtomicOrderingAttr>(getProperties().ordering); } ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::LLVM::DereferenceableAttr getDereferenceableAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::DereferenceableAttr>(getProperties().dereferenceable); } ::std::optional<::mlir::LLVM::DereferenceableAttr> getDereferenceable(); ::mlir::ArrayAttr getAccessGroupsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); } ::std::optional< ::mlir::ArrayAttr > getTbaa(); void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setVolatile_Attr(::mlir::UnitAttr attr) { getProperties().volatile_ = attr; } void setVolatile_(bool attrValue); void setNontemporalAttr(::mlir::UnitAttr attr) { getProperties().nontemporal = attr; } void setNontemporal(bool attrValue); void setInvariantAttr(::mlir::UnitAttr attr) { getProperties().invariant = attr; } void setInvariant(bool attrValue); void setInvariantGroupAttr(::mlir::UnitAttr attr) { getProperties().invariantGroup = attr; } void setInvariantGroup(bool attrValue); void setOrderingAttr(::mlir::LLVM::AtomicOrderingAttr attr) { getProperties().ordering = attr; } void setOrdering(::mlir::LLVM::AtomicOrdering attrValue); void setSyncscopeAttr(::mlir::StringAttr attr) { getProperties().syncscope = attr; } void setSyncscope(::std::optional<::llvm::StringRef> attrValue); void setDereferenceableAttr(::mlir::LLVM::DereferenceableAttr attr) { getProperties().dereferenceable = attr; } void setAccessGroupsAttr(::mlir::ArrayAttr attr) { getProperties().access_groups = attr; } void setAliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().alias_scopes = attr; } void setNoaliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().noalias_scopes = attr; } void setTbaaAttr(::mlir::ArrayAttr attr) { getProperties().tbaa = attr; } ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeVolatile_Attr() { auto attr = getProperties().volatile_; getProperties().volatile_ = {}; return attr; } ::mlir::Attribute removeNontemporalAttr() { auto attr = getProperties().nontemporal; getProperties().nontemporal = {}; return attr; } ::mlir::Attribute removeInvariantAttr() { auto attr = getProperties().invariant; getProperties().invariant = {}; return attr; } ::mlir::Attribute removeInvariantGroupAttr() { auto attr = getProperties().invariantGroup; getProperties().invariantGroup = {}; return attr; } ::mlir::Attribute removeSyncscopeAttr() { auto attr = getProperties().syncscope; getProperties().syncscope = {}; return attr; } ::mlir::Attribute removeDereferenceableAttr() { auto attr = getProperties().dereferenceable; getProperties().dereferenceable = {}; return attr; } ::mlir::Attribute removeAccessGroupsAttr() { auto attr = getProperties().access_groups; getProperties().access_groups = {}; return attr; } ::mlir::Attribute removeAliasScopesAttr() { auto attr = getProperties().alias_scopes; getProperties().alias_scopes = {}; return attr; } ::mlir::Attribute removeNoaliasScopesAttr() { auto attr = getProperties().noalias_scopes; getProperties().noalias_scopes = {}; return attr; } ::mlir::Attribute removeTbaaAttr() { auto attr = getProperties().tbaa; getProperties().tbaa = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type type, Value addr, unsigned alignment = 0, bool isVolatile = false, bool isNonTemporal = false, bool isInvariant = false, bool isInvariantGroup = false, AtomicOrdering ordering = AtomicOrdering::not_atomic, StringRef syncscope = StringRef()); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type type, Value addr, unsigned alignment = 0, bool isVolatile = false, bool isNonTemporal = false, bool isInvariant = false, bool isInvariantGroup = false, AtomicOrdering ordering = AtomicOrdering::not_atomic, StringRef syncscope = StringRef()); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, Type type, Value addr, unsigned alignment = 0, bool isVolatile = false, bool isNonTemporal = false, bool isInvariant = false, bool isInvariantGroup = false, AtomicOrdering ordering = AtomicOrdering::not_atomic, StringRef syncscope = StringRef()); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariant, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariant, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariant, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariant, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariant, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariant, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariant, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariant, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariant, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariant, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariant, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariant, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::LLVM::DereferenceableAttr dereferenceable, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LoadOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static LoadOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::SmallVector<::mlir::Value> getAccessedOperands(); 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); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); bool loadsFrom(const ::mlir::MemorySlot &slot); bool storesTo(const ::mlir::MemorySlot &slot); ::mlir::Value getStored(const ::mlir::MemorySlot &slot, ::mlir::OpBuilder &builder, ::mlir::Value reachingDef, const ::mlir::DataLayout &dataLayout); bool canUsesBeRemoved(const ::mlir::MemorySlot &slot, const ::llvm::SmallPtrSetImpl<::mlir::OpOperand *> &blockingUses, ::llvm::SmallVectorImpl<::mlir::OpOperand *> &newBlockingUses, const ::mlir::DataLayout &datalayout); ::mlir::DeletionKind removeBlockingUses(const ::mlir::MemorySlot &slot, const ::llvm::SmallPtrSetImpl &blockingUses, ::mlir::OpBuilder &builder, ::mlir::Value reachingDefinition, const ::mlir::DataLayout &dataLayout); ::llvm::LogicalResult ensureOnlySafeAccesses(const ::mlir::MemorySlot &slot, ::mlir::SmallVectorImpl<::mlir::MemorySlot> &mustBeSafelyUsed, const ::mlir::DataLayout &dataLayout); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 12 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoadOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::LoadOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::MetadataAsValueOp declarations //===----------------------------------------------------------------------===// namespace detail { class MetadataAsValueOpGenericAdaptorBase { public: struct Properties { using metadataTy = ::mlir::Attribute; metadataTy metadata; auto getMetadata() const { auto &propStorage = this->metadata; return ::llvm::cast<::mlir::Attribute>(propStorage); } void setMetadata(const ::mlir::Attribute &propValue) { this->metadata = propValue; } bool operator==(const Properties &rhs) const { return rhs.metadata == this->metadata && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: MetadataAsValueOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.metadata_as_value", odsAttrs.getContext()); } MetadataAsValueOpGenericAdaptorBase(MetadataAsValueOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::Attribute getMetadataAttr() { auto attr = ::llvm::cast<::mlir::Attribute>(getProperties().metadata); return attr; } ::mlir::Attribute getMetadata(); }; } // namespace detail template class MetadataAsValueOpGenericAdaptor : public detail::MetadataAsValueOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::MetadataAsValueOpGenericAdaptorBase; public: MetadataAsValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} MetadataAsValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : MetadataAsValueOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} MetadataAsValueOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : MetadataAsValueOpGenericAdaptor(values, attrs, Properties{}, {}) {} MetadataAsValueOpGenericAdaptor(RangeT values, const MetadataAsValueOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> MetadataAsValueOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class MetadataAsValueOpAdaptor : public MetadataAsValueOpGenericAdaptor<::mlir::ValueRange> { public: using MetadataAsValueOpGenericAdaptor::MetadataAsValueOpGenericAdaptor; MetadataAsValueOpAdaptor(MetadataAsValueOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class MetadataAsValueOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = MetadataAsValueOpAdaptor; template using GenericAdaptor = MetadataAsValueOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("metadata")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getMetadataAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getMetadataAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.metadata_as_value"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::Attribute getMetadataAttr() { return ::llvm::cast<::mlir::Attribute>(getProperties().metadata); } ::mlir::Attribute getMetadata(); void setMetadataAttr(::mlir::Attribute attr) { getProperties().metadata = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Attribute metadata); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Attribute metadata); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Attribute metadata); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Attribute metadata); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Attribute metadata); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Attribute metadata); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Attribute metadata); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Attribute metadata); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Attribute metadata); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MetadataAsValueOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MetadataAsValueOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::MetadataAsValueOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::MetadataAsValueOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ModuleFlagsOp declarations //===----------------------------------------------------------------------===// namespace detail { class ModuleFlagsOpGenericAdaptorBase { public: struct Properties { using flagsTy = ::mlir::ArrayAttr; flagsTy flags; auto getFlags() const { auto &propStorage = this->flags; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setFlags(const ::mlir::ArrayAttr &propValue) { this->flags = propValue; } bool operator==(const Properties &rhs) const { return rhs.flags == this->flags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ModuleFlagsOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.module_flags", odsAttrs.getContext()); } ModuleFlagsOpGenericAdaptorBase(ModuleFlagsOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::ArrayAttr getFlagsAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().flags); return attr; } ::mlir::ArrayAttr getFlags(); }; } // namespace detail template class ModuleFlagsOpGenericAdaptor : public detail::ModuleFlagsOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ModuleFlagsOpGenericAdaptorBase; public: ModuleFlagsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ModuleFlagsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ModuleFlagsOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ModuleFlagsOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ModuleFlagsOpGenericAdaptor(values, attrs, Properties{}, {}) {} ModuleFlagsOpGenericAdaptor(RangeT values, const ModuleFlagsOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ModuleFlagsOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ModuleFlagsOpAdaptor : public ModuleFlagsOpGenericAdaptor<::mlir::ValueRange> { public: using ModuleFlagsOpGenericAdaptor::ModuleFlagsOpGenericAdaptor; ModuleFlagsOpAdaptor(ModuleFlagsOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ModuleFlagsOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = ModuleFlagsOpAdaptor; template using GenericAdaptor = ModuleFlagsOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("flags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.module_flags"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::ArrayAttr getFlagsAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().flags); } ::mlir::ArrayAttr getFlags(); void setFlagsAttr(::mlir::ArrayAttr attr) { getProperties().flags = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ArrayAttr flags); static ModuleFlagsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ArrayAttr flags); static ModuleFlagsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ArrayAttr flags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr flags); static ModuleFlagsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr flags); static ModuleFlagsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ArrayAttr flags); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ModuleFlagsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ModuleFlagsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ModuleFlagsOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ModuleFlagsOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ModuleFlagsOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ModuleFlagsOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::MulOp declarations //===----------------------------------------------------------------------===// namespace detail { class MulOpGenericAdaptorBase { public: struct Properties { using overflowFlagsTy = ::mlir::LLVM::IntegerOverflowFlags; overflowFlagsTy overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none; ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() const { auto &propStorage = this->overflowFlags; return propStorage; } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags propValue) { auto &propStorage = this->overflowFlags; propStorage = propValue; } bool operator==(const Properties &rhs) const { return rhs.overflowFlags == this->overflowFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: MulOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mul", odsAttrs.getContext()); } MulOpGenericAdaptorBase(MulOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } }; } // namespace detail template class MulOpGenericAdaptor : public detail::MulOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::MulOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: MulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} MulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : MulOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} MulOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : MulOpGenericAdaptor(values, attrs, Properties{}, {}) {} MulOpGenericAdaptor(RangeT values, const MulOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> MulOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class MulOpAdaptor : public MulOpGenericAdaptor<::mlir::ValueRange> { public: using MulOpGenericAdaptor::MulOpGenericAdaptor; MulOpAdaptor(MulOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class MulOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait, ::mlir::OpTrait::IsCommutative, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = MulOpAdaptor; template using GenericAdaptor = MulOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::setOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoUnsignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoSignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlagsAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mul"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags newOverflowFlags) { getProperties().setOverflowFlags(newOverflowFlags); } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MulOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static MulOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::MulOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::MulOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::NamedMetadataOp declarations //===----------------------------------------------------------------------===// namespace detail { class NamedMetadataOpGenericAdaptorBase { public: struct Properties { using metadata_nameTy = ::mlir::StringAttr; metadata_nameTy metadata_name; auto getMetadataName() const { auto &propStorage = this->metadata_name; return ::llvm::cast<::mlir::StringAttr>(propStorage); } void setMetadataName(const ::mlir::StringAttr &propValue) { this->metadata_name = propValue; } using nodesTy = ::mlir::ArrayAttr; nodesTy nodes; auto getNodes() const { auto &propStorage = this->nodes; return ::llvm::cast<::mlir::ArrayAttr>(propStorage); } void setNodes(const ::mlir::ArrayAttr &propValue) { this->nodes = propValue; } bool operator==(const Properties &rhs) const { return rhs.metadata_name == this->metadata_name && rhs.nodes == this->nodes && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: NamedMetadataOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.named_metadata", odsAttrs.getContext()); } NamedMetadataOpGenericAdaptorBase(NamedMetadataOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::StringAttr getMetadataNameAttr() { auto attr = ::llvm::cast<::mlir::StringAttr>(getProperties().metadata_name); return attr; } ::llvm::StringRef getMetadataName(); ::mlir::ArrayAttr getNodesAttr() { auto attr = ::llvm::cast<::mlir::ArrayAttr>(getProperties().nodes); return attr; } ::mlir::ArrayAttr getNodes(); }; } // namespace detail template class NamedMetadataOpGenericAdaptor : public detail::NamedMetadataOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::NamedMetadataOpGenericAdaptorBase; public: NamedMetadataOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} NamedMetadataOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : NamedMetadataOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} NamedMetadataOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : NamedMetadataOpGenericAdaptor(values, attrs, Properties{}, {}) {} NamedMetadataOpGenericAdaptor(RangeT values, const NamedMetadataOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> NamedMetadataOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class NamedMetadataOpAdaptor : public NamedMetadataOpGenericAdaptor<::mlir::ValueRange> { public: using NamedMetadataOpGenericAdaptor::NamedMetadataOpGenericAdaptor; NamedMetadataOpAdaptor(NamedMetadataOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class NamedMetadataOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = NamedMetadataOpAdaptor; template using GenericAdaptor = NamedMetadataOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("metadata_name"), ::llvm::StringRef("nodes")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getMetadataNameAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getMetadataNameAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getNodesAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getNodesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.named_metadata"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::StringAttr getMetadataNameAttr() { return ::llvm::cast<::mlir::StringAttr>(getProperties().metadata_name); } ::llvm::StringRef getMetadataName(); ::mlir::ArrayAttr getNodesAttr() { return ::llvm::cast<::mlir::ArrayAttr>(getProperties().nodes); } ::mlir::ArrayAttr getNodes(); void setMetadataNameAttr(::mlir::StringAttr attr) { getProperties().metadata_name = attr; } void setMetadataName(::llvm::StringRef attrValue); void setNodesAttr(::mlir::ArrayAttr attr) { getProperties().nodes = attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::StringAttr metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::StringAttr metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::StringAttr metadata_name, ::mlir::ArrayAttr nodes); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::StringAttr metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::StringAttr metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::StringAttr metadata_name, ::mlir::ArrayAttr nodes); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::StringRef metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::llvm::StringRef metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::ImplicitLocOpBuilder &builder, ::llvm::StringRef metadata_name, ::mlir::ArrayAttr nodes); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::llvm::StringRef metadata_name, ::mlir::ArrayAttr nodes); static NamedMetadataOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::llvm::StringRef metadata_name, ::mlir::ArrayAttr nodes); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static NamedMetadataOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static NamedMetadataOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static NamedMetadataOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static NamedMetadataOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 2 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::NamedMetadataOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::NamedMetadataOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::NoneTokenOp declarations //===----------------------------------------------------------------------===// namespace detail { class NoneTokenOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: NoneTokenOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.none", odsAttrs.getContext()); } NoneTokenOpGenericAdaptorBase(NoneTokenOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class NoneTokenOpGenericAdaptor : public detail::NoneTokenOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::NoneTokenOpGenericAdaptorBase; public: NoneTokenOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} NoneTokenOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : NoneTokenOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} NoneTokenOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : NoneTokenOpGenericAdaptor(values, attrs, Properties{}, {}) {} NoneTokenOpGenericAdaptor(RangeT values, const NoneTokenOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> NoneTokenOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class NoneTokenOpAdaptor : public NoneTokenOpGenericAdaptor<::mlir::ValueRange> { public: using NoneTokenOpGenericAdaptor::NoneTokenOpGenericAdaptor; NoneTokenOpAdaptor(NoneTokenOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class NoneTokenOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpTrait::TokenProducerTrait> { public: using Op::Op; using Op::print; using Adaptor = NoneTokenOpAdaptor; template using GenericAdaptor = NoneTokenOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.none"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::TokenType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::TokenType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static NoneTokenOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static NoneTokenOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::NoneTokenOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::OrOp declarations //===----------------------------------------------------------------------===// namespace detail { class OrOpGenericAdaptorBase { public: struct Properties { using isDisjointTy = ::mlir::UnitAttr; isDisjointTy isDisjoint; auto getIsDisjoint() const { auto &propStorage = this->isDisjoint; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setIsDisjoint(const ::mlir::UnitAttr &propValue) { this->isDisjoint = propValue; } bool operator==(const Properties &rhs) const { return rhs.isDisjoint == this->isDisjoint && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: OrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.or", odsAttrs.getContext()); } OrOpGenericAdaptorBase(OrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getIsDisjointAttr(); bool getIsDisjoint(); }; } // namespace detail template class OrOpGenericAdaptor : public detail::OrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::OrOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: OrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} OrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : OrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} OrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : OrOpGenericAdaptor(values, attrs, Properties{}, {}) {} OrOpGenericAdaptor(RangeT values, const OrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> OrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class OrOpAdaptor : public OrOpGenericAdaptor<::mlir::ValueRange> { public: using OrOpGenericAdaptor::OrOpGenericAdaptor; OrOpAdaptor(OrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class OrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::DisjointFlagInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = OrOpAdaptor; template using GenericAdaptor = OrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::DisjointFlagInterface::Trait::getIsDisjoint; using ::mlir::LLVM::DisjointFlagInterface::Trait::setIsDisjoint; using ::mlir::LLVM::DisjointFlagInterface::Trait::getIsDisjointName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("isDisjoint")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getIsDisjointAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getIsDisjointAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.or"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getIsDisjointAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().isDisjoint); } bool getIsDisjoint(); void setIsDisjointAttr(::mlir::UnitAttr attr) { getProperties().isDisjoint = attr; } void setIsDisjoint(bool attrValue); ::mlir::Attribute removeIsDisjointAttr() { auto attr = getProperties().isDisjoint; getProperties().isDisjoint = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isDisjoint); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isDisjoint = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static OrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static OrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::OrOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::OrOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::PoisonOp declarations //===----------------------------------------------------------------------===// namespace detail { class PoisonOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: PoisonOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.poison", odsAttrs.getContext()); } PoisonOpGenericAdaptorBase(PoisonOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class PoisonOpGenericAdaptor : public detail::PoisonOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::PoisonOpGenericAdaptorBase; public: PoisonOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} PoisonOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PoisonOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} PoisonOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PoisonOpGenericAdaptor(values, attrs, Properties{}, {}) {} PoisonOpGenericAdaptor(RangeT values, const PoisonOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> PoisonOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class PoisonOpAdaptor : public PoisonOpGenericAdaptor<::mlir::ValueRange> { public: using PoisonOpGenericAdaptor::PoisonOpGenericAdaptor; PoisonOpAdaptor(PoisonOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class PoisonOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike> { public: using Op::Op; using Op::print; using Adaptor = PoisonOpAdaptor; template using GenericAdaptor = PoisonOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.poison"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static PoisonOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static PoisonOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res); static PoisonOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res); static PoisonOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes); static PoisonOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes); static PoisonOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static PoisonOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static PoisonOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static PoisonOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static PoisonOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::PoisonOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::PtrToAddrOp declarations //===----------------------------------------------------------------------===// namespace detail { class PtrToAddrOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: PtrToAddrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.ptrtoaddr", odsAttrs.getContext()); } PtrToAddrOpGenericAdaptorBase(PtrToAddrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class PtrToAddrOpGenericAdaptor : public detail::PtrToAddrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::PtrToAddrOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: PtrToAddrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} PtrToAddrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PtrToAddrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} PtrToAddrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PtrToAddrOpGenericAdaptor(values, attrs, Properties{}, {}) {} PtrToAddrOpGenericAdaptor(RangeT values, const PtrToAddrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> PtrToAddrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class PtrToAddrOpAdaptor : public PtrToAddrOpGenericAdaptor<::mlir::ValueRange> { public: using PtrToAddrOpGenericAdaptor::PtrToAddrOpGenericAdaptor; PtrToAddrOpAdaptor(PtrToAddrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class PtrToAddrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = PtrToAddrOpAdaptor; template using GenericAdaptor = PtrToAddrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.ptrtoaddr"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static PtrToAddrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static PtrToAddrOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static PtrToAddrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static PtrToAddrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static PtrToAddrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static PtrToAddrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static PtrToAddrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static PtrToAddrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static PtrToAddrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static PtrToAddrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::PtrToAddrOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::PtrToIntOp declarations //===----------------------------------------------------------------------===// namespace detail { class PtrToIntOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: PtrToIntOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.ptrtoint", odsAttrs.getContext()); } PtrToIntOpGenericAdaptorBase(PtrToIntOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class PtrToIntOpGenericAdaptor : public detail::PtrToIntOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::PtrToIntOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: PtrToIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} PtrToIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : PtrToIntOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} PtrToIntOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : PtrToIntOpGenericAdaptor(values, attrs, Properties{}, {}) {} PtrToIntOpGenericAdaptor(RangeT values, const PtrToIntOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> PtrToIntOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class PtrToIntOpAdaptor : public PtrToIntOpGenericAdaptor<::mlir::ValueRange> { public: using PtrToIntOpGenericAdaptor::PtrToIntOpGenericAdaptor; PtrToIntOpAdaptor(PtrToIntOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class PtrToIntOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = PtrToIntOpAdaptor; template using GenericAdaptor = PtrToIntOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.ptrtoint"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static PtrToIntOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static PtrToIntOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static PtrToIntOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static PtrToIntOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static PtrToIntOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static PtrToIntOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static PtrToIntOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static PtrToIntOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static PtrToIntOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static PtrToIntOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::PtrToIntOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ResumeOp declarations //===----------------------------------------------------------------------===// namespace detail { class ResumeOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ResumeOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.resume", odsAttrs.getContext()); } ResumeOpGenericAdaptorBase(ResumeOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class ResumeOpGenericAdaptor : public detail::ResumeOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ResumeOpGenericAdaptorBase; static constexpr int odsIndex_value = 0; public: ResumeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ResumeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ResumeOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ResumeOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ResumeOpGenericAdaptor(values, attrs, Properties{}, {}) {} ResumeOpGenericAdaptor(RangeT values, const ResumeOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ResumeOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getValue() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ResumeOpAdaptor : public ResumeOpGenericAdaptor<::mlir::ValueRange> { public: using ResumeOpGenericAdaptor::ResumeOpGenericAdaptor; ResumeOpAdaptor(ResumeOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ResumeOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = ResumeOpAdaptor; template using GenericAdaptor = ResumeOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_value = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.resume"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getValueMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value); static ResumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value value); static ResumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value value); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value value); static ResumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value value); static ResumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value value); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ResumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ResumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ResumeOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ResumeOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ResumeOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ReturnOp declarations //===----------------------------------------------------------------------===// namespace detail { class ReturnOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ReturnOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.return", odsAttrs.getContext()); } ReturnOpGenericAdaptorBase(ReturnOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class ReturnOpGenericAdaptor : public detail::ReturnOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ReturnOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: ReturnOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ReturnOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ReturnOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ReturnOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ReturnOpGenericAdaptor(values, attrs, Properties{}, {}) {} ReturnOpGenericAdaptor(RangeT values, const ReturnOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ReturnOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { auto operands = getODSOperands(0); return operands.empty() ? ValueT{} : (*operands.begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ReturnOpAdaptor : public ReturnOpGenericAdaptor<::mlir::ValueRange> { public: using ReturnOpGenericAdaptor::ReturnOpGenericAdaptor; ReturnOpAdaptor(ReturnOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ReturnOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = ReturnOpAdaptor; template using GenericAdaptor = ReturnOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::RegionBranchTerminatorOpInterface::Trait::getMutableSuccessorOperands; using ::mlir::RegionBranchTerminatorOpInterface::Trait::getSuccessorRegions; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.return"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { auto operands = getODSOperands(0); return operands.empty() ? ::mlir::TypedValue<::mlir::Type>{} : ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*operands.begin()); } ::mlir::MutableOperandRange getArgMutable(); std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange args); static ReturnOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ValueRange args); static ReturnOp create(::mlir::ImplicitLocOpBuilder &builder, ValueRange args); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Value arg); static ReturnOp create(::mlir::OpBuilder &builder, ::mlir::Location location, /*optional*/::mlir::Value arg); static ReturnOp create(::mlir::ImplicitLocOpBuilder &builder, /*optional*/::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, /*optional*/::mlir::Value arg); static ReturnOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, /*optional*/::mlir::Value arg); static ReturnOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, /*optional*/::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ReturnOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ReturnOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ReturnOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ReturnOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ReturnOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SDivOp declarations //===----------------------------------------------------------------------===// namespace detail { class SDivOpGenericAdaptorBase { public: struct Properties { using isExactTy = ::mlir::UnitAttr; isExactTy isExact; auto getIsExact() const { auto &propStorage = this->isExact; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setIsExact(const ::mlir::UnitAttr &propValue) { this->isExact = propValue; } bool operator==(const Properties &rhs) const { return rhs.isExact == this->isExact && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SDivOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.sdiv", odsAttrs.getContext()); } SDivOpGenericAdaptorBase(SDivOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getIsExactAttr(); bool getIsExact(); }; } // namespace detail template class SDivOpGenericAdaptor : public detail::SDivOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SDivOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: SDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SDivOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SDivOpGenericAdaptor(values, attrs, Properties{}, {}) {} SDivOpGenericAdaptor(RangeT values, const SDivOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SDivOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SDivOpAdaptor : public SDivOpGenericAdaptor<::mlir::ValueRange> { public: using SDivOpGenericAdaptor::SDivOpGenericAdaptor; SDivOpAdaptor(SDivOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SDivOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::ExactFlagInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = SDivOpAdaptor; template using GenericAdaptor = SDivOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::setIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExactName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("isExact")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getIsExactAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getIsExactAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.sdiv"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getIsExactAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().isExact); } bool getIsExact(); void setIsExactAttr(::mlir::UnitAttr attr) { getProperties().isExact = attr; } void setIsExact(bool attrValue); ::mlir::Attribute removeIsExactAttr() { auto attr = getProperties().isExact; getProperties().isExact = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); ::mlir::Speculation::Speculatability getSpeculatability(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SDivOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::SDivOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SExtOp declarations //===----------------------------------------------------------------------===// namespace detail { class SExtOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SExtOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.sext", odsAttrs.getContext()); } SExtOpGenericAdaptorBase(SExtOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class SExtOpGenericAdaptor : public detail::SExtOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SExtOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: SExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SExtOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SExtOpGenericAdaptor(values, attrs, Properties{}, {}) {} SExtOpGenericAdaptor(RangeT values, const SExtOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SExtOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SExtOpAdaptor : public SExtOpGenericAdaptor<::mlir::ValueRange> { public: using SExtOpGenericAdaptor::SExtOpGenericAdaptor; SExtOpAdaptor(SExtOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SExtOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = SExtOpAdaptor; template using GenericAdaptor = SExtOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.sext"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SExtOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static SExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static SExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static SExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static SExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SExtOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SIToFPOp declarations //===----------------------------------------------------------------------===// namespace detail { class SIToFPOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SIToFPOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.sitofp", odsAttrs.getContext()); } SIToFPOpGenericAdaptorBase(SIToFPOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class SIToFPOpGenericAdaptor : public detail::SIToFPOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SIToFPOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: SIToFPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SIToFPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SIToFPOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SIToFPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SIToFPOpGenericAdaptor(values, attrs, Properties{}, {}) {} SIToFPOpGenericAdaptor(RangeT values, const SIToFPOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SIToFPOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SIToFPOpAdaptor : public SIToFPOpGenericAdaptor<::mlir::ValueRange> { public: using SIToFPOpGenericAdaptor::SIToFPOpGenericAdaptor; SIToFPOpAdaptor(SIToFPOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SIToFPOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = SIToFPOpAdaptor; template using GenericAdaptor = SIToFPOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.sitofp"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static SIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static SIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static SIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static SIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SIToFPOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SRemOp declarations //===----------------------------------------------------------------------===// namespace detail { class SRemOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SRemOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.srem", odsAttrs.getContext()); } SRemOpGenericAdaptorBase(SRemOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class SRemOpGenericAdaptor : public detail::SRemOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SRemOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: SRemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SRemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SRemOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SRemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SRemOpGenericAdaptor(values, attrs, Properties{}, {}) {} SRemOpGenericAdaptor(RangeT values, const SRemOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SRemOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SRemOpAdaptor : public SRemOpGenericAdaptor<::mlir::ValueRange> { public: using SRemOpGenericAdaptor::SRemOpGenericAdaptor; SRemOpAdaptor(SRemOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SRemOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = SRemOpAdaptor; template using GenericAdaptor = SRemOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.srem"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SRemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SRemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SRemOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SelectOp declarations //===----------------------------------------------------------------------===// namespace detail { class SelectOpGenericAdaptorBase { public: struct Properties { using fastmathFlagsTy = ::mlir::LLVM::FastmathFlagsAttr; fastmathFlagsTy fastmathFlags; auto getFastmathFlags() const { auto &propStorage = this->fastmathFlags; return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(propStorage); } void setFastmathFlags(const ::mlir::LLVM::FastmathFlagsAttr &propValue) { this->fastmathFlags = propValue; } bool operator==(const Properties &rhs) const { return rhs.fastmathFlags == this->fastmathFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SelectOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.select", odsAttrs.getContext()); } SelectOpGenericAdaptorBase(SelectOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr(); ::mlir::LLVM::FastmathFlags getFastmathFlags(); }; } // namespace detail template class SelectOpGenericAdaptor : public detail::SelectOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SelectOpGenericAdaptorBase; static constexpr int odsIndex_condition = 0; static constexpr int odsIndex_trueValue = 1; static constexpr int odsIndex_falseValue = 2; public: SelectOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SelectOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SelectOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SelectOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SelectOpGenericAdaptor(values, attrs, Properties{}, {}) {} SelectOpGenericAdaptor(RangeT values, const SelectOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SelectOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getCondition() { return (*getODSOperands(0).begin()); } ValueT getTrueValue() { return (*getODSOperands(1).begin()); } ValueT getFalseValue() { return (*getODSOperands(2).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SelectOpAdaptor : public SelectOpGenericAdaptor<::mlir::ValueRange> { public: using SelectOpGenericAdaptor::SelectOpGenericAdaptor; SelectOpAdaptor(SelectOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SelectOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::FastmathFlagsInterface::Trait, ::mlir::SelectLikeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = SelectOpAdaptor; template using GenericAdaptor = SelectOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_condition = 0; static constexpr int odsIndex_trueValue = 1; static constexpr int odsIndex_falseValue = 2; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttr; using ::mlir::LLVM::FastmathFlagsInterface::Trait::getFastmathAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("fastmathFlags")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getFastmathFlagsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getFastmathFlagsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.select"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getCondition() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getTrueValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::TypedValue<::mlir::Type> getFalseValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(2).begin()); } ::mlir::OpOperand &getConditionMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getTrueValueMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getFalseValueMutable() { auto range = getODSOperandIndexAndLength(2); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::FastmathFlagsAttr getFastmathFlagsAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::FastmathFlagsAttr>(getProperties().fastmathFlags); } ::mlir::LLVM::FastmathFlags getFastmathFlags(); void setFastmathFlagsAttr(::mlir::LLVM::FastmathFlagsAttr attr) { getProperties().fastmathFlags = attr; } void setFastmathFlags(::mlir::LLVM::FastmathFlags attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlagsAttr fastmathFlags); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value condition, ::mlir::Value trueValue, ::mlir::Value falseValue, ::mlir::LLVM::FastmathFlags fastmathFlags = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SelectOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SelectOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SelectOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::SelectOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ShlOp declarations //===----------------------------------------------------------------------===// namespace detail { class ShlOpGenericAdaptorBase { public: struct Properties { using overflowFlagsTy = ::mlir::LLVM::IntegerOverflowFlags; overflowFlagsTy overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none; ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() const { auto &propStorage = this->overflowFlags; return propStorage; } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags propValue) { auto &propStorage = this->overflowFlags; propStorage = propValue; } bool operator==(const Properties &rhs) const { return rhs.overflowFlags == this->overflowFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ShlOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.shl", odsAttrs.getContext()); } ShlOpGenericAdaptorBase(ShlOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } }; } // namespace detail template class ShlOpGenericAdaptor : public detail::ShlOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ShlOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: ShlOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ShlOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ShlOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ShlOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ShlOpGenericAdaptor(values, attrs, Properties{}, {}) {} ShlOpGenericAdaptor(RangeT values, const ShlOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ShlOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ShlOpAdaptor : public ShlOpGenericAdaptor<::mlir::ValueRange> { public: using ShlOpGenericAdaptor::ShlOpGenericAdaptor; ShlOpAdaptor(ShlOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ShlOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = ShlOpAdaptor; template using GenericAdaptor = ShlOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::setOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoUnsignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoSignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlagsAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.shl"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags newOverflowFlags) { getProperties().setOverflowFlags(newOverflowFlags); } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ShlOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ShlOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ShlOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ShlOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ShuffleVectorOp declarations //===----------------------------------------------------------------------===// namespace detail { class ShuffleVectorOpGenericAdaptorBase { public: struct Properties { using maskTy = ::mlir::DenseI32ArrayAttr; maskTy mask; auto getMask() const { auto &propStorage = this->mask; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setMask(const ::mlir::DenseI32ArrayAttr &propValue) { this->mask = propValue; } bool operator==(const Properties &rhs) const { return rhs.mask == this->mask && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ShuffleVectorOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.shufflevector", odsAttrs.getContext()); } ShuffleVectorOpGenericAdaptorBase(ShuffleVectorOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::DenseI32ArrayAttr getMaskAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().mask); return attr; } ::llvm::ArrayRef getMask(); }; } // namespace detail template class ShuffleVectorOpGenericAdaptor : public detail::ShuffleVectorOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ShuffleVectorOpGenericAdaptorBase; static constexpr int odsIndex_v1 = 0; static constexpr int odsIndex_v2 = 1; public: ShuffleVectorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ShuffleVectorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ShuffleVectorOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ShuffleVectorOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ShuffleVectorOpGenericAdaptor(values, attrs, Properties{}, {}) {} ShuffleVectorOpGenericAdaptor(RangeT values, const ShuffleVectorOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ShuffleVectorOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getV1() { return (*getODSOperands(0).begin()); } ValueT getV2() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ShuffleVectorOpAdaptor : public ShuffleVectorOpGenericAdaptor<::mlir::ValueRange> { public: using ShuffleVectorOpGenericAdaptor::ShuffleVectorOpGenericAdaptor; ShuffleVectorOpAdaptor(ShuffleVectorOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ShuffleVectorOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = ShuffleVectorOpAdaptor; template using GenericAdaptor = ShuffleVectorOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_v1 = 0; static constexpr int odsIndex_v2 = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("mask")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getMaskAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getMaskAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.shufflevector"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::VectorType> getV1() { return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::VectorType> getV2() { return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getV1Mutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getV2Mutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::VectorType> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::VectorType>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::DenseI32ArrayAttr getMaskAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().mask); } ::llvm::ArrayRef getMask(); void setMaskAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().mask = attr; } void setMask(::llvm::ArrayRef attrValue); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value v1, Value v2, DenseI32ArrayAttr mask, ArrayRef attrs = {}); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value v1, Value v2, DenseI32ArrayAttr mask, ArrayRef attrs = {}); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, Value v1, Value v2, DenseI32ArrayAttr mask, ArrayRef attrs = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value v1, Value v2, ArrayRef mask); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value v1, Value v2, ArrayRef mask); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, Value v1, Value v2, ArrayRef mask); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::mlir::DenseI32ArrayAttr mask); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::mlir::DenseI32ArrayAttr mask); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::mlir::DenseI32ArrayAttr mask); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::mlir::DenseI32ArrayAttr mask); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::mlir::DenseI32ArrayAttr mask); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::mlir::DenseI32ArrayAttr mask); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::llvm::ArrayRef mask); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::llvm::ArrayRef mask); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value v1, ::mlir::Value v2, ::llvm::ArrayRef mask); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::llvm::ArrayRef mask); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::llvm::ArrayRef mask); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value v1, ::mlir::Value v2, ::llvm::ArrayRef mask); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ShuffleVectorOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ShuffleVectorOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ShuffleVectorOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ShuffleVectorOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::StoreOp declarations //===----------------------------------------------------------------------===// namespace detail { class StoreOpGenericAdaptorBase { public: struct Properties { using access_groupsTy = ::mlir::ArrayAttr; access_groupsTy access_groups; auto getAccessGroups() const { auto &propStorage = this->access_groups; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAccessGroups(const ::mlir::ArrayAttr &propValue) { this->access_groups = propValue; } using alias_scopesTy = ::mlir::ArrayAttr; alias_scopesTy alias_scopes; auto getAliasScopes() const { auto &propStorage = this->alias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setAliasScopes(const ::mlir::ArrayAttr &propValue) { this->alias_scopes = propValue; } using alignmentTy = ::mlir::IntegerAttr; alignmentTy alignment; auto getAlignment() const { auto &propStorage = this->alignment; return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(propStorage); } void setAlignment(const ::mlir::IntegerAttr &propValue) { this->alignment = propValue; } using invariantGroupTy = ::mlir::UnitAttr; invariantGroupTy invariantGroup; auto getInvariantGroup() const { auto &propStorage = this->invariantGroup; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setInvariantGroup(const ::mlir::UnitAttr &propValue) { this->invariantGroup = propValue; } using noalias_scopesTy = ::mlir::ArrayAttr; noalias_scopesTy noalias_scopes; auto getNoaliasScopes() const { auto &propStorage = this->noalias_scopes; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setNoaliasScopes(const ::mlir::ArrayAttr &propValue) { this->noalias_scopes = propValue; } using nontemporalTy = ::mlir::UnitAttr; nontemporalTy nontemporal; auto getNontemporal() const { auto &propStorage = this->nontemporal; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNontemporal(const ::mlir::UnitAttr &propValue) { this->nontemporal = propValue; } using orderingTy = ::mlir::LLVM::AtomicOrderingAttr; orderingTy ordering; auto getOrdering() const { auto &propStorage = this->ordering; return ::llvm::dyn_cast_or_null<::mlir::LLVM::AtomicOrderingAttr>(propStorage); } void setOrdering(const ::mlir::LLVM::AtomicOrderingAttr &propValue) { this->ordering = propValue; } using syncscopeTy = ::mlir::StringAttr; syncscopeTy syncscope; auto getSyncscope() const { auto &propStorage = this->syncscope; return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(propStorage); } void setSyncscope(const ::mlir::StringAttr &propValue) { this->syncscope = propValue; } using tbaaTy = ::mlir::ArrayAttr; tbaaTy tbaa; auto getTbaa() const { auto &propStorage = this->tbaa; return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(propStorage); } void setTbaa(const ::mlir::ArrayAttr &propValue) { this->tbaa = propValue; } using volatile_Ty = ::mlir::UnitAttr; volatile_Ty volatile_; auto getVolatile_() const { auto &propStorage = this->volatile_; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setVolatile_(const ::mlir::UnitAttr &propValue) { this->volatile_ = propValue; } bool operator==(const Properties &rhs) const { return rhs.access_groups == this->access_groups && rhs.alias_scopes == this->alias_scopes && rhs.alignment == this->alignment && rhs.invariantGroup == this->invariantGroup && rhs.noalias_scopes == this->noalias_scopes && rhs.nontemporal == this->nontemporal && rhs.ordering == this->ordering && rhs.syncscope == this->syncscope && rhs.tbaa == this->tbaa && rhs.volatile_ == this->volatile_ && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: StoreOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.store", odsAttrs.getContext()); } StoreOpGenericAdaptorBase(StoreOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::IntegerAttr getAlignmentAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); return attr; } ::std::optional getAlignment(); ::mlir::UnitAttr getVolatile_Attr(); bool getVolatile_(); ::mlir::UnitAttr getNontemporalAttr(); bool getNontemporal(); ::mlir::UnitAttr getInvariantGroupAttr(); bool getInvariantGroup(); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr(); ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); return attr; } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::ArrayAttr getAccessGroupsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); return attr; } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); return attr; } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); return attr; } ::std::optional< ::mlir::ArrayAttr > getTbaa(); }; } // namespace detail template class StoreOpGenericAdaptor : public detail::StoreOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::StoreOpGenericAdaptorBase; static constexpr int odsIndex_value = 0; static constexpr int odsIndex_addr = 1; public: StoreOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} StoreOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : StoreOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} StoreOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : StoreOpGenericAdaptor(values, attrs, Properties{}, {}) {} StoreOpGenericAdaptor(RangeT values, const StoreOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> StoreOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getValue() { return (*getODSOperands(0).begin()); } ValueT getAddr() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class StoreOpAdaptor : public StoreOpGenericAdaptor<::mlir::ValueRange> { public: using StoreOpGenericAdaptor::StoreOpGenericAdaptor; StoreOpAdaptor(StoreOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class StoreOp : public ::mlir::Op::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::LLVM::AccessGroupOpInterface::Trait, ::mlir::LLVM::AliasAnalysisOpInterface::Trait, ::mlir::DestructurableAccessorOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::PromotableMemOpInterface::Trait, ::mlir::SafeMemorySlotAccessOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = StoreOpAdaptor; template using GenericAdaptor = StoreOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_value = 0; static constexpr int odsIndex_addr = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::AccessGroupOpInterface::Trait::getAccessGroupsOrNull; using ::mlir::LLVM::AccessGroupOpInterface::Trait::setAccessGroups; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getNoAliasScopesOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setNoAliasScopes; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::getTBAATagsOrNull; using ::mlir::LLVM::AliasAnalysisOpInterface::Trait::setTBAATags; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("access_groups"), ::llvm::StringRef("alias_scopes"), ::llvm::StringRef("alignment"), ::llvm::StringRef("invariantGroup"), ::llvm::StringRef("noalias_scopes"), ::llvm::StringRef("nontemporal"), ::llvm::StringRef("ordering"), ::llvm::StringRef("syncscope"), ::llvm::StringRef("tbaa"), ::llvm::StringRef("volatile_")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getAccessGroupsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getAccessGroupsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getAliasScopesAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getAliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getAlignmentAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getAlignmentAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getInvariantGroupAttrName() { return getAttributeNameForIndex(3); } static ::mlir::StringAttr getInvariantGroupAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 3); } ::mlir::StringAttr getNoaliasScopesAttrName() { return getAttributeNameForIndex(4); } static ::mlir::StringAttr getNoaliasScopesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 4); } ::mlir::StringAttr getNontemporalAttrName() { return getAttributeNameForIndex(5); } static ::mlir::StringAttr getNontemporalAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 5); } ::mlir::StringAttr getOrderingAttrName() { return getAttributeNameForIndex(6); } static ::mlir::StringAttr getOrderingAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 6); } ::mlir::StringAttr getSyncscopeAttrName() { return getAttributeNameForIndex(7); } static ::mlir::StringAttr getSyncscopeAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 7); } ::mlir::StringAttr getTbaaAttrName() { return getAttributeNameForIndex(8); } static ::mlir::StringAttr getTbaaAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 8); } ::mlir::StringAttr getVolatile_AttrName() { return getAttributeNameForIndex(9); } static ::mlir::StringAttr getVolatile_AttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 9); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.store"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getAddr() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getValueMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getAddrMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::IntegerAttr getAlignmentAttr() { return ::llvm::dyn_cast_or_null<::mlir::IntegerAttr>(getProperties().alignment); } ::std::optional getAlignment(); ::mlir::UnitAttr getVolatile_Attr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().volatile_); } bool getVolatile_(); ::mlir::UnitAttr getNontemporalAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nontemporal); } bool getNontemporal(); ::mlir::UnitAttr getInvariantGroupAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().invariantGroup); } bool getInvariantGroup(); ::mlir::LLVM::AtomicOrderingAttr getOrderingAttr() { return ::llvm::dyn_cast_or_null<::mlir::LLVM::AtomicOrderingAttr>(getProperties().ordering); } ::mlir::LLVM::AtomicOrdering getOrdering(); ::mlir::StringAttr getSyncscopeAttr() { return ::llvm::dyn_cast_or_null<::mlir::StringAttr>(getProperties().syncscope); } ::std::optional< ::llvm::StringRef > getSyncscope(); ::mlir::ArrayAttr getAccessGroupsAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().access_groups); } ::std::optional< ::mlir::ArrayAttr > getAccessGroups(); ::mlir::ArrayAttr getAliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().alias_scopes); } ::std::optional< ::mlir::ArrayAttr > getAliasScopes(); ::mlir::ArrayAttr getNoaliasScopesAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().noalias_scopes); } ::std::optional< ::mlir::ArrayAttr > getNoaliasScopes(); ::mlir::ArrayAttr getTbaaAttr() { return ::llvm::dyn_cast_or_null<::mlir::ArrayAttr>(getProperties().tbaa); } ::std::optional< ::mlir::ArrayAttr > getTbaa(); void setAlignmentAttr(::mlir::IntegerAttr attr) { getProperties().alignment = attr; } void setAlignment(::std::optional attrValue); void setVolatile_Attr(::mlir::UnitAttr attr) { getProperties().volatile_ = attr; } void setVolatile_(bool attrValue); void setNontemporalAttr(::mlir::UnitAttr attr) { getProperties().nontemporal = attr; } void setNontemporal(bool attrValue); void setInvariantGroupAttr(::mlir::UnitAttr attr) { getProperties().invariantGroup = attr; } void setInvariantGroup(bool attrValue); void setOrderingAttr(::mlir::LLVM::AtomicOrderingAttr attr) { getProperties().ordering = attr; } void setOrdering(::mlir::LLVM::AtomicOrdering attrValue); void setSyncscopeAttr(::mlir::StringAttr attr) { getProperties().syncscope = attr; } void setSyncscope(::std::optional<::llvm::StringRef> attrValue); void setAccessGroupsAttr(::mlir::ArrayAttr attr) { getProperties().access_groups = attr; } void setAliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().alias_scopes = attr; } void setNoaliasScopesAttr(::mlir::ArrayAttr attr) { getProperties().noalias_scopes = attr; } void setTbaaAttr(::mlir::ArrayAttr attr) { getProperties().tbaa = attr; } ::mlir::Attribute removeAlignmentAttr() { auto attr = getProperties().alignment; getProperties().alignment = {}; return attr; } ::mlir::Attribute removeVolatile_Attr() { auto attr = getProperties().volatile_; getProperties().volatile_ = {}; return attr; } ::mlir::Attribute removeNontemporalAttr() { auto attr = getProperties().nontemporal; getProperties().nontemporal = {}; return attr; } ::mlir::Attribute removeInvariantGroupAttr() { auto attr = getProperties().invariantGroup; getProperties().invariantGroup = {}; return attr; } ::mlir::Attribute removeSyncscopeAttr() { auto attr = getProperties().syncscope; getProperties().syncscope = {}; return attr; } ::mlir::Attribute removeAccessGroupsAttr() { auto attr = getProperties().access_groups; getProperties().access_groups = {}; return attr; } ::mlir::Attribute removeAliasScopesAttr() { auto attr = getProperties().alias_scopes; getProperties().alias_scopes = {}; return attr; } ::mlir::Attribute removeNoaliasScopesAttr() { auto attr = getProperties().noalias_scopes; getProperties().noalias_scopes = {}; return attr; } ::mlir::Attribute removeTbaaAttr() { auto attr = getProperties().tbaa; getProperties().tbaa = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value value, Value addr, unsigned alignment = 0, bool isVolatile = false, bool isNonTemporal = false, bool isInvariantGroup = false, AtomicOrdering ordering = AtomicOrdering::not_atomic, StringRef syncscope = StringRef()); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value value, Value addr, unsigned alignment = 0, bool isVolatile = false, bool isNonTemporal = false, bool isInvariantGroup = false, AtomicOrdering ordering = AtomicOrdering::not_atomic, StringRef syncscope = StringRef()); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, Value value, Value addr, unsigned alignment = 0, bool isVolatile = false, bool isNonTemporal = false, bool isInvariantGroup = false, AtomicOrdering ordering = AtomicOrdering::not_atomic, StringRef syncscope = StringRef()); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/::mlir::UnitAttr volatile_, /*optional*/::mlir::UnitAttr nontemporal, /*optional*/::mlir::UnitAttr invariantGroup, ::mlir::LLVM::AtomicOrderingAttr ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::Value addr, /*optional*/::mlir::IntegerAttr alignment, /*optional*/bool volatile_, /*optional*/bool nontemporal, /*optional*/bool invariantGroup, ::mlir::LLVM::AtomicOrdering ordering, /*optional*/::mlir::StringAttr syncscope, /*optional*/::mlir::ArrayAttr access_groups, /*optional*/::mlir::ArrayAttr alias_scopes, /*optional*/::mlir::ArrayAttr noalias_scopes, /*optional*/::mlir::ArrayAttr tbaa); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static StoreOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static StoreOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void populateDefaultProperties(::mlir::OperationName opName, Properties &properties); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::llvm::SmallVector<::mlir::Value> getAccessedOperands(); 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); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); bool loadsFrom(const ::mlir::MemorySlot &slot); bool storesTo(const ::mlir::MemorySlot &slot); ::mlir::Value getStored(const ::mlir::MemorySlot &slot, ::mlir::OpBuilder &builder, ::mlir::Value reachingDef, const ::mlir::DataLayout &dataLayout); bool canUsesBeRemoved(const ::mlir::MemorySlot &slot, const ::llvm::SmallPtrSetImpl<::mlir::OpOperand *> &blockingUses, ::llvm::SmallVectorImpl<::mlir::OpOperand *> &newBlockingUses, const ::mlir::DataLayout &datalayout); ::mlir::DeletionKind removeBlockingUses(const ::mlir::MemorySlot &slot, const ::llvm::SmallPtrSetImpl &blockingUses, ::mlir::OpBuilder &builder, ::mlir::Value reachingDefinition, const ::mlir::DataLayout &dataLayout); ::llvm::LogicalResult ensureOnlySafeAccesses(const ::mlir::MemorySlot &slot, ::mlir::SmallVectorImpl<::mlir::MemorySlot> &mustBeSafelyUsed, const ::mlir::DataLayout &dataLayout); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 10 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::StoreOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::StoreOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SubOp declarations //===----------------------------------------------------------------------===// namespace detail { class SubOpGenericAdaptorBase { public: struct Properties { using overflowFlagsTy = ::mlir::LLVM::IntegerOverflowFlags; overflowFlagsTy overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none; ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() const { auto &propStorage = this->overflowFlags; return propStorage; } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags propValue) { auto &propStorage = this->overflowFlags; propStorage = propValue; } bool operator==(const Properties &rhs) const { return rhs.overflowFlags == this->overflowFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SubOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.sub", odsAttrs.getContext()); } SubOpGenericAdaptorBase(SubOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } }; } // namespace detail template class SubOpGenericAdaptor : public detail::SubOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SubOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: SubOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SubOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SubOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SubOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : SubOpGenericAdaptor(values, attrs, Properties{}, {}) {} SubOpGenericAdaptor(RangeT values, const SubOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SubOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SubOpAdaptor : public SubOpGenericAdaptor<::mlir::ValueRange> { public: using SubOpGenericAdaptor::SubOpGenericAdaptor; SubOpAdaptor(SubOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SubOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = SubOpAdaptor; template using GenericAdaptor = SubOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::setOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoUnsignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoSignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlagsAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.sub"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags newOverflowFlags) { getProperties().setOverflowFlags(newOverflowFlags); } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SubOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SubOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SubOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::SubOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::SwitchOp declarations //===----------------------------------------------------------------------===// namespace detail { class SwitchOpGenericAdaptorBase { public: struct Properties { using branch_weightsTy = ::mlir::DenseI32ArrayAttr; branch_weightsTy branch_weights; auto getBranchWeights() const { auto &propStorage = this->branch_weights; return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(propStorage); } void setBranchWeights(const ::mlir::DenseI32ArrayAttr &propValue) { this->branch_weights = propValue; } using case_operand_segmentsTy = ::mlir::DenseI32ArrayAttr; case_operand_segmentsTy case_operand_segments; auto getCaseOperandSegments() const { auto &propStorage = this->case_operand_segments; return ::llvm::cast<::mlir::DenseI32ArrayAttr>(propStorage); } void setCaseOperandSegments(const ::mlir::DenseI32ArrayAttr &propValue) { this->case_operand_segments = propValue; } using case_valuesTy = ::mlir::DenseIntElementsAttr; case_valuesTy case_values; auto getCaseValues() const { auto &propStorage = this->case_values; return ::llvm::dyn_cast_or_null<::mlir::DenseIntElementsAttr>(propStorage); } void setCaseValues(const ::mlir::DenseIntElementsAttr &propValue) { this->case_values = propValue; } using operandSegmentSizesTy = std::array; operandSegmentSizesTy operandSegmentSizes; ::llvm::ArrayRef getOperandSegmentSizes() const { auto &propStorage = this->operandSegmentSizes; return propStorage; } void setOperandSegmentSizes(::llvm::ArrayRef propValue) { auto &propStorage = this->operandSegmentSizes; ::llvm::copy(propValue, propStorage.begin()); } bool operator==(const Properties &rhs) const { return rhs.branch_weights == this->branch_weights && rhs.case_operand_segments == this->case_operand_segments && rhs.case_values == this->case_values && rhs.operandSegmentSizes == this->operandSegmentSizes && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: SwitchOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.switch", odsAttrs.getContext()); } SwitchOpGenericAdaptorBase(SwitchOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize); const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::DenseIntElementsAttr getCaseValuesAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseIntElementsAttr>(getProperties().case_values); return attr; } ::std::optional< ::mlir::DenseIntElementsAttr > getCaseValues(); ::mlir::DenseI32ArrayAttr getCaseOperandSegmentsAttr() { auto attr = ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().case_operand_segments); return attr; } ::llvm::ArrayRef getCaseOperandSegments(); ::mlir::DenseI32ArrayAttr getBranchWeightsAttr() { auto attr = ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().branch_weights); return attr; } ::std::optional<::llvm::ArrayRef> getBranchWeights(); }; } // namespace detail template class SwitchOpGenericAdaptor : public detail::SwitchOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::SwitchOpGenericAdaptorBase; static constexpr int odsIndex_value = 0; static constexpr int odsIndex_defaultOperands = 1; static constexpr int odsIndex_caseOperands = 2; public: SwitchOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} SwitchOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : SwitchOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} SwitchOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs) : SwitchOpGenericAdaptor(values, attrs, Properties{}, {}) {} SwitchOpGenericAdaptor(RangeT values, const SwitchOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> SwitchOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getValue() { return (*getODSOperands(0).begin()); } RangeT getDefaultOperands() { return getODSOperands(1); } ::llvm::SmallVector getCaseOperands() { auto tblgenTmpOperands = getODSOperands(2); auto sizes = getCaseOperandSegments(); ::llvm::SmallVector tblgenTmpOperandGroups; for (int i = 0, e = sizes.size(); i < e; ++i) { tblgenTmpOperandGroups.push_back(tblgenTmpOperands.take_front(sizes[i])); tblgenTmpOperands = tblgenTmpOperands.drop_front(sizes[i]); } return tblgenTmpOperandGroups; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class SwitchOpAdaptor : public SwitchOpGenericAdaptor<::mlir::ValueRange> { public: using SwitchOpGenericAdaptor::SwitchOpGenericAdaptor; SwitchOpAdaptor(SwitchOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class SwitchOp : public ::mlir::Op::Impl, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::BranchOpInterface::Trait, ::mlir::WeightedBranchOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { public: using Op::Op; using Op::print; using Adaptor = SwitchOpAdaptor; template using GenericAdaptor = SwitchOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_value = 0; static constexpr int odsIndex_defaultOperands = 1; static constexpr int odsIndex_caseOperands = 2; using Properties = FoldAdaptor::Properties; using ::mlir::BranchOpInterface::Trait::getSuccessorForOperands; using ::mlir::BranchOpInterface::Trait::areTypesCompatible; using ::mlir::WeightedBranchOpInterface::Trait::getWeights; using ::mlir::WeightedBranchOpInterface::Trait::setWeights; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("branch_weights"), ::llvm::StringRef("case_operand_segments"), ::llvm::StringRef("case_values"), ::llvm::StringRef("operandSegmentSizes")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getBranchWeightsAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getBranchWeightsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } ::mlir::StringAttr getCaseOperandSegmentsAttrName() { return getAttributeNameForIndex(1); } static ::mlir::StringAttr getCaseOperandSegmentsAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 1); } ::mlir::StringAttr getCaseValuesAttrName() { return getAttributeNameForIndex(2); } static ::mlir::StringAttr getCaseValuesAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 2); } ::mlir::StringAttr getOperandSegmentSizesAttrName() { return (*this)->getName().getAttributeNames().back(); } static ::mlir::StringAttr getOperandSegmentSizesAttrName(::mlir::OperationName name) { return name.getAttributeNames().back(); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.switch"); } std::pair getODSOperandIndexAndLength(unsigned index); ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::IntegerType> getValue() { return ::llvm::cast<::mlir::TypedValue<::mlir::IntegerType>>(*getODSOperands(0).begin()); } ::mlir::Operation::operand_range getDefaultOperands() { return getODSOperands(1); } ::mlir::OperandRangeRange getCaseOperands() { return getODSOperands(2).split(getCaseOperandSegmentsAttr()); } ::mlir::OpOperand &getValueMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::MutableOperandRange getDefaultOperandsMutable(); ::mlir::MutableOperandRangeRange getCaseOperandsMutable(); std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::Block *getDefaultDestination() { return (*this)->getSuccessor(0); } ::mlir::SuccessorRange getCaseDestinations() { return {std::next((*this)->successor_begin(), 1), (*this)->successor_end()}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::DenseIntElementsAttr getCaseValuesAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseIntElementsAttr>(getProperties().case_values); } ::std::optional< ::mlir::DenseIntElementsAttr > getCaseValues(); ::mlir::DenseI32ArrayAttr getCaseOperandSegmentsAttr() { return ::llvm::cast<::mlir::DenseI32ArrayAttr>(getProperties().case_operand_segments); } ::llvm::ArrayRef getCaseOperandSegments(); ::mlir::DenseI32ArrayAttr getBranchWeightsAttr() { return ::llvm::dyn_cast_or_null<::mlir::DenseI32ArrayAttr>(getProperties().branch_weights); } ::std::optional<::llvm::ArrayRef> getBranchWeights(); void setCaseValuesAttr(::mlir::DenseIntElementsAttr attr) { getProperties().case_values = attr; } void setCaseOperandSegmentsAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().case_operand_segments = attr; } void setCaseOperandSegments(::llvm::ArrayRef attrValue); void setBranchWeightsAttr(::mlir::DenseI32ArrayAttr attr) { getProperties().branch_weights = attr; } void setBranchWeights(::std::optional<::llvm::ArrayRef> attrValue); ::mlir::Attribute removeCaseValuesAttr() { auto attr = getProperties().case_values; getProperties().case_values = {}; return attr; } ::mlir::Attribute removeBranchWeightsAttr() { auto attr = getProperties().branch_weights; getProperties().branch_weights = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value value, Block *defaultDestination, ValueRange defaultOperands, DenseIntElementsAttr caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Value value, Block *defaultDestination, ValueRange defaultOperands, DenseIntElementsAttr caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, Value value, Block *defaultDestination, ValueRange defaultOperands, DenseIntElementsAttr caseValues = {}, BlockRange caseDestinations = {}, ArrayRef caseOperands = {}, ArrayRef branchWeights = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, ValueRange operands, SuccessorRange destinations, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value value, ::mlir::ValueRange defaultOperands, ::llvm::ArrayRef<::mlir::ValueRange> caseOperands, /*optional*/::mlir::DenseIntElementsAttr case_values, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::Block *defaultDestination, ::mlir::BlockRange caseDestinations); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value value, ::mlir::ValueRange defaultOperands, ::llvm::ArrayRef<::mlir::ValueRange> caseOperands, /*optional*/::mlir::DenseIntElementsAttr case_values, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::Block *defaultDestination, ::mlir::BlockRange caseDestinations); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value value, ::mlir::ValueRange defaultOperands, ::llvm::ArrayRef<::mlir::ValueRange> caseOperands, /*optional*/::mlir::DenseIntElementsAttr case_values, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::Block *defaultDestination, ::mlir::BlockRange caseDestinations); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::ValueRange defaultOperands, ::llvm::ArrayRef<::mlir::ValueRange> caseOperands, /*optional*/::mlir::DenseIntElementsAttr case_values, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::Block *defaultDestination, ::mlir::BlockRange caseDestinations); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::ValueRange defaultOperands, ::llvm::ArrayRef<::mlir::ValueRange> caseOperands, /*optional*/::mlir::DenseIntElementsAttr case_values, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::Block *defaultDestination, ::mlir::BlockRange caseDestinations); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value value, ::mlir::ValueRange defaultOperands, ::llvm::ArrayRef<::mlir::ValueRange> caseOperands, /*optional*/::mlir::DenseIntElementsAttr case_values, /*optional*/::mlir::DenseI32ArrayAttr branch_weights, ::mlir::Block *defaultDestination, ::mlir::BlockRange caseDestinations); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SwitchOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static SwitchOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::SuccessorOperands getSuccessorOperands(unsigned index); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 3 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: /// Return the operands for the case destination block at the given index. OperandRange getCaseOperands(unsigned index) { return getCaseOperands()[index]; } /// Return a mutable range of operands for the case destination block at the /// given index. MutableOperandRange getCaseOperandsMutable(unsigned index) { return getCaseOperandsMutable()[index]; } }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::SwitchOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::SwitchOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::TruncOp declarations //===----------------------------------------------------------------------===// namespace detail { class TruncOpGenericAdaptorBase { public: struct Properties { using overflowFlagsTy = ::mlir::LLVM::IntegerOverflowFlags; overflowFlagsTy overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none; ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() const { auto &propStorage = this->overflowFlags; return propStorage; } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags propValue) { auto &propStorage = this->overflowFlags; propStorage = propValue; } bool operator==(const Properties &rhs) const { return rhs.overflowFlags == this->overflowFlags && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: TruncOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.trunc", odsAttrs.getContext()); } TruncOpGenericAdaptorBase(TruncOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } }; } // namespace detail template class TruncOpGenericAdaptor : public detail::TruncOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::TruncOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: TruncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} TruncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : TruncOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} TruncOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : TruncOpGenericAdaptor(values, attrs, Properties{}, {}) {} TruncOpGenericAdaptor(RangeT values, const TruncOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> TruncOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class TruncOpAdaptor : public TruncOpGenericAdaptor<::mlir::ValueRange> { public: using TruncOpGenericAdaptor::TruncOpGenericAdaptor; TruncOpAdaptor(TruncOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class TruncOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = TruncOpAdaptor; template using GenericAdaptor = TruncOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::setOverflowFlags; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoUnsignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::hasNoSignedWrap; using ::mlir::LLVM::IntegerOverflowFlagsInterface::Trait::getOverflowFlagsAttrName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.trunc"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::LLVM::IntegerOverflowFlags getOverflowFlags() { return getProperties().getOverflowFlags(); } void setOverflowFlags(::mlir::LLVM::IntegerOverflowFlags newOverflowFlags) { getProperties().setOverflowFlags(newOverflowFlags); } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static TruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static TruncOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static TruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static TruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static TruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static TruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::LLVM::IntegerOverflowFlags overflowFlags = ::mlir::LLVM::IntegerOverflowFlags::none); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static TruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static TruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static TruncOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static TruncOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::TruncOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::TruncOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::UDivOp declarations //===----------------------------------------------------------------------===// namespace detail { class UDivOpGenericAdaptorBase { public: struct Properties { using isExactTy = ::mlir::UnitAttr; isExactTy isExact; auto getIsExact() const { auto &propStorage = this->isExact; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setIsExact(const ::mlir::UnitAttr &propValue) { this->isExact = propValue; } bool operator==(const Properties &rhs) const { return rhs.isExact == this->isExact && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: UDivOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.udiv", odsAttrs.getContext()); } UDivOpGenericAdaptorBase(UDivOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getIsExactAttr(); bool getIsExact(); }; } // namespace detail template class UDivOpGenericAdaptor : public detail::UDivOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::UDivOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: UDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} UDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UDivOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} UDivOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UDivOpGenericAdaptor(values, attrs, Properties{}, {}) {} UDivOpGenericAdaptor(RangeT values, const UDivOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> UDivOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class UDivOpAdaptor : public UDivOpGenericAdaptor<::mlir::ValueRange> { public: using UDivOpGenericAdaptor::UDivOpGenericAdaptor; UDivOpAdaptor(UDivOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class UDivOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::ExactFlagInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = UDivOpAdaptor; template using GenericAdaptor = UDivOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::setIsExact; using ::mlir::LLVM::ExactFlagInterface::Trait::getIsExactName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("isExact")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getIsExactAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getIsExactAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.udiv"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getIsExactAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().isExact); } bool getIsExact(); void setIsExactAttr(::mlir::UnitAttr attr) { getProperties().isExact = attr; } void setIsExact(bool attrValue); ::mlir::Attribute removeIsExactAttr() { auto attr = getProperties().isExact; getProperties().isExact = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/::mlir::UnitAttr isExact); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs, /*optional*/bool isExact = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UDivOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UDivOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); ::mlir::Speculation::Speculatability getSpeculatability(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::UDivOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::UDivOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::UIToFPOp declarations //===----------------------------------------------------------------------===// namespace detail { class UIToFPOpGenericAdaptorBase { public: struct Properties { using nonNegTy = ::mlir::UnitAttr; nonNegTy nonNeg; auto getNonNeg() const { auto &propStorage = this->nonNeg; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNonNeg(const ::mlir::UnitAttr &propValue) { this->nonNeg = propValue; } bool operator==(const Properties &rhs) const { return rhs.nonNeg == this->nonNeg && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: UIToFPOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.uitofp", odsAttrs.getContext()); } UIToFPOpGenericAdaptorBase(UIToFPOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getNonNegAttr(); bool getNonNeg(); }; } // namespace detail template class UIToFPOpGenericAdaptor : public detail::UIToFPOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::UIToFPOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: UIToFPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} UIToFPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UIToFPOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} UIToFPOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UIToFPOpGenericAdaptor(values, attrs, Properties{}, {}) {} UIToFPOpGenericAdaptor(RangeT values, const UIToFPOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> UIToFPOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class UIToFPOpAdaptor : public UIToFPOpGenericAdaptor<::mlir::ValueRange> { public: using UIToFPOpGenericAdaptor::UIToFPOpGenericAdaptor; UIToFPOpAdaptor(UIToFPOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class UIToFPOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::NonNegFlagInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = UIToFPOpAdaptor; template using GenericAdaptor = UIToFPOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::NonNegFlagInterface::Trait::getNonNeg; using ::mlir::LLVM::NonNegFlagInterface::Trait::setNonNeg; using ::mlir::LLVM::NonNegFlagInterface::Trait::getNonNegName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("nonNeg")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getNonNegAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getNonNegAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.uitofp"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getNonNegAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nonNeg); } bool getNonNeg(); void setNonNegAttr(::mlir::UnitAttr attr) { getProperties().nonNeg = attr; } void setNonNeg(bool attrValue); ::mlir::Attribute removeNonNegAttr() { auto attr = getProperties().nonNeg; getProperties().nonNeg = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, /*optional*/bool nonNeg = false); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, /*optional*/bool nonNeg = false); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, /*optional*/bool nonNeg = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/bool nonNeg = false); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/bool nonNeg = false); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/bool nonNeg = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UIToFPOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UIToFPOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::UIToFPOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::UIToFPOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::URemOp declarations //===----------------------------------------------------------------------===// namespace detail { class URemOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: URemOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.urem", odsAttrs.getContext()); } URemOpGenericAdaptorBase(URemOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class URemOpGenericAdaptor : public detail::URemOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::URemOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: URemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} URemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : URemOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} URemOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : URemOpGenericAdaptor(values, attrs, Properties{}, {}) {} URemOpGenericAdaptor(RangeT values, const URemOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> URemOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class URemOpAdaptor : public URemOpGenericAdaptor<::mlir::ValueRange> { public: using URemOpGenericAdaptor::URemOpGenericAdaptor; URemOpAdaptor(URemOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class URemOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = URemOpAdaptor; template using GenericAdaptor = URemOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.urem"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static URemOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static URemOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::URemOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::UndefOp declarations //===----------------------------------------------------------------------===// namespace detail { class UndefOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: UndefOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.undef", odsAttrs.getContext()); } UndefOpGenericAdaptorBase(UndefOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class UndefOpGenericAdaptor : public detail::UndefOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::UndefOpGenericAdaptorBase; public: UndefOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} UndefOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UndefOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} UndefOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UndefOpGenericAdaptor(values, attrs, Properties{}, {}) {} UndefOpGenericAdaptor(RangeT values, const UndefOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> UndefOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class UndefOpAdaptor : public UndefOpGenericAdaptor<::mlir::ValueRange> { public: using UndefOpGenericAdaptor::UndefOpGenericAdaptor; UndefOpAdaptor(UndefOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class UndefOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike> { public: using Op::Op; using Op::print; using Adaptor = UndefOpAdaptor; template using GenericAdaptor = UndefOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.undef"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static UndefOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static UndefOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res); static UndefOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res); static UndefOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes); static UndefOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes); static UndefOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UndefOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UndefOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UndefOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UndefOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::UndefOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::UnreachableOp declarations //===----------------------------------------------------------------------===// namespace detail { class UnreachableOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: UnreachableOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.unreachable", odsAttrs.getContext()); } UnreachableOpGenericAdaptorBase(UnreachableOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class UnreachableOpGenericAdaptor : public detail::UnreachableOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::UnreachableOpGenericAdaptorBase; public: UnreachableOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} UnreachableOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : UnreachableOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} UnreachableOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : UnreachableOpGenericAdaptor(values, attrs, Properties{}, {}) {} UnreachableOpGenericAdaptor(RangeT values, const UnreachableOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> UnreachableOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class UnreachableOpAdaptor : public UnreachableOpGenericAdaptor<::mlir::ValueRange> { public: using UnreachableOpGenericAdaptor::UnreachableOpGenericAdaptor; UnreachableOpAdaptor(UnreachableOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class UnreachableOp : public ::mlir::Op { public: using Op::Op; using Op::print; using Adaptor = UnreachableOpAdaptor; template using GenericAdaptor = UnreachableOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.unreachable"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState); static UnreachableOp create(::mlir::OpBuilder &builder, ::mlir::Location location); static UnreachableOp create(::mlir::ImplicitLocOpBuilder &builder); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes); static UnreachableOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes); static UnreachableOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UnreachableOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static UnreachableOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UnreachableOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static UnreachableOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::UnreachableOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::VaArgOp declarations //===----------------------------------------------------------------------===// namespace detail { class VaArgOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: VaArgOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.va_arg", odsAttrs.getContext()); } VaArgOpGenericAdaptorBase(VaArgOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class VaArgOpGenericAdaptor : public detail::VaArgOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::VaArgOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: VaArgOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} VaArgOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : VaArgOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} VaArgOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : VaArgOpGenericAdaptor(values, attrs, Properties{}, {}) {} VaArgOpGenericAdaptor(RangeT values, const VaArgOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> VaArgOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class VaArgOpAdaptor : public VaArgOpGenericAdaptor<::mlir::ValueRange> { public: using VaArgOpGenericAdaptor::VaArgOpGenericAdaptor; VaArgOpAdaptor(VaArgOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class VaArgOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { public: using Op::Op; using Op::print; using Adaptor = VaArgOpAdaptor; template using GenericAdaptor = VaArgOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.va_arg"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::LLVM::LLVMPointerType> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::LLVM::LLVMPointerType>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static VaArgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static VaArgOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg); static VaArgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg); static VaArgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static VaArgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static VaArgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static VaArgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static VaArgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static VaArgOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static VaArgOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::VaArgOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::XOrOp declarations //===----------------------------------------------------------------------===// namespace detail { class XOrOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: XOrOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.xor", odsAttrs.getContext()); } XOrOpGenericAdaptorBase(XOrOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class XOrOpGenericAdaptor : public detail::XOrOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::XOrOpGenericAdaptorBase; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; public: XOrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} XOrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : XOrOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} XOrOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : XOrOpGenericAdaptor(values, attrs, Properties{}, {}) {} XOrOpGenericAdaptor(RangeT values, const XOrOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> XOrOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getLhs() { return (*getODSOperands(0).begin()); } ValueT getRhs() { return (*getODSOperands(1).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class XOrOpAdaptor : public XOrOpGenericAdaptor<::mlir::ValueRange> { public: using XOrOpGenericAdaptor::XOrOpGenericAdaptor; XOrOpAdaptor(XOrOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class XOrOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::InferTypeOpInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = XOrOpAdaptor; template using GenericAdaptor = XOrOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_lhs = 0; static constexpr int odsIndex_rhs = 1; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.xor"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getLhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::TypedValue<::mlir::Type> getRhs() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(1).begin()); } ::mlir::OpOperand &getLhsMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } ::mlir::OpOperand &getRhsMutable() { auto range = getODSOperandIndexAndLength(1); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value lhs, ::mlir::Value rhs); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Value lhs, ::mlir::Value rhs); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value lhs, ::mlir::Value rhs); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static XOrOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static XOrOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); static ::llvm::LogicalResult inferReturnTypes(::mlir::MLIRContext *context, ::std::optional<::mlir::Location> location, ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, ::mlir::PropertyRef properties, ::mlir::RegionRange regions, ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::XOrOp) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ZExtOp declarations //===----------------------------------------------------------------------===// namespace detail { class ZExtOpGenericAdaptorBase { public: struct Properties { using nonNegTy = ::mlir::UnitAttr; nonNegTy nonNeg; auto getNonNeg() const { auto &propStorage = this->nonNeg; return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(propStorage); } void setNonNeg(const ::mlir::UnitAttr &propValue) { this->nonNeg = propValue; } bool operator==(const Properties &rhs) const { return rhs.nonNeg == this->nonNeg && true; } bool operator!=(const Properties &rhs) const { return !(*this == rhs); } }; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ZExtOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.zext", odsAttrs.getContext()); } ZExtOpGenericAdaptorBase(ZExtOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } ::mlir::UnitAttr getNonNegAttr(); bool getNonNeg(); }; } // namespace detail template class ZExtOpGenericAdaptor : public detail::ZExtOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ZExtOpGenericAdaptorBase; static constexpr int odsIndex_arg = 0; public: ZExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ZExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ZExtOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ZExtOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ZExtOpGenericAdaptor(values, attrs, Properties{}, {}) {} ZExtOpGenericAdaptor(RangeT values, const ZExtOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ZExtOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } ValueT getArg() { return (*getODSOperands(0).begin()); } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ZExtOpAdaptor : public ZExtOpGenericAdaptor<::mlir::ValueRange> { public: using ZExtOpGenericAdaptor::ZExtOpGenericAdaptor; ZExtOpAdaptor(ZExtOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ZExtOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::LLVM::NonNegFlagInterface::Trait> { public: using Op::Op; using Op::print; using Adaptor = ZExtOpAdaptor; template using GenericAdaptor = ZExtOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; static constexpr int odsIndex_arg = 0; using Properties = FoldAdaptor::Properties; using ::mlir::LLVM::NonNegFlagInterface::Trait::getNonNeg; using ::mlir::LLVM::NonNegFlagInterface::Trait::setNonNeg; using ::mlir::LLVM::NonNegFlagInterface::Trait::getNonNegName; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { static ::llvm::StringRef attrNames[] = {::llvm::StringRef("nonNeg")}; return ::llvm::ArrayRef(attrNames); } ::mlir::StringAttr getNonNegAttrName() { return getAttributeNameForIndex(0); } static ::mlir::StringAttr getNonNegAttrName(::mlir::OperationName name) { return getAttributeNameForIndex(name, 0); } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.zext"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getArg() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSOperands(0).begin()); } ::mlir::OpOperand &getArgMutable() { auto range = getODSOperandIndexAndLength(0); return getOperation()->getOpOperand(range.first); } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::llvm::LogicalResult readProperties(::mlir::DialectBytecodeReader &reader, ::mlir::OperationState &state); void writeProperties(::mlir::DialectBytecodeWriter &writer); ::mlir::UnitAttr getNonNegAttr() { return ::llvm::dyn_cast_or_null<::mlir::UnitAttr>(getProperties().nonNeg); } bool getNonNeg(); void setNonNegAttr(::mlir::UnitAttr attr) { getProperties().nonNeg = attr; } void setNonNeg(bool attrValue); ::mlir::Attribute removeNonNegAttr() { auto attr = getProperties().nonNeg; getProperties().nonNeg = {}; return attr; } static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/::mlir::UnitAttr nonNeg); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res, ::mlir::Value arg, /*optional*/bool nonNeg = false); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res, ::mlir::Value arg, /*optional*/bool nonNeg = false); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res, ::mlir::Value arg, /*optional*/bool nonNeg = false); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/bool nonNeg = false); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/bool nonNeg = false); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::Value arg, /*optional*/bool nonNeg = false); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ZExtOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ZExtOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); private: ::mlir::StringAttr getAttributeNameForIndex(unsigned index) { return getAttributeNameForIndex((*this)->getName(), index); } static ::mlir::StringAttr getAttributeNameForIndex(::mlir::OperationName name, unsigned index) { assert(index < 1 && "invalid attribute index"); assert(name.getStringRef() == getOperationName() && "invalid operation name"); assert(name.isRegistered() && "Operation isn't registered, missing a " "dependent dialect loading?"); return name.getAttributeNames()[index]; } public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ZExtOp) MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::detail::ZExtOpGenericAdaptorBase::Properties) namespace mlir::LLVM { //===----------------------------------------------------------------------===// // ::mlir::LLVM::ZeroOp declarations //===----------------------------------------------------------------------===// namespace detail { class ZeroOpGenericAdaptorBase { public: using Properties = ::mlir::EmptyProperties; protected: ::mlir::DictionaryAttr odsAttrs; ::std::optional<::mlir::OperationName> odsOpName; Properties properties; ::mlir::RegionRange odsRegions; public: ZeroOpGenericAdaptorBase(::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : odsAttrs(attrs), properties(properties), odsRegions(regions) { if (odsAttrs) odsOpName.emplace("llvm.mlir.zero", odsAttrs.getContext()); } ZeroOpGenericAdaptorBase(ZeroOp op); std::pair getODSOperandIndexAndLength(unsigned index, unsigned odsOperandsSize) { return {index, 1}; } const Properties &getProperties() { return properties; } ::mlir::DictionaryAttr getAttributes() { return odsAttrs; } }; } // namespace detail template class ZeroOpGenericAdaptor : public detail::ZeroOpGenericAdaptorBase { using ValueT = ::llvm::detail::ValueOfRange; using Base = detail::ZeroOpGenericAdaptorBase; public: ZeroOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, const Properties &properties, ::mlir::RegionRange regions = {}) : Base(attrs, properties, regions), odsOperands(values) {} ZeroOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs, ::mlir::PropertyRef properties, ::mlir::RegionRange regions = {}) : ZeroOpGenericAdaptor(values, attrs, (properties ? *properties.as() : Properties{}), regions) {} ZeroOpGenericAdaptor(RangeT values, ::mlir::DictionaryAttr attrs = nullptr) : ZeroOpGenericAdaptor(values, attrs, Properties{}, {}) {} ZeroOpGenericAdaptor(RangeT values, const ZeroOpGenericAdaptorBase &base) : Base(base), odsOperands(values) {} template >> ZeroOpGenericAdaptor(RangeT values, LateInst op) : Base(op), odsOperands(values) {} std::pair getODSOperandIndexAndLength(unsigned index) { return Base::getODSOperandIndexAndLength(index, odsOperands.size()); } RangeT getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(odsOperands.begin(), valueRange.first), std::next(odsOperands.begin(), valueRange.first + valueRange.second)}; } RangeT getOperands() { return odsOperands; } private: RangeT odsOperands; }; class ZeroOpAdaptor : public ZeroOpGenericAdaptor<::mlir::ValueRange> { public: using ZeroOpGenericAdaptor::ZeroOpGenericAdaptor; ZeroOpAdaptor(ZeroOp op); ::llvm::LogicalResult verify(::mlir::Location loc); }; class ZeroOp : public ::mlir::Op::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::ConstantLike> { public: using Op::Op; using Op::print; using Adaptor = ZeroOpAdaptor; template using GenericAdaptor = ZeroOpGenericAdaptor; using FoldAdaptor = GenericAdaptor<::llvm::ArrayRef<::mlir::Attribute>>; using Properties = FoldAdaptor::Properties; static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames() { return {}; } static constexpr ::llvm::StringLiteral getOperationName() { return ::llvm::StringLiteral("llvm.mlir.zero"); } std::pair getODSOperandIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::operand_range getODSOperands(unsigned index) { auto valueRange = getODSOperandIndexAndLength(index); return {std::next(getOperation()->operand_begin(), valueRange.first), std::next(getOperation()->operand_begin(), valueRange.first + valueRange.second)}; } std::pair getODSResultIndexAndLength(unsigned index) { return {index, 1}; } ::mlir::Operation::result_range getODSResults(unsigned index) { auto valueRange = getODSResultIndexAndLength(index); return {std::next(getOperation()->result_begin(), valueRange.first), std::next(getOperation()->result_begin(), valueRange.first + valueRange.second)}; } ::mlir::TypedValue<::mlir::Type> getRes() { return ::llvm::cast<::mlir::TypedValue<::mlir::Type>>(*getODSResults(0).begin()); } static ::llvm::LogicalResult setPropertiesFromAttr(Properties &prop, ::mlir::Attribute attr, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static ::mlir::Attribute getPropertiesAsAttr(::mlir::MLIRContext *ctx, const Properties &prop); static llvm::hash_code computePropertiesHash(const Properties &prop); static std::optional getInherentAttr(::mlir::MLIRContext *ctx, const Properties &prop, llvm::StringRef name); static void setInherentAttr(Properties &prop, llvm::StringRef name, mlir::Attribute value); static void populateInherentAttrs(::mlir::MLIRContext *ctx, const Properties &prop, ::mlir::NamedAttrList &attrs); static ::llvm::LogicalResult verifyInherentAttrs(::mlir::OperationName opName, ::mlir::NamedAttrList &attrs, llvm::function_ref<::mlir::InFlightDiagnostic()> emitError); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ZeroOp create(::mlir::OpBuilder &builder, ::mlir::Location location, Type resultType, ValueRange operands, ArrayRef attributes = {}); static ZeroOp create(::mlir::ImplicitLocOpBuilder &builder, Type resultType, ValueRange operands, ArrayRef attributes = {}); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type res); static ZeroOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::Type res); static ZeroOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::Type res); static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes); static ZeroOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes); static ZeroOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ZeroOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static ZeroOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {}); static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ZeroOp create(::mlir::OpBuilder &builder, ::mlir::Location location, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); static ZeroOp create(::mlir::ImplicitLocOpBuilder &builder, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, const Properties &properties, ::llvm::ArrayRef<::mlir::NamedAttribute> discardableAttributes = {}); ::llvm::LogicalResult verifyInvariantsImpl(); ::llvm::LogicalResult verifyInvariants(); ::llvm::LogicalResult verify(); ::mlir::OpFoldResult fold(FoldAdaptor adaptor); static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result); void print(::mlir::OpAsmPrinter &_odsPrinter); void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> &effects); public: }; } // namespace mlir::LLVM MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::LLVM::ZeroOp) #endif // GET_OP_CLASSES