Lines Matching +full:built +full:- +full:docs
3 This dialect maps [LLVM IR](https://llvm.org/docs/LangRef.html) into MLIR by
8 [intermediate representation of LLVM](https://llvm.org/docs/LangRef.html) and
25 thread-safe alternatives compatible with the rest of the infrastructure. The
31 IR modules use the built-in MLIR `ModuleOp` and support all its features. In
40 [same syntax](https://llvm.org/docs/LangRef.html#data-layout) as in LLVM IR and
45 llvm.target_triple = "aarch64-linux-android"} {
53 syntax similar to that of the built-in function operation but supports
54 LLVM-related features such as linkage and variadic argument lists. See detailed
55 description in the operation list [below](#llvmfunc-llvmllvmfuncop).
100 ### Context-Level Values
104 values for thread-safety and concept parsimony reasons. Instead, regular values
106 [`llvm.mlir.constant`](#llvmmlirconstant-llvmconstantop),
107 [`llvm.mlir.undef`](#llvmmlirundef-llvmundefop),
108 [`llvm.mlir.poison`](#llvmmlirpoison-llvmpoisonop),
109 [`llvm.mlir.zero`](#llvmmlirzero-llvmzeroop). Note how these operations are
117 // Create an undefined value of structure type with a 32-bit integer followed
124 // Create an zero initialized value of structure type with a 32-bit integer
136 not using built-in types, which are used for typed MLIR attributes. The syntax
142 [`llvm.mlir.global`](#llvmmlirglobal-llvmglobalop), located at the module
145 Since functions need to be isolated-from-above, i.e. values defined outside the
147 [`llvm.mlir.addressof`](#llvmmliraddressof-llvmaddressofop), is provided to
155 Module-level named objects in the LLVM dialect, namely functions and globals,
157 [linkage types](https://llvm.org/docs/LangRef.html#linkage-types). Linkage is
163 ### Attribute Pass-Through
167 introduced as proper first-class concepts in the dialect.
169 The LLVM dialect provides a mechanism to forward function-level attributes to
182 passthrough = ["readonly", // value-less attribute
195 LLVM dialect uses built-in types whenever possible and defines a set of
197 directly represented with built-in types. Similarly to other MLIR context-owned
198 objects, the creation and manipulation of LLVM dialect types is thread-safe.
200 MLIR does not support module-scoped named type declarations, e.g. `%s = type
203 to be fully specified. MLIR [type aliases](../LangRef.md/#type-aliases) can be
212 find a type (starting with `!` or a built-in type) and falls back to accepting a
217 ### Built-in Type Compatibility
219 LLVM dialect accepts a subset of built-in types that are referred to as _LLVM
220 dialect-compatible types_. The following types are compatible:
222 - Signless integers - `iN` (`IntegerType`).
223 - Floating point types - `bfloat`, `half`, `float`, `double` , `f80`, `f128`
225 - 1D vectors of signless integers or floating point types - `vector<NxT>`
233 Each LLVM IR type corresponds to *exactly one* MLIR type, either built-in or
234 LLVM dialect type. For example, because `i32` is LLVM-compatible, there is no
236 dialect as there is no corresponding built-in type.
240 The following non-parametric types derived from the LLVM IR are available in the
243 - `!llvm.ppc_fp128` (`LLVMPPCFP128Type`) - 128-bit floating-point value (two
245 - `!llvm.token` (`LLVMTokenType`) - a non-inspectable value associated with an
247 - `!llvm.metadata` (`LLVMMetadataType`) - LLVM IR metadata, to be used only if
249 - `!llvm.void` (`LLVMVoidType`) - does not represent any value; can only
258 the element type, which can be either compatible built-in or LLVM dialect types.
264 Pointers are [opaque](https://llvm.org/docs/OpaquePointers.html), i.e., do not
272 llvm-ptr-type ::= `!llvm.ptr` (`<` integer-literal `>`)?
288 llvm-array-type ::= `!llvm.array<` integer-literal `x` type `>`
298 and by an optional "variadic" flag. Unlike built-in `FunctionType`, LLVM dialect
303 llvm-func-type ::= `!llvm.func<` type `(` type-list (`,` `...`)? `)` `>`
314 In the LLVM dialect, functions are not first-class objects and one cannot have a
330 LLVM dialect uses built-in vector types for _fixed_-size vectors of built-in
331 types, and provides additional types for fixed-sized vectors of LLVM dialect
337 llvm-vec-type ::= `!llvm.vec<` (`?` `x`)? integer-literal `x` type `>`
340 Note that the sets of element types supported by built-in and LLVM dialect
341 vector types are mutually exclusive, e.g., the built-in vector type does not
342 accept `!llvm.ptr` and the LLVM dialect fixed-width vector type does not
348 - `bool LLVM::isCompatibleVectorType(Type)` - checks whether a type is a
350 - `Type LLVM::getVectorElementType(Type)` - returns the element type of any
352 - `llvm::ElementCount LLVM::getVectorNumElements(Type)` - returns the number
354 - `Type LLVM::getFixedVectorType(Type, unsigned)` - gets a fixed vector type
356 built-in or an LLVM dialect vector type depending on which one supports the
362 vector<42 x i32> // Vector of 42 32-bit integers.
364 !llvm.vec<? x 4 x i32> // Scalable vector of 32-bit integers with
366 !llvm.array<2 x vector<2 x i32>> // Array of 2 vectors of 2 32-bit integers.
388 returned*. **MLIR does not auto-rename identified structs in case of name
402 thread-safe; however, if a concurrent thread initializes the type before the
408 llvm-ident-struct-type ::= `!llvm.struct<` string-literal, `opaque` `>`
409 | `!llvm.struct<` string-literal, `packed`?
410 `(` type-or-ref-list `)` `>`
411 type-or-ref-list ::= <maybe empty comma-separated list of type-or-ref>
412 type-or-ref ::= <any compatible type with optional !llvm.>
413 | `!llvm.`? `struct<` string-literal `>`
422 llvm-literal-struct-type ::= `!llvm.struct<` `packed`? `(` type-list `)` `>`
423 type-list ::= <maybe empty comma-separated list of types with optional !llvm.>
463 modeled as first-class operations in the LLVM dialect. Target-specific LLVM IR