This is an archive of the discontinued LLVM Phabricator instance.

Differential D94178

[mlir] replace LLVMIntegerType with built-in integer type
ClosedPublic

Authored by ftynse on Jan 6 2021, 7:19 AM.

Details

Reviewers
mehdi_amini
nicolasvasilache
silvas
mravishankar
antiagainst
aartbik
jdoerfert
herhut
Commits
rG2230bf99c712: [mlir] replace LLVMIntegerType with built-in integer type
Summary

The LLVM dialect type system has been closed until now, i.e. did not support
types from other dialects inside containers. While this has had obvious
benefits of deriving from a common base class, it has led to some simple types
being almost identical with the built-in types, namely integer and floating
point types. This in turn has led to a lot of larger-scale complexity: simple
types must still be converted, numerous operations that correspond to LLVM IR
intrinsics are replicated to produce versions operating on either LLVM dialect
or built-in types leading to quasi-duplicate dialects, lowering to the LLVM
dialect is essentially required to be one-shot because of type conversion, etc.
In this light, it is reasonable to trade off some local complexity in the
internal implementation of LLVM dialect types for removing larger-scale system
complexity. Previous commits to the LLVM dialect type system have adapted the
API to support types from other dialects.

Replace LLVMIntegerType with the built-in IntegerType plus additional checks
that such types are signless (these are isolated in a utility function that
replaced isa<LLVMType> and in the parser). Temporarily keep the possibility
to parse !llvm.i32 as a synonym for i32, but add a deprecation notice.

Diff Detail

Event Timeline

ftynse created this revision.Jan 6 2021, 7:19 AM
Herald added a reviewer: mravishankar. · View Herald TranscriptJan 6 2021, 7:19 AM
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added subscribers: mravishankar, teijeong, rdzhabarov and 20 others. · View Herald Transcript
ftynse requested review of this revision.Jan 6 2021, 7:19 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJan 6 2021, 7:19 AM
Herald added a reviewer: herhut. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: sstefan1, stephenneuendorffer. · View Herald Transcript
Harbormaster completed remote builds in B84210: Diff 314890.Jan 6 2021, 7:19 AM
ftynse added a child revision: D94179: [mlir] replace LLVM dialect float types with built-ins.Jan 6 2021, 7:21 AM
antiagainst accepted this revision.Jan 6 2021, 8:20 AM

Fantastic!!

This revision is now accepted and ready to land.Jan 6 2021, 8:20 AM
silvas accepted this revision.Jan 6 2021, 11:25 AM

Awesome! Thank you for pushing this herculean effort!

mehdi_amini accepted this revision.Jan 6 2021, 2:35 PM
mehdi_amini added inline comments.
mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp
423

I'm not sure why we need to maintain this? This seems like an entire mechanical change?

This revision was landed with ongoing or failed builds.Jan 7 2021, 10:48 AM
Closed by commit rG2230bf99c712: [mlir] replace LLVMIntegerType with built-in integer type (authored by ftynse). · Explain Why
This revision was automatically updated to reflect the committed changes.
ftynse added a commit: rG2230bf99c712: [mlir] replace LLVMIntegerType with built-in integer type.
Lewuathe mentioned this in D94651: [mlir] Update doc to omit the usage of LLVMIntegerType.Jan 13 2021, 9:53 PM
ftynse mentioned this in rGed205f63b4a2: [mlir] Update doc to omit the usage of LLVMIntegerType.Jan 14 2021, 12:29 AM

Revision Contents

PathSize
mlir/
docs/
2 lines
Dialects/
12 lines
56 lines
140 lines
Tutorials/
Toy/
26 lines
examples/
toy/
Ch6/
mlir/
12 lines
Ch7/
mlir/
12 lines
include/
mlir/
Conversion/
StandardToLLVM/
18 lines
Dialect/
LLVMIR/
6 lines
28 lines
52 lines
4 lines
integration_test/
Dialect/
LLVMIR/
CPU/
X86/
8 lines
16 lines
62 lines
lib/
Conversion/
AsyncToLLVM/
34 lines
GPUCommon/
18 lines
4 lines
13 lines
GPUToNVVM/
12 lines
GPUToVulkan/
27 lines
SPIRVToLLVM/
2 lines
8 lines
StandardToLLVM/
34 lines
VectorToLLVM/
16 lines
Dialect/
LLVMIR/
IR/
54 lines
50 lines
59 lines
7 lines
8 lines
21 lines
ExecutionEngine/
8 lines
Target/
LLVMIR/
8 lines
14 lines
test/
Conversion/
GPUCommon/
10 lines
76 lines
GPUToNVVM/
70 lines
GPUToROCDL/
58 lines
GPUToVulkan/
40 lines
OpenMPToLLVM/
18 lines
SPIRVToLLVM/
14 lines
222 lines
20 lines
20 lines
10 lines
32 lines
8 lines
4 lines
12 lines
8 lines
40 lines
22 lines
36 lines
StandardToLLVM/
14 lines
4 lines
284 lines
14 lines
220 lines
622 lines
42 lines
VectorToLLVM/
14 lines
378 lines
Dialect/
GPU/
4 lines
LLVMIR/
14 lines
46 lines
78 lines
220 lines
12 lines
74 lines
150 lines
260 lines
2 lines
13 lines
32 lines
Linalg/
62 lines
OpenMP/
12 lines
SPIRV/
IR/
4 lines
Target/
6 lines
16 lines
84 lines
84 lines
24 lines
672 lines
50 lines
60 lines
86 lines
Transforms/
6 lines
lib/
Transforms/
3 lines
mlir-cpu-runner/
2 lines
24 lines

Diff 315183

mlir/docs/ConversionToLLVMDialect.md

Show All 29 Lines
- `f32` converts to `!llvm.float` - `f32` converts to `!llvm.float`
- `f64` converts to `!llvm.double` - `f64` converts to `!llvm.double`
### Index Type ### Index Type
Index type is converted to an LLVM dialect integer type with bitwidth equal to Index type is converted to an LLVM dialect integer type with bitwidth equal to
the bitwidth of the pointer size as specified by the the bitwidth of the pointer size as specified by the
[data layout](Dialects/LLVM.md#data-layout-and-triple) of the closest module. [data layout](Dialects/LLVM.md#data-layout-and-triple) of the closest module.
For example, on x86-64 CPUs it converts to `!llvm.i64`. This behavior can be For example, on x86-64 CPUs it converts to `i64`. This behavior can be
overridden by the type converter configuration, which is often exposed as a pass overridden by the type converter configuration, which is often exposed as a pass
option by conversion passes. option by conversion passes.
### Vector Types ### Vector Types
LLVM IR only supports *one-dimensional* vectors, unlike MLIR where vectors can LLVM IR only supports *one-dimensional* vectors, unlike MLIR where vectors can
be multi-dimensional. Vector types cannot be nested in either IR. In the be multi-dimensional. Vector types cannot be nested in either IR. In the
one-dimensional case, MLIR vectors are converted to LLVM IR vectors of the same one-dimensional case, MLIR vectors are converted to LLVM IR vectors of the same
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

mlir/docs/Dialects/LLVM.md

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
`phi` in LLVM IR. Instead, all terminators can pass values as successor operands `phi` in LLVM IR. Instead, all terminators can pass values as successor operands
as these values will be forwarded as block arguments when the control flow is as these values will be forwarded as block arguments when the control flow is
transferred. transferred.
For example: For example:
```mlir ```mlir
^bb1: ^bb1:
%0 = llvm.addi %arg0, %cst : !llvm.i32 %0 = llvm.addi %arg0, %cst : i32
llvm.br ^bb2[%0: !llvm.i32] llvm.br ^bb2[%0: i32]
// If the control flow comes from ^bb1, %arg1 == %0. // If the control flow comes from ^bb1, %arg1 == %0.
^bb2(%arg1: !llvm.i32) ^bb2(%arg1: i32)
// ... // ...
``` ```
is equivalent to LLVM IR is equivalent to LLVM IR
```llvm ```llvm
%0: %0:
%1 = add i32 %arg0, %cst %1 = add i32 %arg0, %cst
br %3 br %3
%3: %3:
%arg1 = phi [%1, %0], //... %arg1 = phi [%1, %0], //...
``` ```
Since there is no need to use the block identifier to differentiate the source Since there is no need to use the block identifier to differentiate the source
of different values, the LLVM dialect supports terminators that transfer the of different values, the LLVM dialect supports terminators that transfer the
control flow to the same block with different arguments. For example: control flow to the same block with different arguments. For example:
```mlir ```mlir
^bb1: ^bb1:
llvm.cond_br %cond, ^bb2[%0: !llvm.i32], ^bb2[%1: !llvm.i32] llvm.cond_br %cond, ^bb2[%0: i32], ^bb2[%1: i32]
^bb2(%arg0: !llvm.i32): ^bb2(%arg0: i32):
// ... // ...
``` ```
### Context-Level Values ### Context-Level Values
Some value kinds in LLVM IR, such as constants and undefs, are uniqued in Some value kinds in LLVM IR, such as constants and undefs, are uniqued in
context and used directly in relevant operations. MLIR does not support such context and used directly in relevant operations. MLIR does not support such
values for thread-safety and concept parsimony reasons. Instead, regular values values for thread-safety and concept parsimony reasons. Instead, regular values
Show All 14 Lines
// Null pointer to i8. // Null pointer to i8.
%1 = llvm.mlir.null : !llvm.ptr<i8> %1 = llvm.mlir.null : !llvm.ptr<i8>
// Null pointer to a function with signature void(). // Null pointer to a function with signature void().
%2 = llvm.mlir.null : !llvm.ptr<func<void ()>> %2 = llvm.mlir.null : !llvm.ptr<func<void ()>>
// Constant 42 as i32. // Constant 42 as i32.
%3 = llvm.mlir.constant(42 : i32) : !llvm.i32 %3 = llvm.mlir.constant(42 : i32) : i32
// Splat dense vector constant. // Splat dense vector constant.
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float> %3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float>
``` ```
Note that constants use built-in types within the initializer definition: MLIR Note that constants use built-in types within the initializer definition: MLIR
attributes are typed and the attributes used for constants require a built-in attributes are typed and the attributes used for constants require a built-in
type. type.
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

mlir/docs/LLVMDialectMemRefConvention.md

Show All 25 Linesfunc @bar() {
%1 = constant 17 : i64 %1 = constant 17 : i64
%2:2 = call @foo(%0, %1) : (i32, i64) -> (i32, i64) %2:2 = call @foo(%0, %1) : (i32, i64) -> (i32, i64)
"use_i32"(%2#0) : (i32) -> () "use_i32"(%2#0) : (i32) -> ()
"use_i64"(%2#1) : (i64) -> () "use_i64"(%2#1) : (i64) -> ()
} }
// is transformed into // is transformed into
llvm.func @foo(%arg0: !llvm.i32, %arg1: !llvm.i64) -> !llvm.struct<(i32, i64)> { llvm.func @foo(%arg0: i32, %arg1: i64) -> !llvm.struct<(i32, i64)> {
// insert the vales into a structure // insert the vales into a structure
%0 = llvm.mlir.undef : !llvm.struct<(i32, i64)> %0 = llvm.mlir.undef : !llvm.struct<(i32, i64)>
%1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(i32, i64)> %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(i32, i64)>
%2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(i32, i64)> %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(i32, i64)>
// return the structure value // return the structure value
llvm.return %2 : !llvm.struct<(i32, i64)> llvm.return %2 : !llvm.struct<(i32, i64)>
} }
llvm.func @bar() { llvm.func @bar() {
%0 = llvm.mlir.constant(42 : i32) : !llvm.i32 %0 = llvm.mlir.constant(42 : i32) : i32
%1 = llvm.mlir.constant(17) : !llvm.i64 %1 = llvm.mlir.constant(17) : i64
// call and extract the values from the structure // call and extract the values from the structure
%2 = llvm.call @bar(%0, %1) %2 = llvm.call @bar(%0, %1)
: (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i64)> : (i32, i32) -> !llvm.struct<(i32, i64)>
%3 = llvm.extractvalue %2[0] : !llvm.struct<(i32, i64)> %3 = llvm.extractvalue %2[0] : !llvm.struct<(i32, i64)>
%4 = llvm.extractvalue %2[1] : !llvm.struct<(i32, i64)> %4 = llvm.extractvalue %2[1] : !llvm.struct<(i32, i64)>
// use as before // use as before
"use_i32"(%3) : (!llvm.i32) -> () "use_i32"(%3) : (i32) -> ()
"use_i64"(%4) : (!llvm.i64) -> () "use_i64"(%4) : (i64) -> ()
} }
``` ```
## Calling Convention for Ranked `memref` ## Calling Convention for Ranked `memref`
Function _arguments_ of `memref` type, ranked or unranked, are _expanded_ into a Function _arguments_ of `memref` type, ranked or unranked, are _expanded_ into a
list of arguments of non-aggregate types that the memref descriptor defined list of arguments of non-aggregate types that the memref descriptor defined
above comprises. That is, the outer struct type and the inner array types are above comprises. That is, the outer struct type and the inner array types are
Show All 18 Lines
// Gets converted to the following // Gets converted to the following
// (using type alias for brevity): // (using type alias for brevity):
!llvm.memref_1d = type !llvm.struct<(ptr<float>, ptr<float>, i64, !llvm.memref_1d = type !llvm.struct<(ptr<float>, ptr<float>, i64,
array<1xi64>, array<1xi64>)> array<1xi64>, array<1xi64>)>
llvm.func @foo(%arg0: !llvm.ptr<float>, // Allocated pointer. llvm.func @foo(%arg0: !llvm.ptr<float>, // Allocated pointer.
%arg1: !llvm.ptr<float>, // Aligned pointer. %arg1: !llvm.ptr<float>, // Aligned pointer.
%arg2: !llvm.i64, // Offset. %arg2: i64, // Offset.
%arg3: !llvm.i64, // Size in dim 0. %arg3: i64, // Size in dim 0.
%arg4: !llvm.i64) { // Stride in dim 0. %arg4: i64) { // Stride in dim 0.
// Populate memref descriptor structure. // Populate memref descriptor structure.
%0 = llvm.mlir.undef : %0 = llvm.mlir.undef :
%1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_1d %1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_1d
%2 = llvm.insertvalue %arg1, %1[1] : !llvm.memref_1d %2 = llvm.insertvalue %arg1, %1[1] : !llvm.memref_1d
%3 = llvm.insertvalue %arg2, %2[2] : !llvm.memref_1d %3 = llvm.insertvalue %arg2, %2[2] : !llvm.memref_1d
%4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.memref_1d %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.memref_1d
%5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm.memref_1d %5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm.memref_1d
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
```mlir ```mlir
llvm.func @foo(%arg0: memref<*xf32>) -> () { llvm.func @foo(%arg0: memref<*xf32>) -> () {
"use"(%arg0) : (memref<*xf32>) -> () "use"(%arg0) : (memref<*xf32>) -> ()
return return
} }
// Gets converted to the following. // Gets converted to the following.
llvm.func @foo(%arg0: !llvm.i64 // Rank. llvm.func @foo(%arg0: i64 // Rank.
%arg1: !llvm.ptr<i8>) { // Type-erased pointer to descriptor. %arg1: !llvm.ptr<i8>) { // Type-erased pointer to descriptor.
// Pack the unranked memref descriptor. // Pack the unranked memref descriptor.
%0 = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)> %0 = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
%1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(i64, ptr<i8>)> %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(i64, ptr<i8>)>
%2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(i64, ptr<i8>)> %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(i64, ptr<i8>)>
"use"(%2) : (!llvm.struct<(i64, ptr<i8>)>) -> () "use"(%2) : (!llvm.struct<(i64, ptr<i8>)>) -> ()
llvm.return llvm.return
Show All 12 Lines
llvm.func @bar() { llvm.func @bar() {
%0 = "get"() : () -> (!llvm.struct<(i64, ptr<i8>)>) %0 = "get"() : () -> (!llvm.struct<(i64, ptr<i8>)>)
// Unpack the memref descriptor. // Unpack the memref descriptor.
%1 = llvm.extractvalue %0[0] : !llvm.struct<(i64, ptr<i8>)> %1 = llvm.extractvalue %0[0] : !llvm.struct<(i64, ptr<i8>)>
%2 = llvm.extractvalue %0[1] : !llvm.struct<(i64, ptr<i8>)> %2 = llvm.extractvalue %0[1] : !llvm.struct<(i64, ptr<i8>)>
// Pass individual values to the callee. // Pass individual values to the callee.
llvm.call @foo(%1, %2) : (!llvm.i64, !llvm.ptr<i8>) llvm.call @foo(%1, %2) : (i64, !llvm.ptr<i8>)
llvm.return llvm.return
} }
``` ```
**Lifetime.** The second element of the unranked memref descriptor points to **Lifetime.** The second element of the unranked memref descriptor points to
some memory in which the ranked memref descriptor is stored. By convention, this some memory in which the ranked memref descriptor is stored. By convention, this
memory is allocated on stack and has the lifetime of the function. (*Note:* due memory is allocated on stack and has the lifetime of the function. (*Note:* due
to function-length lifetime, creation of multiple unranked memref descriptors, to function-length lifetime, creation of multiple unranked memref descriptors,
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
// Gets converted into the following // Gets converted into the following
// (using type alias for brevity): // (using type alias for brevity):
!llvm.memref_2d = type !llvm.struct<(ptr<float>, ptr<float>, i64, !llvm.memref_2d = type !llvm.struct<(ptr<float>, ptr<float>, i64,
array<2xi64>, array<2xi64>)> array<2xi64>, array<2xi64>)>
// Function with unpacked arguments. // Function with unpacked arguments.
llvm.func @qux(%arg0: !llvm.ptr<float>, %arg1: !llvm.ptr<float>, llvm.func @qux(%arg0: !llvm.ptr<float>, %arg1: !llvm.ptr<float>,
%arg2: !llvm.i64, %arg3: !llvm.i64, %arg4: !llvm.i64, %arg2: i64, %arg3: i64, %arg4: i64,
%arg5: !llvm.i64, %arg6: !llvm.i64) { %arg5: i64, %arg6: i64) {
// Populate memref descriptor (as per calling convention). // Populate memref descriptor (as per calling convention).
%0 = llvm.mlir.undef : !llvm.memref_2d %0 = llvm.mlir.undef : !llvm.memref_2d
%1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_2d %1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_2d
%2 = llvm.insertvalue %arg1, %1[1] : !llvm.memref_2d %2 = llvm.insertvalue %arg1, %1[1] : !llvm.memref_2d
%3 = llvm.insertvalue %arg2, %2[2] : !llvm.memref_2d %3 = llvm.insertvalue %arg2, %2[2] : !llvm.memref_2d
%4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.memref_2d %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.memref_2d
%5 = llvm.insertvalue %arg5, %4[4, 0] : !llvm.memref_2d %5 = llvm.insertvalue %arg5, %4[4, 0] : !llvm.memref_2d
%6 = llvm.insertvalue %arg4, %5[3, 1] : !llvm.memref_2d %6 = llvm.insertvalue %arg4, %5[3, 1] : !llvm.memref_2d
%7 = llvm.insertvalue %arg6, %6[4, 1] : !llvm.memref_2d %7 = llvm.insertvalue %arg6, %6[4, 1] : !llvm.memref_2d
// Store the descriptor in a stack-allocated space. // Store the descriptor in a stack-allocated space.
%8 = llvm.mlir.constant(1 : index) : !llvm.i64 %8 = llvm.mlir.constant(1 : index) : i64
%9 = llvm.alloca %8 x !llvm.memref_2d %9 = llvm.alloca %8 x !llvm.memref_2d
: (!llvm.i64) -> !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, : (i64) -> !llvm.ptr<struct<(ptr<float>, ptr<float>, i64,
array<2xi64>, array<2xi64>)>> array<2xi64>, array<2xi64>)>>
llvm.store %7, %9 : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, llvm.store %7, %9 : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64,
array<2xi64>, array<2xi64>)>> array<2xi64>, array<2xi64>)>>
// Call the interface function. // Call the interface function.
llvm.call @_mlir_ciface_qux(%9) llvm.call @_mlir_ciface_qux(%9)
: (!llvm.ptr<struct<(ptr<float>, ptr<float>, i64, : (!llvm.ptr<struct<(ptr<float>, ptr<float>, i64,
array<2xi64>, array<2xi64>)>>) -> () array<2xi64>, array<2xi64>)>>) -> ()
Show All 16 Lines
// (using type alias for brevity): // (using type alias for brevity):
!llvm.memref_2d = type !llvm.struct<(ptr<float>, ptr<float>, i64, !llvm.memref_2d = type !llvm.struct<(ptr<float>, ptr<float>, i64,
array<2xi64>, array<2xi64>)> array<2xi64>, array<2xi64>)>
!llvm.memref_2d_ptr = type !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, !llvm.memref_2d_ptr = type !llvm.ptr<struct<(ptr<float>, ptr<float>, i64,
array<2xi64>, array<2xi64>)>> array<2xi64>, array<2xi64>)>>
// Function with unpacked arguments. // Function with unpacked arguments.
llvm.func @foo(%arg0: !llvm.ptr<float>, %arg1: !llvm.ptr<float>, llvm.func @foo(%arg0: !llvm.ptr<float>, %arg1: !llvm.ptr<float>,
%arg2: !llvm.i64, %arg3: !llvm.i64, %arg4: !llvm.i64, %arg2: i64, %arg3: i64, %arg4: i64,
%arg5: !llvm.i64, %arg6: !llvm.i64) { %arg5: i64, %arg6: i64) {
llvm.return llvm.return
} }
// Interface function callable from C. // Interface function callable from C.
llvm.func @_mlir_ciface_foo(%arg0: !llvm.memref_2d_ptr) { llvm.func @_mlir_ciface_foo(%arg0: !llvm.memref_2d_ptr) {
// Load the descriptor. // Load the descriptor.
%0 = llvm.load %arg0 : !llvm.memref_2d_ptr %0 = llvm.load %arg0 : !llvm.memref_2d_ptr
// Unpack the descriptor as per calling convention. // Unpack the descriptor as per calling convention.
%1 = llvm.extractvalue %0[0] : !llvm.memref_2d %1 = llvm.extractvalue %0[0] : !llvm.memref_2d
%2 = llvm.extractvalue %0[1] : !llvm.memref_2d %2 = llvm.extractvalue %0[1] : !llvm.memref_2d
%3 = llvm.extractvalue %0[2] : !llvm.memref_2d %3 = llvm.extractvalue %0[2] : !llvm.memref_2d
%4 = llvm.extractvalue %0[3, 0] : !llvm.memref_2d %4 = llvm.extractvalue %0[3, 0] : !llvm.memref_2d
%5 = llvm.extractvalue %0[3, 1] : !llvm.memref_2d %5 = llvm.extractvalue %0[3, 1] : !llvm.memref_2d
%6 = llvm.extractvalue %0[4, 0] : !llvm.memref_2d %6 = llvm.extractvalue %0[4, 0] : !llvm.memref_2d
%7 = llvm.extractvalue %0[4, 1] : !llvm.memref_2d %7 = llvm.extractvalue %0[4, 1] : !llvm.memref_2d
llvm.call @foo(%1, %2, %3, %4, %5, %6, %7) llvm.call @foo(%1, %2, %3, %4, %5, %6, %7)
: (!llvm.ptr<float>, !llvm.ptr<float>, !llvm.i64, !llvm.i64, !llvm.i64, : (!llvm.ptr<float>, !llvm.ptr<float>, i64, i64, i64,
!llvm.i64, !llvm.i64) -> () i64, i64) -> ()
llvm.return llvm.return
} }
``` ```
Rationale: Introducing auxiliary functions for C-compatible interfaces is Rationale: Introducing auxiliary functions for C-compatible interfaces is
preferred to modifying the calling convention since it will minimize the effect preferred to modifying the calling convention since it will minimize the effect
of C compatibility on intra-module calls or calls between MLIR-generated of C compatibility on intra-module calls or calls between MLIR-generated
functions. In particular, when calling external functions from an MLIR module in functions. In particular, when calling external functions from an MLIR module in
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
is transformed into the equivalent of the following code: is transformed into the equivalent of the following code:
```mlir ```mlir
// Compute the linearized index from strides. // Compute the linearized index from strides.
// When strides or, in absence of explicit strides, the corresponding sizes are // When strides or, in absence of explicit strides, the corresponding sizes are
// dynamic, extract the stride value from the descriptor. // dynamic, extract the stride value from the descriptor.
%stride1 = llvm.extractvalue[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, %stride1 = llvm.extractvalue[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64,
array<4xi64>, array<4xi64>)> array<4xi64>, array<4xi64>)>
%addr1 = muli %stride1, %1 : !llvm.i64 %addr1 = muli %stride1, %1 : i64
// When the stride or, in absence of explicit strides, the trailing sizes are // When the stride or, in absence of explicit strides, the trailing sizes are
// known statically, this value is used as a constant. The natural value of // known statically, this value is used as a constant. The natural value of
// strides is the product of all sizes following the current dimension. // strides is the product of all sizes following the current dimension.
%stride2 = llvm.mlir.constant(32 : index) : !llvm.i64 %stride2 = llvm.mlir.constant(32 : index) : i64
%addr2 = muli %stride2, %2 : !llvm.i64 %addr2 = muli %stride2, %2 : i64
%addr3 = addi %addr1, %addr2 : !llvm.i64 %addr3 = addi %addr1, %addr2 : i64
%stride3 = llvm.mlir.constant(8 : index) : !llvm.i64 %stride3 = llvm.mlir.constant(8 : index) : i64
%addr4 = muli %stride3, %3 : !llvm.i64 %addr4 = muli %stride3, %3 : i64
%addr5 = addi %addr3, %addr4 : !llvm.i64 %addr5 = addi %addr3, %addr4 : i64
// Multiplication with the known unit stride can be omitted. // Multiplication with the known unit stride can be omitted.
%addr6 = addi %addr5, %4 : !llvm.i64 %addr6 = addi %addr5, %4 : i64
// If the linear offset is known to be zero, it can also be omitted. If it is // If the linear offset is known to be zero, it can also be omitted. If it is
// dynamic, it is extracted from the descriptor. // dynamic, it is extracted from the descriptor.
%offset = llvm.extractvalue[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, %offset = llvm.extractvalue[2] : !llvm.struct<(ptr<float>, ptr<float>, i64,
array<4xi64>, array<4xi64>)> array<4xi64>, array<4xi64>)>
%addr7 = addi %addr6, %offset : !llvm.i64 %addr7 = addi %addr6, %offset : i64
// All accesses are based on the aligned pointer. // All accesses are based on the aligned pointer.
%aligned = llvm.extractvalue[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, %aligned = llvm.extractvalue[1] : !llvm.struct<(ptr<float>, ptr<float>, i64,
array<4xi64>, array<4xi64>)> array<4xi64>, array<4xi64>)>
// Get the address of the data pointer. // Get the address of the data pointer.
%ptr = llvm.getelementptr %aligned[%addr8] %ptr = llvm.getelementptr %aligned[%addr8]
: !llvm.struct<(ptr<float>, ptr<float>, i64, array<4xi64>, array<4xi64>)> : !llvm.struct<(ptr<float>, ptr<float>, i64, array<4xi64>, array<4xi64>)>
Show All 11 Lines

mlir/docs/SPIRVToLLVMDialectConversion.md

Show First 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
`spv.BitCount` | `llvm.intr.ctpop` `spv.BitCount` | `llvm.intr.ctpop`
`spv.BitReverse` | `llvm.intr.bitreverse` `spv.BitReverse` | `llvm.intr.bitreverse`
#### `spv.Not` #### `spv.Not`
`spv.Not` is modelled with a `xor` operation with a mask with all bits set. `spv.Not` is modelled with a `xor` operation with a mask with all bits set.
```mlir ```mlir
%mask = llvm.mlir.constant(-1 : i32) : !llvm.i32 %mask = llvm.mlir.constant(-1 : i32) : i32
%0 = spv.Not %op : i32 => %0 = llvm.xor %op, %mask : !llvm.i32 %0 = spv.Not %op : i32 => %0 = llvm.xor %op, %mask : i32
``` ```
#### Bitfield ops #### Bitfield ops
SPIR-V dialect has three bitfield ops: `spv.BitFieldInsert`, SPIR-V dialect has three bitfield ops: `spv.BitFieldInsert`,
`spv.BitFieldSExtract` and `spv.BitFieldUExtract`. This section will first `spv.BitFieldSExtract` and `spv.BitFieldUExtract`. This section will first
outline the general design of conversion patterns for this ops, and then outline the general design of conversion patterns for this ops, and then
describe each of them. describe each of them.
Show All 12 Lines* `offset` and `count` are always scalar. This means that we can have the
To be able to proceed with conversion algorithms described below, all To be able to proceed with conversion algorithms described below, all
operands have to be of the same type and bitwidth. This requires operands have to be of the same type and bitwidth. This requires
broadcasting of `offset` and `count` to vectors, for example for the case broadcasting of `offset` and `count` to vectors, for example for the case
above it gives: above it gives:
```mlir ```mlir
// Broadcasting offset // Broadcasting offset
%offset0 = llvm.mlir.undef : !llvm.vec<2 x i8> %offset0 = llvm.mlir.undef : !llvm.vec<2 x i8>
%zero = llvm.mlir.constant(0 : i32) : !llvm.i32 %zero = llvm.mlir.constant(0 : i32) : i32
%offset1 = llvm.insertelement %offset, %offset0[%zero : !llvm.i32] : !llvm.vec<2 x i8> %offset1 = llvm.insertelement %offset, %offset0[%zero : i32] : !llvm.vec<2 x i8>
%one = llvm.mlir.constant(1 : i32) : !llvm.i32 %one = llvm.mlir.constant(1 : i32) : i32
%vec_offset = llvm.insertelement %offset, %offset1[%one : !llvm.i32] : !llvm.vec<2 x i8> %vec_offset = llvm.insertelement %offset, %offset1[%one : i32] : !llvm.vec<2 x i8>
// Broadcasting count // Broadcasting count
// ... // ...
``` ```
* `offset` and `count` may have different bitwidths from `base`. In this case, * `offset` and `count` may have different bitwidths from `base`. In this case,
both of these operands have to be zero extended (since they are treated as both of these operands have to be zero extended (since they are treated as
unsigned by the specification) or truncated. For the above example it would unsigned by the specification) or truncated. For the above example it would
be: be:
```mlir ```mlir
// Zero extending offset after broadcasting // Zero extending offset after broadcasting
%res_offset = llvm.zext %vec_offset: !llvm.vec<2 x i8> to !llvm.vec<2 x i32> %res_offset = llvm.zext %vec_offset: !llvm.vec<2 x i8> to !llvm.vec<2 x i32>
``` ```
Also, note that if the bitwidth of `offset` or `count` is greater than the Also, note that if the bitwidth of `offset` or `count` is greater than the
bitwidth of `base`, truncation is still permitted. This is because the ops have a bitwidth of `base`, truncation is still permitted. This is because the ops
defined behaviour with `offset` and `count` being less than the size of have a defined behaviour with `offset` and `count` being less than the size
`base`. It creates a natural upper bound on what values `offset` and `count` of `base`. It creates a natural upper bound on what values `offset` and
can take, which is 64. This can be expressed in less than 8 bits. `count` can take, which is 64. This can be expressed in less than 8 bits.
Now, having these two cases in mind, we can proceed with conversion for the ops Now, having these two cases in mind, we can proceed with conversion for the ops
and their operands. and their operands.
##### `spv.BitFieldInsert` ##### `spv.BitFieldInsert`
This operation is implemented as a series of LLVM Dialect operations. First step This operation is implemented as a series of LLVM Dialect operations. First step
would be to create a mask with bits set outside would be to create a mask with bits set outside
[`offset`, `offset` + `count` - 1]. Then, unchanged bits are extracted from [`offset`, `offset` + `count` - 1]. Then, unchanged bits are extracted from
`base` that are outside of [`offset`, `offset` + `count` - 1]. The result is `base` that are outside of [`offset`, `offset` + `count` - 1]. The result is
`or`ed with shifted `insert`. `or`ed with shifted `insert`.
```mlir ```mlir
// Create mask // Create mask
// %minus_one = llvm.mlir.constant(-1 : i32) : !llvm.i32 // %minus_one = llvm.mlir.constant(-1 : i32) : i32
// %t0 = llvm.shl %minus_one, %count : !llvm.i32 // %t0 = llvm.shl %minus_one, %count : i32
// %t1 = llvm.xor %t0, %minus_one : !llvm.i32 // %t1 = llvm.xor %t0, %minus_one : i32
// %t2 = llvm.shl %t1, %offset : !llvm.i32 // %t2 = llvm.shl %t1, %offset : i32
// %mask = llvm.xor %t2, %minus_one : !llvm.i32 // %mask = llvm.xor %t2, %minus_one : i32
// Extract unchanged bits from the Base // Extract unchanged bits from the Base
// %new_base = llvm.and %base, %mask : !llvm.i32 // %new_base = llvm.and %base, %mask : i32
// Insert new bits // Insert new bits
// %sh_insert = llvm.shl %insert, %offset : !llvm.i32 // %sh_insert = llvm.shl %insert, %offset : i32
// %res = llvm.or %new_base, %sh_insert : !llvm.i32 // %res = llvm.or %new_base, %sh_insert : i32
%res = spv.BitFieldInsert %base, %insert, %offset, %count : i32, i32, i32 %res = spv.BitFieldInsert %base, %insert, %offset, %count : i32, i32, i32
``` ```
##### `spv.BitFieldSExtract` ##### `spv.BitFieldSExtract`
To implement `spv.BitFieldSExtract`, `base` is shifted left by [sizeof(`base`) - To implement `spv.BitFieldSExtract`, `base` is shifted left by [sizeof(`base`) -
(`count` + `offset`)], so that the bit at `offset` + `count` - 1 is the most (`count` + `offset`)], so that the bit at `offset` + `count` - 1 is the most
significant bit. After, the result is shifted right, filling the bits with the significant bit. After, the result is shifted right, filling the bits with the
sign bit. sign bit.
```mlir ```mlir
// Calculate the amount to shift left. // Calculate the amount to shift left.
// %size = llvm.mlir.constant(32 : i32) : !llvm.i32 // %size = llvm.mlir.constant(32 : i32) : i32
// %t0 = llvm.add %count, %offset : !llvm.i32 // %t0 = llvm.add %count, %offset : i32
// %t1 = llvm.sub %size, %t0 : !llvm.i32 // %t1 = llvm.sub %size, %t0 : i32
// Shift left and then right to extract the bits // Shift left and then right to extract the bits
// %sh_left = llvm.shl %base, %t1 : !llvm.i32 // %sh_left = llvm.shl %base, %t1 : i32
// %t2 = llvm.add %offset, %t1 : !llvm.i32 // %t2 = llvm.add %offset, %t1 : i32
// %res = llvm.ashr %sh_left, %t2 : !llvm.i32 // %res = llvm.ashr %sh_left, %t2 : i32
%res = spv.BitFieldSExtract %base, %offset, %count : i32, i32, i32 %res = spv.BitFieldSExtract %base, %offset, %count : i32, i32, i32
``` ```
##### `spv.BitFieldUExtract` ##### `spv.BitFieldUExtract`
For this op a similar pattern as for `spv.BitFieldInsert` is used. First, a mask For this op a similar pattern as for `spv.BitFieldInsert` is used. First, a mask
with bits set at [0, `count` - 1] is created. Then `base` is shifted by `offset` with bits set at [0, `count` - 1] is created. Then `base` is shifted by `offset`
and the mask is applied. and the mask is applied.
```mlir ```mlir
// Create a mask // Create a mask
// %minus_one = llvm.mlir.constant(-1 : i32) : !llvm.i32 // %minus_one = llvm.mlir.constant(-1 : i32) : i32
// %t0 = llvm.shl %minus_one, %count : !llvm.i32 // %t0 = llvm.shl %minus_one, %count : i32
// mask = llvm.xor %t0, %minus_one : !llvm.i32 // mask = llvm.xor %t0, %minus_one : i32
// Shift Base and apply mask // Shift Base and apply mask
// %sh_base = llvm.lshr %base, %offset : !llvm.i32 // %sh_base = llvm.lshr %base, %offset : i32
// %res = llvm.and %sh_base, %mask : !llvm.i32 // %res = llvm.and %sh_base, %mask : i32
%res = spv.BitFieldUExtract %base, %offset, %count : i32, i32, i32 %res = spv.BitFieldUExtract %base, %offset, %count : i32, i32, i32
``` ```
### Cast ops ### Cast ops
#### Direct conversions #### Direct conversions
SPIR-V Dialect op | LLVM Dialect op SPIR-V Dialect op | LLVM Dialect op
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
non-vector | `spv.CompositeExtract` | `llvm.extractvalue` non-vector | `spv.CompositeExtract` | `llvm.extractvalue`
non-vector | `spv.CompositeInsert` | `llvm.insertvalue` non-vector | `spv.CompositeInsert` | `llvm.insertvalue`
### `spv.EntryPoint` and `spv.ExecutionMode` ### `spv.EntryPoint` and `spv.ExecutionMode`
First of all, it is important to note that there is no direct representation of First of all, it is important to note that there is no direct representation of
entry points in LLVM. At the moment, we use the following approach: entry points in LLVM. At the moment, we use the following approach:
* `spv.EntryPoint` is simply removed. * `spv.EntryPoint` is simply removed.
* In contrast, `spv.ExecutionMode` may contain important information about the * In contrast, `spv.ExecutionMode` may contain important information about the
entry point. For example, `LocalSize` provides information about the entry point. For example, `LocalSize` provides information about the
work-group size that can be reused. work-group size that can be reused.
In order to preserve this information, `spv.ExecutionMode` is converted to In order to preserve this information, `spv.ExecutionMode` is converted to a
a struct global variable that stores the execution mode id and any variables struct global variable that stores the execution mode id and any variables
associated with it. In C, the struct has the structure shown below. associated with it. In C, the struct has the structure shown below.
```C ```C
// No values are associated // There are values that are associated // No values are associated // There are values that are associated
// with this entry point. // with this entry point. // with this entry point. // with this entry point.
struct { struct { struct { struct {
int32_t executionMode; int32_t executionMode; int32_t executionMode; int32_t executionMode;
}; int32_t values[]; }; int32_t values[];
}; };
``` ```
```mlir ```mlir
// spv.ExecutionMode @empty "ContractionOff" // spv.ExecutionMode @empty "ContractionOff"
llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> { llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> {
%0 = llvm.mlir.undef : !llvm.struct<(i32)> %0 = llvm.mlir.undef : !llvm.struct<(i32)>
%1 = llvm.mlir.constant(31 : i32) : !llvm.i32 %1 = llvm.mlir.constant(31 : i32) : i32
%ret = llvm.insertvalue %1, %0[0 : i32] : !llvm.struct<(i32)> %ret = llvm.insertvalue %1, %0[0 : i32] : !llvm.struct<(i32)>
llvm.return %ret : !llvm.struct<(i32)> llvm.return %ret : !llvm.struct<(i32)>
} }
``` ```
### Logical ops ### Logical ops
Logical ops follow a similar pattern as bitwise ops, with the difference that Logical ops follow a similar pattern as bitwise ops, with the difference that
they operate on `i1` or vector of `i1` values. The following mapping is used to they operate on `i1` or vector of `i1` values. The following mapping is used to
emulate SPIR-V ops behaviour: emulate SPIR-V ops behaviour:
SPIR-V Dialect op | LLVM Dialect op SPIR-V Dialect op | LLVM Dialect op
:-----------------------------------: | :-----------------------------------: :-----------------------------------: | :-----------------------------------:
`spv.LogicalAnd` | `llvm.and` `spv.LogicalAnd` | `llvm.and`
`spv.LogicalOr` | `llvm.or` `spv.LogicalOr` | `llvm.or`
`spv.LogicalEqual` | `llvm.icmp "eq"` `spv.LogicalEqual` | `llvm.icmp "eq"`
`spv.LogicalNotEqual` | `llvm.icmp "ne"` `spv.LogicalNotEqual` | `llvm.icmp "ne"`
`spv.LogicalNot` has the same conversion pattern as bitwise `spv.Not`. It is `spv.LogicalNot` has the same conversion pattern as bitwise `spv.Not`. It is
modelled with `xor` operation with a mask with all bits set. modelled with `xor` operation with a mask with all bits set.
```mlir ```mlir
%mask = llvm.mlir.constant(-1 : i1) : !llvm.i1 %mask = llvm.mlir.constant(-1 : i1) : i1
%0 = spv.LogicalNot %op : i1 => %0 = llvm.xor %op, %mask : !llvm.i1 %0 = spv.LogicalNot %op : i1 => %0 = llvm.xor %op, %mask : i1
``` ```
### Memory ops ### Memory ops
This section describes the conversion patterns for SPIR-V dialect operations This section describes the conversion patterns for SPIR-V dialect operations
that concern memory. that concern memory.
#### `spv.AccessChain` #### `spv.AccessChain`
`spv.AccessChain` is mapped to `llvm.getelementptr` op. In order to create a `spv.AccessChain` is mapped to `llvm.getelementptr` op. In order to create a
valid LLVM op, we also add a 0 index to the `spv.AccessChain`'s indices list in valid LLVM op, we also add a 0 index to the `spv.AccessChain`'s indices list in
order to go through the pointer. order to go through the pointer.
```mlir ```mlir
// Access the 1st element of the array // Access the 1st element of the array
%i = spv.constant 1: i32 %i = spv.constant 1: i32
%var = spv.Variable : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function> %var = spv.Variable : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function>
%el = spv.AccessChain %var[%i, %i] : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function>, i32, i32 %el = spv.AccessChain %var[%i, %i] : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function>, i32, i32
// Corresponding LLVM dialect code // Corresponding LLVM dialect code
%i = ... %i = ...
%var = ... %var = ...
%0 = llvm.mlir.constant(0 : i32) : !llvm.i32 %0 = llvm.mlir.constant(0 : i32) : i32
%el = llvm.getelementptr %var[%0, %i, %i] : (!llvm.ptr<struct<packed (float, array<4 x float>)>>, !llvm.i32, !llvm.i32, !llvm.i32) %el = llvm.getelementptr %var[%0, %i, %i] : (!llvm.ptr<struct<packed (float, array<4 x float>)>>, i32, i32, i32)
``` ```
#### `spv.Load` and `spv.Store` #### `spv.Load` and `spv.Store`
These ops are converted to their LLVM counterparts: `llvm.load` and These ops are converted to their LLVM counterparts: `llvm.load` and
`llvm.store`. If the op has a memory access attribute, then there are the `llvm.store`. If the op has a memory access attribute, then there are the
following cases, based on the value of the attribute: following cases, based on the value of the attribute:
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
`spv.Variable` is modelled as `llvm.alloca` op. If initialized, an additional `spv.Variable` is modelled as `llvm.alloca` op. If initialized, an additional
store instruction is used. Note that there is no initialization for arrays and store instruction is used. Note that there is no initialization for arrays and
structs since constants of these types are not supported in LLVM dialect (TODO). structs since constants of these types are not supported in LLVM dialect (TODO).
Also, at the moment initialization is only possible via `spv.constant`. Also, at the moment initialization is only possible via `spv.constant`.
```mlir ```mlir
// Conversion of VariableOp without initialization // Conversion of VariableOp without initialization
%size = llvm.mlir.constant(1 : i32) : !llvm.i32 %size = llvm.mlir.constant(1 : i32) : i32
%res = spv.Variable : !spv.ptr<vector<3xf32>, Function> => %res = llvm.alloca %size x !llvm.vec<3 x float> : (!llvm.i32) -> !llvm.ptr<vec<3 x float>> %res = spv.Variable : !spv.ptr<vector<3xf32>, Function> => %res = llvm.alloca %size x !llvm.vec<3 x float> : (i32) -> !llvm.ptr<vec<3 x float>>
// Conversion of VariableOp with initialization // Conversion of VariableOp with initialization
%c = llvm.mlir.constant(0 : i64) : !llvm.i64 %c = llvm.mlir.constant(0 : i64) : i64
%c = spv.constant 0 : i64 %size = llvm.mlir.constant(1 : i32) : !llvm.i32 %c = spv.constant 0 : i64 %size = llvm.mlir.constant(1 : i32) : i32
%res = spv.Variable init(%c) : !spv.ptr<i64, Function> => %res = llvm.alloca %[[SIZE]] x !llvm.i64 : (!llvm.i32) -> !llvm.ptr<i64> %res = spv.Variable init(%c) : !spv.ptr<i64, Function> => %res = llvm.alloca %[[SIZE]] x i64 : (i32) -> !llvm.ptr<i64>
llvm.store %c, %res : !llvm.ptr<i64> llvm.store %c, %res : !llvm.ptr<i64>
``` ```
Note that simple conversion to `alloca` may not be sufficient if the code has Note that simple conversion to `alloca` may not be sufficient if the code has
some scoping. For example, if converting ops executed in a loop into `alloca`s, some scoping. For example, if converting ops executed in a loop into `alloca`s,
a stack overflow may occur. For this case, `stacksave`/`stackrestore` pair can a stack overflow may occur. For this case, `stacksave`/`stackrestore` pair can
be used (TODO). be used (TODO).
Show All 21 Lines
* if `base` has a greater bit width than `shift`, shift is sign or zero * if `base` has a greater bit width than `shift`, shift is sign or zero
extended first. Then the extended value is passed to the shift. extended first. Then the extended value is passed to the shift.
* otherwise, the conversion is considered to be illegal. * otherwise, the conversion is considered to be illegal.
```mlir ```mlir
// Shift without extension // Shift without extension
%res0 = spv.ShiftRightArithmetic %0, %2 : i32, i32 => %res0 = llvm.ashr %0, %2 : !llvm.i32 %res0 = spv.ShiftRightArithmetic %0, %2 : i32, i32 => %res0 = llvm.ashr %0, %2 : i32
// Shift with extension // Shift with extension
%ext = llvm.sext %1 : !llvm.i16 to !llvm.i32 %ext = llvm.sext %1 : i16 to i32
%res1 = spv.ShiftRightArithmetic %0, %1 : i32, i16 => %res1 = llvm.ashr %0, %ext: !llvm.i32 %res1 = spv.ShiftRightArithmetic %0, %1 : i32, i16 => %res1 = llvm.ashr %0, %ext: i32
``` ```
### `spv.constant` ### `spv.constant`
At the moment `spv.constant` conversion supports scalar and vector constants At the moment `spv.constant` conversion supports scalar and vector constants
**only**. **only**.
#### Mapping #### Mapping
Show All 9 Lines
The conversion casts constant value attribute to a signless integer or a vector The conversion casts constant value attribute to a signless integer or a vector
of signless integers. This is correct because in SPIR-V, like in LLVM, how to of signless integers. This is correct because in SPIR-V, like in LLVM, how to
interpret an integer number is also dictated by the opcode. However, in reality interpret an integer number is also dictated by the opcode. However, in reality
hardware implementation might show unexpected behavior. Therefore, it is better hardware implementation might show unexpected behavior. Therefore, it is better
to handle it case-by-case, given that the purpose of the conversion is not to to handle it case-by-case, given that the purpose of the conversion is not to
cover all possible corner cases. cover all possible corner cases.
```mlir ```mlir
// %0 = llvm.mlir.constant(0 : i8) : !llvm.i8 // %0 = llvm.mlir.constant(0 : i8) : i8
%0 = spv.constant 0 : i8 %0 = spv.constant 0 : i8
// %1 = llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : !llvm.vec<3 x i32> // %1 = llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : !llvm.vec<3 x i32>
%1 = spv.constant dense<[2, 3, 4]> : vector<3xui32> %1 = spv.constant dense<[2, 3, 4]> : vector<3xui32>
``` ```
### Not implemented ops ### Not implemented ops
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
Control flow within `spv.selection` and `spv.loop` is lowered directly to LLVM Control flow within `spv.selection` and `spv.loop` is lowered directly to LLVM
via branch ops. The conversion can only be applied to selection or loop with all via branch ops. The conversion can only be applied to selection or loop with all
blocks being reachable. Moreover, selection and loop control attributes (such as blocks being reachable. Moreover, selection and loop control attributes (such as
`Flatten` or `Unroll`) are not supported at the moment. `Flatten` or `Unroll`) are not supported at the moment.
```mlir ```mlir
// Conversion of selection // Conversion of selection
%cond = spv.constant true %cond = llvm.mlir.constant(true) : !llvm.i1 %cond = spv.constant true %cond = llvm.mlir.constant(true) : i1
spv.selection { spv.selection {
spv.BranchConditional %cond, ^true, ^false llvm.cond_br %cond, ^true, ^false spv.BranchConditional %cond, ^true, ^false llvm.cond_br %cond, ^true, ^false
^true: ^true: ^true: ^true:
// True block code // True block code // True block code // True block code
spv.Branch ^merge => llvm.br ^merge spv.Branch ^merge => llvm.br ^merge
^false: ^false: ^false: ^false:
// False block code // False block code // False block code // False block code
spv.Branch ^merge llvm.br ^merge spv.Branch ^merge llvm.br ^merge
^merge: ^merge: ^merge: ^merge:
spv.mlir.merge llvm.br ^continue spv.mlir.merge llvm.br ^continue
} }
// Remaining code ^continue: // Remaining code ^continue:
// Remaining code // Remaining code
``` ```
```mlir ```mlir
// Conversion of loop // Conversion of loop
%cond = spv.constant true %cond = llvm.mlir.constant(true) : !llvm.i1 %cond = spv.constant true %cond = llvm.mlir.constant(true) : i1
spv.loop { spv.loop {
spv.Branch ^header llvm.br ^header spv.Branch ^header llvm.br ^header
^header: ^header: ^header: ^header:
// Header code // Header code // Header code // Header code
spv.BranchConditional %cond, ^body, ^merge => llvm.cond_br %cond, ^body, ^merge spv.BranchConditional %cond, ^body, ^merge => llvm.cond_br %cond, ^body, ^merge
^body: ^body: ^body: ^body:
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

mlir/docs/Tutorials/Toy/Ch-6.md

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Linesfunc @main() {
toy.return toy.return
} }
``` ```
We can now lower down to the LLVM dialect, which produces the following code: We can now lower down to the LLVM dialect, which produces the following code:
```mlir ```mlir
llvm.func @free(!llvm<"i8*">) llvm.func @free(!llvm<"i8*">)
llvm.func @printf(!llvm<"i8*">, ...) -> !llvm.i32 llvm.func @printf(!llvm<"i8*">, ...) -> i32
llvm.func @malloc(!llvm.i64) -> !llvm<"i8*"> llvm.func @malloc(i64) -> !llvm<"i8*">
llvm.func @main() { llvm.func @main() {
%0 = llvm.mlir.constant(1.000000e+00 : f64) : !llvm.double %0 = llvm.mlir.constant(1.000000e+00 : f64) : !llvm.double
%1 = llvm.mlir.constant(2.000000e+00 : f64) : !llvm.double %1 = llvm.mlir.constant(2.000000e+00 : f64) : !llvm.double
... ...
^bb16: ^bb16:
%221 = llvm.extractvalue %25[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %221 = llvm.extractvalue %25[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }">
%222 = llvm.mlir.constant(0 : index) : !llvm.i64 %222 = llvm.mlir.constant(0 : index) : i64
%223 = llvm.mlir.constant(2 : index) : !llvm.i64 %223 = llvm.mlir.constant(2 : index) : i64
%224 = llvm.mul %214, %223 : !llvm.i64 %224 = llvm.mul %214, %223 : i64
%225 = llvm.add %222, %224 : !llvm.i64 %225 = llvm.add %222, %224 : i64
%226 = llvm.mlir.constant(1 : index) : !llvm.i64 %226 = llvm.mlir.constant(1 : index) : i64
%227 = llvm.mul %219, %226 : !llvm.i64 %227 = llvm.mul %219, %226 : i64
%228 = llvm.add %225, %227 : !llvm.i64 %228 = llvm.add %225, %227 : i64
%229 = llvm.getelementptr %221[%228] : (!llvm<"double*">, !llvm.i64) -> !llvm<"double*"> %229 = llvm.getelementptr %221[%228] : (!llvm<"double*">, i64) -> !llvm<"double*">
%230 = llvm.load %229 : !llvm<"double*"> %230 = llvm.load %229 : !llvm<"double*">
%231 = llvm.call @printf(%207, %230) : (!llvm<"i8*">, !llvm.double) -> !llvm.i32 %231 = llvm.call @printf(%207, %230) : (!llvm<"i8*">, !llvm.double) -> i32
%232 = llvm.add %219, %218 : !llvm.i64 %232 = llvm.add %219, %218 : i64
llvm.br ^bb15(%232 : !llvm.i64) llvm.br ^bb15(%232 : i64)
... ...
^bb18: ^bb18:
%235 = llvm.extractvalue %65[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %235 = llvm.extractvalue %65[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }">
%236 = llvm.bitcast %235 : !llvm<"double*"> to !llvm<"i8*"> %236 = llvm.bitcast %235 : !llvm<"double*"> to !llvm<"i8*">
llvm.call @free(%236) : (!llvm<"i8*">) -> () llvm.call @free(%236) : (!llvm<"i8*">) -> ()
%237 = llvm.extractvalue %45[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }"> %237 = llvm.extractvalue %45[0 : index] : !llvm<"{ double*, i64, [2 x i64], [2 x i64] }">
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesprivate:
static FlatSymbolRefAttr getOrInsertPrintf(PatternRewriter &rewriter, static FlatSymbolRefAttr getOrInsertPrintf(PatternRewriter &rewriter,
ModuleOp module) { ModuleOp module) {
auto *context = module.getContext(); auto *context = module.getContext();
if (module.lookupSymbol<LLVM::LLVMFuncOp>("printf")) if (module.lookupSymbol<LLVM::LLVMFuncOp>("printf"))
return SymbolRefAttr::get("printf", context); return SymbolRefAttr::get("printf", context);
// Create a function declaration for printf, the signature is: // Create a function declaration for printf, the signature is:
// * `i32 (i8*, ...)` // * `i32 (i8*, ...)`
auto llvmI32Ty = LLVM::LLVMIntegerType::get(context, 32); auto llvmI32Ty = IntegerType::get(context, 32);
auto llvmI8PtrTy = auto llvmI8PtrTy = LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8));
auto llvmFnType = LLVM::LLVMFunctionType::get(llvmI32Ty, llvmI8PtrTy, auto llvmFnType = LLVM::LLVMFunctionType::get(llvmI32Ty, llvmI8PtrTy,
/*isVarArg=*/true); /*isVarArg=*/true);
// Insert the printf function into the body of the parent module. // Insert the printf function into the body of the parent module.
PatternRewriter::InsertionGuard insertGuard(rewriter); PatternRewriter::InsertionGuard insertGuard(rewriter);
rewriter.setInsertionPointToStart(module.getBody()); rewriter.setInsertionPointToStart(module.getBody());
rewriter.create<LLVM::LLVMFuncOp>(module.getLoc(), "printf", llvmFnType); rewriter.create<LLVM::LLVMFuncOp>(module.getLoc(), "printf", llvmFnType);
return SymbolRefAttr::get("printf", context); return SymbolRefAttr::get("printf", context);
} }
/// Return a value representing an access into a global string with the given /// Return a value representing an access into a global string with the given
/// name, creating the string if necessary. /// name, creating the string if necessary.
static Value getOrCreateGlobalString(Location loc, OpBuilder &builder, static Value getOrCreateGlobalString(Location loc, OpBuilder &builder,
StringRef name, StringRef value, StringRef name, StringRef value,
ModuleOp module) { ModuleOp module) {
// Create the global at the entry of the module. // Create the global at the entry of the module.
LLVM::GlobalOp global; LLVM::GlobalOp global;
if (!(global = module.lookupSymbol<LLVM::GlobalOp>(name))) { if (!(global = module.lookupSymbol<LLVM::GlobalOp>(name))) {
OpBuilder::InsertionGuard insertGuard(builder); OpBuilder::InsertionGuard insertGuard(builder);
builder.setInsertionPointToStart(module.getBody()); builder.setInsertionPointToStart(module.getBody());
auto type = LLVM::LLVMArrayType::get( auto type = LLVM::LLVMArrayType::get(
LLVM::LLVMIntegerType::get(builder.getContext(), 8), value.size()); IntegerType::get(builder.getContext(), 8), value.size());
global = builder.create<LLVM::GlobalOp>(loc, type, /*isConstant=*/true, global = builder.create<LLVM::GlobalOp>(loc, type, /*isConstant=*/true,
LLVM::Linkage::Internal, name, LLVM::Linkage::Internal, name,
builder.getStringAttr(value)); builder.getStringAttr(value));
} }
// Get the pointer to the first character in the global string. // Get the pointer to the first character in the global string.
Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global); Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global);
Value cst0 = builder.create<LLVM::ConstantOp>( Value cst0 = builder.create<LLVM::ConstantOp>(
loc, LLVM::LLVMIntegerType::get(builder.getContext(), 64), loc, IntegerType::get(builder.getContext(), 64),
builder.getIntegerAttr(builder.getIndexType(), 0)); builder.getIntegerAttr(builder.getIndexType(), 0));
return builder.create<LLVM::GEPOp>( return builder.create<LLVM::GEPOp>(
loc, loc,
LLVM::LLVMPointerType::get( LLVM::LLVMPointerType::get(IntegerType::get(builder.getContext(), 8)),
LLVM::LLVMIntegerType::get(builder.getContext(), 8)),
globalPtr, ArrayRef<Value>({cst0, cst0})); globalPtr, ArrayRef<Value>({cst0, cst0}));
} }
}; };
} // end anonymous namespace } // end anonymous namespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyToLLVMLoweringPass // ToyToLLVMLoweringPass
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesprivate:
static FlatSymbolRefAttr getOrInsertPrintf(PatternRewriter &rewriter, static FlatSymbolRefAttr getOrInsertPrintf(PatternRewriter &rewriter,
ModuleOp module) { ModuleOp module) {
auto *context = module.getContext(); auto *context = module.getContext();
if (module.lookupSymbol<LLVM::LLVMFuncOp>("printf")) if (module.lookupSymbol<LLVM::LLVMFuncOp>("printf"))
return SymbolRefAttr::get("printf", context); return SymbolRefAttr::get("printf", context);
// Create a function declaration for printf, the signature is: // Create a function declaration for printf, the signature is:
// * `i32 (i8*, ...)` // * `i32 (i8*, ...)`
auto llvmI32Ty = LLVM::LLVMIntegerType::get(context, 32); auto llvmI32Ty = IntegerType::get(context, 32);
auto llvmI8PtrTy = auto llvmI8PtrTy = LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8));
auto llvmFnType = LLVM::LLVMFunctionType::get(llvmI32Ty, llvmI8PtrTy, auto llvmFnType = LLVM::LLVMFunctionType::get(llvmI32Ty, llvmI8PtrTy,
/*isVarArg=*/true); /*isVarArg=*/true);
// Insert the printf function into the body of the parent module. // Insert the printf function into the body of the parent module.
PatternRewriter::InsertionGuard insertGuard(rewriter); PatternRewriter::InsertionGuard insertGuard(rewriter);
rewriter.setInsertionPointToStart(module.getBody()); rewriter.setInsertionPointToStart(module.getBody());
rewriter.create<LLVM::LLVMFuncOp>(module.getLoc(), "printf", llvmFnType); rewriter.create<LLVM::LLVMFuncOp>(module.getLoc(), "printf", llvmFnType);
return SymbolRefAttr::get("printf", context); return SymbolRefAttr::get("printf", context);
} }
/// Return a value representing an access into a global string with the given /// Return a value representing an access into a global string with the given
/// name, creating the string if necessary. /// name, creating the string if necessary.
static Value getOrCreateGlobalString(Location loc, OpBuilder &builder, static Value getOrCreateGlobalString(Location loc, OpBuilder &builder,
StringRef name, StringRef value, StringRef name, StringRef value,
ModuleOp module) { ModuleOp module) {
// Create the global at the entry of the module. // Create the global at the entry of the module.
LLVM::GlobalOp global; LLVM::GlobalOp global;
if (!(global = module.lookupSymbol<LLVM::GlobalOp>(name))) { if (!(global = module.lookupSymbol<LLVM::GlobalOp>(name))) {
OpBuilder::InsertionGuard insertGuard(builder); OpBuilder::InsertionGuard insertGuard(builder);
builder.setInsertionPointToStart(module.getBody()); builder.setInsertionPointToStart(module.getBody());
auto type = LLVM::LLVMArrayType::get( auto type = LLVM::LLVMArrayType::get(
LLVM::LLVMIntegerType::get(builder.getContext(), 8), value.size()); IntegerType::get(builder.getContext(), 8), value.size());
global = builder.create<LLVM::GlobalOp>(loc, type, /*isConstant=*/true, global = builder.create<LLVM::GlobalOp>(loc, type, /*isConstant=*/true,
LLVM::Linkage::Internal, name, LLVM::Linkage::Internal, name,
builder.getStringAttr(value)); builder.getStringAttr(value));
} }
// Get the pointer to the first character in the global string. // Get the pointer to the first character in the global string.
Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global); Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global);
Value cst0 = builder.create<LLVM::ConstantOp>( Value cst0 = builder.create<LLVM::ConstantOp>(
loc, LLVM::LLVMIntegerType::get(builder.getContext(), 64), loc, IntegerType::get(builder.getContext(), 64),
builder.getIntegerAttr(builder.getIndexType(), 0)); builder.getIntegerAttr(builder.getIndexType(), 0));
return builder.create<LLVM::GEPOp>( return builder.create<LLVM::GEPOp>(
loc, loc,
LLVM::LLVMPointerType::get( LLVM::LLVMPointerType::get(IntegerType::get(builder.getContext(), 8)),
LLVM::LLVMIntegerType::get(builder.getContext(), 8)),
globalPtr, ArrayRef<Value>({cst0, cst0})); globalPtr, ArrayRef<Value>({cst0, cst0}));
} }
}; };
} // end anonymous namespace } // end anonymous namespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ToyToLLVMLoweringPass // ToyToLLVMLoweringPass
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Linesprivate:
/// - one index-typed stride per dimension of the memref. /// - one index-typed stride per dimension of the memref.
/// - (if unpackArrregates = false) /// - (if unpackArrregates = false)
/// - one rank-sized array of index-type for the size of each dimension /// - one rank-sized array of index-type for the size of each dimension
/// - one rank-sized array of index-type for the stride of each dimension /// - one rank-sized array of index-type for the stride of each dimension
/// ///
/// For example, memref<?x?xf32> is converted to the following list: /// For example, memref<?x?xf32> is converted to the following list:
/// - `!llvm<"float*">` (allocated pointer), /// - `!llvm<"float*">` (allocated pointer),
/// - `!llvm<"float*">` (aligned pointer), /// - `!llvm<"float*">` (aligned pointer),
/// - `!llvm.i64` (offset), /// - `i64` (offset),
/// - `!llvm.i64`, `!llvm.i64` (sizes), /// - `i64`, `i64` (sizes),
/// - `!llvm.i64`, `!llvm.i64` (strides). /// - `i64`, `i64` (strides).
/// These types can be recomposed to a memref descriptor struct. /// These types can be recomposed to a memref descriptor struct.
SmallVector<Type, 5> getMemRefDescriptorFields(MemRefType type, SmallVector<Type, 5> getMemRefDescriptorFields(MemRefType type,
bool unpackAggregates); bool unpackAggregates);
/// Convert an unranked memref type into a list of non-aggregate LLVM IR types /// Convert an unranked memref type into a list of non-aggregate LLVM IR types
/// that will form the unranked memref descriptor. In particular, this list /// that will form the unranked memref descriptor. In particular, this list
/// contains: /// contains:
/// - an integer rank, followed by /// - an integer rank, followed by
/// - a pointer to the memref descriptor struct. /// - a pointer to the memref descriptor struct.
/// For example, memref<*xf32> is converted to the following list: /// For example, memref<*xf32> is converted to the following list:
/// !llvm.i64 (rank) /// i64 (rank)
/// !llvm<"i8*"> (type-erased pointer). /// !llvm<"i8*"> (type-erased pointer).
/// These types can be recomposed to a unranked memref descriptor struct. /// These types can be recomposed to a unranked memref descriptor struct.
SmallVector<Type, 2> getUnrankedMemRefDescriptorFields(); SmallVector<Type, 2> getUnrankedMemRefDescriptorFields();
// Convert an unranked memref type to an LLVM type that captures the // Convert an unranked memref type to an LLVM type that captures the
// runtime rank and a pointer to the static ranked memref desc // runtime rank and a pointer to the static ranked memref desc
Type convertUnrankedMemRefType(UnrankedMemRefType type); Type convertUnrankedMemRefType(UnrankedMemRefType type);
▲ Show 20 Lines • Show All 313 Lines • ▼ Show 20 Linesprotected:
Type getElementPtrType(MemRefType type) const; Type getElementPtrType(MemRefType type) const;
/// Computes sizes, strides and buffer size in bytes of `memRefType` with /// Computes sizes, strides and buffer size in bytes of `memRefType` with
/// identity layout. Emits constant ops for the static sizes of `memRefType`, /// identity layout. Emits constant ops for the static sizes of `memRefType`,
/// and uses `dynamicSizes` for the others. Emits instructions to compute /// and uses `dynamicSizes` for the others. Emits instructions to compute
/// strides and buffer size from these sizes. /// strides and buffer size from these sizes.
/// ///
/// For example, memref<4x?xf32> emits: /// For example, memref<4x?xf32> emits:
/// `sizes[0]` = llvm.mlir.constant(4 : index) : !llvm.i64 /// `sizes[0]` = llvm.mlir.constant(4 : index) : i64
/// `sizes[1]` = `dynamicSizes[0]` /// `sizes[1]` = `dynamicSizes[0]`
/// `strides[1]` = llvm.mlir.constant(1 : index) : !llvm.i64 /// `strides[1]` = llvm.mlir.constant(1 : index) : i64
/// `strides[0]` = `sizes[0]` /// `strides[0]` = `sizes[0]`
/// %size = llvm.mul `sizes[0]`, `sizes[1]` : !llvm.i64 /// %size = llvm.mul `sizes[0]`, `sizes[1]` : i64
/// %nullptr = llvm.mlir.null : !llvm.ptr<float> /// %nullptr = llvm.mlir.null : !llvm.ptr<float>
/// %gep = llvm.getelementptr %nullptr[%size] /// %gep = llvm.getelementptr %nullptr[%size]
/// : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> /// : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
/// `sizeBytes` = llvm.ptrtoint %gep : !llvm.ptr<float> to !llvm.i64 /// `sizeBytes` = llvm.ptrtoint %gep : !llvm.ptr<float> to i64
void getMemRefDescriptorSizes(Location loc, MemRefType memRefType, void getMemRefDescriptorSizes(Location loc, MemRefType memRefType,
ArrayRef<Value> dynamicSizes, ArrayRef<Value> dynamicSizes,
ConversionPatternRewriter &rewriter, ConversionPatternRewriter &rewriter,
SmallVectorImpl<Value> &sizes, SmallVectorImpl<Value> &sizes,
SmallVectorImpl<Value> &strides, SmallVectorImpl<Value> &strides,
Value &sizeBytes) const; Value &sizeBytes) const;
/// Computes the size of type in bytes. /// Computes the size of type in bytes.
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
// LLVM dialect type. // LLVM dialect type.
def LLVM_Type : DialectType<LLVM_Dialect, def LLVM_Type : DialectType<LLVM_Dialect,
CPred<"::mlir::LLVM::isCompatibleType($_self)">, CPred<"::mlir::LLVM::isCompatibleType($_self)">,
"LLVM dialect-compatible type">; "LLVM dialect-compatible type">;
// Type constraint accepting LLVM integer types. // Type constraint accepting LLVM integer types.
def LLVM_AnyInteger : Type< def LLVM_AnyInteger : Type<
CPred<"$_self.isa<::mlir::LLVM::LLVMIntegerType>()">, CPred<"$_self.isa<::mlir::IntegerType>()">,
"LLVM integer type">; "LLVM integer type">;
// Type constraints accepting LLVM integer type of a specific width. // Type constraints accepting LLVM integer type of a specific width.
class LLVM_IntBase<int width> : class LLVM_IntBase<int width> :
Type<And<[ Type<And<[
LLVM_AnyInteger.predicate, LLVM_AnyInteger.predicate,
CPred<"$_self.cast<::mlir::LLVM::LLVMIntegerType>().getBitWidth() == " CPred<"$_self.cast<::mlir::IntegerType>().getWidth() == "
# width>]>, # width>]>,
"LLVM " # width # "-bit integer type">, "LLVM " # width # "-bit integer type">,
BuildableType< BuildableType<
"::mlir::LLVM::LLVMIntegerType::get($_builder.getContext(), " "::mlir::IntegerType::get($_builder.getContext(), "
# width # ")">; # width # ")">;
def LLVM_i1 : LLVM_IntBase<1>; def LLVM_i1 : LLVM_IntBase<1>;
def LLVM_i8 : LLVM_IntBase<8>; def LLVM_i8 : LLVM_IntBase<8>;
def LLVM_i32 : LLVM_IntBase<32>; def LLVM_i32 : LLVM_IntBase<32>;
// Type constraint accepting LLVM primitive types, i.e. all types except void // Type constraint accepting LLVM primitive types, i.e. all types except void
// and function. // and function.
▲ Show 20 Lines • Show All 266 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines let arguments = (ins ICmpPredicate:$predicate,
LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs); LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs);
let results = (outs LLVM_ScalarOrVectorOf<LLVM_i1>:$res); let results = (outs LLVM_ScalarOrVectorOf<LLVM_i1>:$res);
let llvmBuilder = [{ let llvmBuilder = [{
$res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs); $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
}]; }];
let builders = [ let builders = [
OpBuilderDAG<(ins "ICmpPredicate":$predicate, "Value":$lhs, "Value":$rhs), OpBuilderDAG<(ins "ICmpPredicate":$predicate, "Value":$lhs, "Value":$rhs),
[{ [{
build($_builder, $_state, LLVMIntegerType::get(lhs.getType().getContext(), 1), build($_builder, $_state, IntegerType::get(lhs.getType().getContext(), 1),
$_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs); $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs);
}]>]; }]>];
let parser = [{ return parseCmpOp<ICmpPredicate>(parser, result); }]; let parser = [{ return parseCmpOp<ICmpPredicate>(parser, result); }];
let printer = [{ printICmpOp(p, *this); }]; let printer = [{ printICmpOp(p, *this); }];
} }
// Predicate for float comparisons // Predicate for float comparisons
def FCmpPredicateFALSE : I64EnumAttrCase<"_false", 0>; def FCmpPredicateFALSE : I64EnumAttrCase<"_false", 0>;
Show All 34 Linesdef LLVM_FCmpOp : LLVM_Op<"fcmp", [
let results = (outs LLVM_ScalarOrVectorOf<LLVM_i1>:$res); let results = (outs LLVM_ScalarOrVectorOf<LLVM_i1>:$res);
let llvmBuilder = [{ let llvmBuilder = [{
$res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs); $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
}]; }];
let builders = [ let builders = [
OpBuilderDAG<(ins "FCmpPredicate":$predicate, "Value":$lhs, "Value":$rhs, OpBuilderDAG<(ins "FCmpPredicate":$predicate, "Value":$lhs, "Value":$rhs,
CArg<"FastmathFlags", "{}">:$fmf), CArg<"FastmathFlags", "{}">:$fmf),
[{ [{
build($_builder, $_state, LLVMIntegerType::get(lhs.getType().getContext(), 1), build($_builder, $_state, IntegerType::get(lhs.getType().getContext(), 1),
$_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs, $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs,
::mlir::LLVM::FMFAttr::get(fmf, $_builder.getContext())); ::mlir::LLVM::FMFAttr::get(fmf, $_builder.getContext()));
}]>]; }]>];
let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }]; let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }];
let printer = [{ printFCmpOp(p, *this); }]; let printer = [{ printFCmpOp(p, *this); }];
} }
// Floating point binary operations. // Floating point binary operations.
▲ Show 20 Lines • Show All 539 Lines • ▼ Show 20 Lines func @foo() {
// Get the address of a function. // Get the address of a function.
%2 = llvm.mlir.addressof @foo : !llvm.ptr<func<void ()>> %2 = llvm.mlir.addressof @foo : !llvm.ptr<func<void ()>>
// The function address can be used for indirect calls. // The function address can be used for indirect calls.
llvm.call %2() : () -> () llvm.call %2() : () -> ()
} }
// Define the global. // Define the global.
llvm.mlir.global @const(42 : i32) : !llvm.i32 llvm.mlir.global @const(42 : i32) : i32
``` ```
}]; }];
let builders = [ let builders = [
OpBuilderDAG<(ins "GlobalOp":$global, OpBuilderDAG<(ins "GlobalOp":$global,
CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs), CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
[{ [{
build($_builder, $_state, build($_builder, $_state,
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines let description = [{
More complex constants that cannot be represented as MLIR attributes can be More complex constants that cannot be represented as MLIR attributes can be
given in an initializer region: given in an initializer region:
```mlir ```mlir
// This global is initialized with the equivalent of: // This global is initialized with the equivalent of:
// i32* getelementptr (i32* @g2, i32 2) // i32* getelementptr (i32* @g2, i32 2)
llvm.mlir.global constant @int_gep() : !llvm.ptr<i32> { llvm.mlir.global constant @int_gep() : !llvm.ptr<i32> {
%0 = llvm.mlir.addressof @g2 : !llvm.ptr<i32> %0 = llvm.mlir.addressof @g2 : !llvm.ptr<i32>
%1 = llvm.mlir.constant(2 : i32) : !llvm.i32 %1 = llvm.mlir.constant(2 : i32) : i32
%2 = llvm.getelementptr %0[%1] %2 = llvm.getelementptr %0[%1]
: (!llvm.ptr<i32>, !llvm.i32) -> !llvm.ptr<i32> : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
// The initializer region must end with `llvm.return`. // The initializer region must end with `llvm.return`.
llvm.return %2 : !llvm.ptr<i32> llvm.return %2 : !llvm.ptr<i32>
} }
``` ```
Only one of the initializer attribute or initializer region may be provided. 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 `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 an @-identifier for its value, which will be uniqued by the module with
respect to other @-identifiers in it. respect to other @-identifiers in it.
Examples: Examples:
```mlir ```mlir
// Global values use @-identifiers. // Global values use @-identifiers.
llvm.mlir.global constant @cst(42 : i32) : !llvm.i32 llvm.mlir.global constant @cst(42 : i32) : i32
// Non-constant values must also be initialized. // Non-constant values must also be initialized.
llvm.mlir.global @variable(32.0 : f32) : !llvm.float llvm.mlir.global @variable(32.0 : f32) : !llvm.float
// Strings are expected to be of wrapped LLVM i8 array type and do not // Strings are expected to be of wrapped LLVM i8 array type and do not
// automatically include the trailing zero. // automatically include the trailing zero.
llvm.mlir.global @string("abc") : !llvm.array<3 x i8> llvm.mlir.global @string("abc") : !llvm.array<3 x i8>
// For strings globals, the trailing type may be omitted. // For strings globals, the trailing type may be omitted.
llvm.mlir.global constant @no_trailing_type("foo bar") llvm.mlir.global constant @no_trailing_type("foo bar")
// A complex initializer is constructed with an initializer region. // A complex initializer is constructed with an initializer region.
llvm.mlir.global constant @int_gep() : !llvm.ptr<i32> { llvm.mlir.global constant @int_gep() : !llvm.ptr<i32> {
%0 = llvm.mlir.addressof @g2 : !llvm.ptr<i32> %0 = llvm.mlir.addressof @g2 : !llvm.ptr<i32>
%1 = llvm.mlir.constant(2 : i32) : !llvm.i32 %1 = llvm.mlir.constant(2 : i32) : i32
%2 = llvm.getelementptr %0[%1] %2 = llvm.getelementptr %0[%1]
: (!llvm.ptr<i32>, !llvm.i32) -> !llvm.ptr<i32> : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
llvm.return %2 : !llvm.ptr<i32> llvm.return %2 : !llvm.ptr<i32>
} }
``` ```
Similarly to functions, globals have a linkage attribute. In the custom Similarly to functions, globals have a linkage attribute. In the custom
syntax, this attribute is placed between `llvm.mlir.global` and the optional syntax, this attribute is placed between `llvm.mlir.global` and the optional
`constant` keyword. If the attribute is omitted, `external` linkage is `constant` keyword. If the attribute is omitted, `external` linkage is
assumed by default. assumed by default.
Examples: Examples:
```mlir ```mlir
// A constant with internal linkage will not participate in linking. // A constant with internal linkage will not participate in linking.
llvm.mlir.global internal constant @cst(42 : i32) : !llvm.i32 llvm.mlir.global internal constant @cst(42 : i32) : i32
// By default, "external" linkage is assumed and the global participates in // By default, "external" linkage is assumed and the global participates in
// symbol resolution at link-time. // symbol resolution at link-time.
llvm.mlir.global @glob(0 : f32) : !llvm.float llvm.mlir.global @glob(0 : f32) : !llvm.float
``` ```
}]; }];
let regions = (region AnyRegion:$initializer); let regions = (region AnyRegion:$initializer);
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines let description = [{
functions compatible with LLVM IR. These functions have LLVM dialect functions compatible with LLVM IR. These functions have LLVM dialect
function type but use MLIR syntax to express it. They are required to have 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 exactly one result type. LLVM function operation is intended to capture
additional properties of LLVM functions, such as linkage and calling additional properties of LLVM functions, such as linkage and calling
convention, that may be modeled differently by the built-in MLIR function. convention, that may be modeled differently by the built-in MLIR function.
```mlir ```mlir
// The type of @bar is !llvm<"i64 (i64)"> // The type of @bar is !llvm<"i64 (i64)">
llvm.func @bar(%arg0: !llvm.i64) -> !llvm.i64 { llvm.func @bar(%arg0: i64) -> i64 {
llvm.return %arg0 : !llvm.i64 llvm.return %arg0 : i64
} }
// Type type of @foo is !llvm<"void (i64)"> // Type type of @foo is !llvm<"void (i64)">
// !llvm.void type is omitted // !llvm.void type is omitted
llvm.func @foo(%arg0: !llvm.i64) { llvm.func @foo(%arg0: i64) {
llvm.return llvm.return
} }
// A function with `internal` linkage. // A function with `internal` linkage.
llvm.func internal @internal_func() { llvm.func internal @internal_func() {
llvm.return llvm.return
} }
``` ```
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines let description = [{
operation produces a new SSA value of the specified LLVM IR dialect type. operation produces a new SSA value of the specified LLVM IR dialect type.
The type of that value _must_ correspond to the attribute type converted to The type of that value _must_ correspond to the attribute type converted to
LLVM IR. LLVM IR.
Examples: Examples:
```mlir ```mlir
// Integer constant, internal i32 is mandatory // Integer constant, internal i32 is mandatory
%0 = llvm.mlir.constant(42 : i32) : !llvm.i32 %0 = llvm.mlir.constant(42 : i32) : i32
// It's okay to omit i64. // It's okay to omit i64.
%1 = llvm.mlir.constant(42) : !llvm.i64 %1 = llvm.mlir.constant(42) : i64
// Floating point constant. // Floating point constant.
%2 = llvm.mlir.constant(42.0 : f32) : !llvm.float %2 = llvm.mlir.constant(42.0 : f32) : !llvm.float
// Splat dense vector constant. // Splat dense vector constant.
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float> %3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float>
``` ```
}]; }];
▲ Show 20 Lines • Show All 454 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

Show All 25 Lines
class DialectAsmParser; class DialectAsmParser;
class DialectAsmPrinter; class DialectAsmPrinter;
namespace LLVM { namespace LLVM {
class LLVMDialect; class LLVMDialect;
namespace detail { namespace detail {
struct LLVMFunctionTypeStorage; struct LLVMFunctionTypeStorage;
struct LLVMIntegerTypeStorage;
struct LLVMPointerTypeStorage; struct LLVMPointerTypeStorage;
struct LLVMStructTypeStorage; struct LLVMStructTypeStorage;
struct LLVMTypeAndSizeStorage; struct LLVMTypeAndSizeStorage;
} // namespace detail } // namespace detail
class LLVMBFloatType; class LLVMBFloatType;
class LLVMHalfType; class LLVMHalfType;
class LLVMFloatType; class LLVMFloatType;
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Linespublic:
/// Verifies that the type about to be constructed is well-formed. /// Verifies that the type about to be constructed is well-formed.
static LogicalResult verifyConstructionInvariants(Location loc, Type result, static LogicalResult verifyConstructionInvariants(Location loc, Type result,
ArrayRef<Type> arguments, ArrayRef<Type> arguments,
bool); bool);
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LLVMIntegerType.
//===----------------------------------------------------------------------===//
/// LLVM dialect signless integer type parameterized by bitwidth.
class LLVMIntegerType : public Type::TypeBase<LLVMIntegerType, Type,
detail::LLVMIntegerTypeStorage> {
public:
/// Inherit base constructor.
using Base::Base;
/// Gets or creates an instance of the integer of the specified `bitwidth` in
/// the given context.
static LLVMIntegerType get(MLIRContext *ctx, unsigned bitwidth);
static LLVMIntegerType getChecked(Location loc, unsigned bitwidth);
/// Returns the bitwidth of this integer type.
unsigned getBitWidth();
/// Verifies that the type about to be constructed is well-formed.
static LogicalResult verifyConstructionInvariants(Location loc,
unsigned bitwidth);
};
//===----------------------------------------------------------------------===//
// LLVMPointerType. // LLVMPointerType.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// LLVM dialect pointer type. This type typically represents a reference to an /// LLVM dialect pointer type. This type typically represents a reference to an
/// object in memory. It is parameterized by the element type and the address /// object in memory. It is parameterized by the element type and the address
/// space. /// space.
class LLVMPointerType : public Type::TypeBase<LLVMPointerType, Type, class LLVMPointerType : public Type::TypeBase<LLVMPointerType, Type,
detail::LLVMPointerTypeStorage> { detail::LLVMPointerTypeStorage> {
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
void printType(Type type, DialectAsmPrinter &printer); void printType(Type type, DialectAsmPrinter &printer);
} // namespace detail } // namespace detail
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Utility functions. // Utility functions.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Returns `true` if the given type is compatible with the LLVM dialect. /// Returns `true` if the given type is compatible with the LLVM dialect.
inline bool isCompatibleType(Type type) { bool isCompatibleType(Type type);
// clang-format off
return type.isa<
LLVMArrayType,
LLVMBFloatType,
LLVMDoubleType,
LLVMFP128Type,
LLVMFloatType,
LLVMFunctionType,
LLVMHalfType,
LLVMIntegerType,
LLVMLabelType,
LLVMMetadataType,
LLVMPPCFP128Type,
LLVMPointerType,
LLVMStructType,
LLVMTokenType,
LLVMVectorType,
LLVMVoidType,
LLVMX86FP80Type,
LLVMX86MMXType
>();
// clang-format on
}
inline bool isCompatibleFloatingPointType(Type type) { inline bool isCompatibleFloatingPointType(Type type) {
return type.isa<LLVMHalfType, LLVMBFloatType, LLVMFloatType, LLVMDoubleType, return type.isa<LLVMHalfType, LLVMBFloatType, LLVMFloatType, LLVMDoubleType,
LLVMFP128Type, LLVMX86FP80Type>(); LLVMFP128Type, LLVMX86FP80Type>();
} }
/// Returns the size of the given primitive LLVM dialect-compatible type /// Returns the size of the given primitive LLVM dialect-compatible type
/// (including vectors) in bits, for example, the size of !llvm.i16 is 16 and /// (including vectors) in bits, for example, the size of i16 is 16 and
/// the size of !llvm.vec<4 x i16> is 64. Returns 0 for non-primitive /// the size of !llvm.vec<4 x i16> is 64. Returns 0 for non-primitive
/// (aggregates such as struct) or types that don't have a size (such as void). /// (aggregates such as struct) or types that don't have a size (such as void).
llvm::TypeSize getPrimitiveTypeSizeInBits(Type type); llvm::TypeSize getPrimitiveTypeSizeInBits(Type type);
} // namespace LLVM } // namespace LLVM
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_LLVMIR_LLVMTYPES_H_ #endif // MLIR_DIALECT_LLVMIR_LLVMTYPES_H_

mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesdef NVVM_ShflBflyOp :
}]; }];
let parser = [{ return parseNVVMShflSyncBflyOp(parser, result); }]; let parser = [{ return parseNVVMShflSyncBflyOp(parser, result); }];
let printer = [{ printNVVMIntrinsicOp(p, this->getOperation()); }]; let printer = [{ printNVVMIntrinsicOp(p, this->getOperation()); }];
let verifier = [{ let verifier = [{
if (!(*this)->getAttrOfType<UnitAttr>("return_value_and_is_valid")) if (!(*this)->getAttrOfType<UnitAttr>("return_value_and_is_valid"))
return success(); return success();
auto type = getType().dyn_cast<LLVM::LLVMStructType>(); auto type = getType().dyn_cast<LLVM::LLVMStructType>();
auto elementType = (type && type.getBody().size() == 2) auto elementType = (type && type.getBody().size() == 2)
? type.getBody()[1].dyn_cast<LLVM::LLVMIntegerType>() ? type.getBody()[1].dyn_cast<IntegerType>()
: nullptr; : nullptr;
if (!elementType || elementType.getBitWidth() != 1) if (!elementType || elementType.getWidth() != 1)
return emitError("expected return type to be a two-element struct with " return emitError("expected return type to be a two-element struct with "
"i1 as the second element"); "i1 as the second element");
return success(); return success();
}]; }];
} }
def NVVM_VoteBallotOp : def NVVM_VoteBallotOp :
NVVM_Op<"vote.ballot.sync">, NVVM_Op<"vote.ballot.sync">,
Show All 23 Lines

mlir/integration_test/Dialect/LLVMIR/CPU/X86/test-inline-asm.mlir

// RUN: mlir-cpu-runner %s -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner %s -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
module { module {
llvm.func @printI64(!llvm.i64) llvm.func @printI64(i64)
llvm.func @entry() { llvm.func @entry() {
%c2 = llvm.mlir.constant(-42: i64) :!llvm.i64 %c2 = llvm.mlir.constant(-42: i64) :i64
%val = llvm.inline_asm "xor $0, $0", "=r,r" %c2 : %val = llvm.inline_asm "xor $0, $0", "=r,r" %c2 :
(!llvm.i64) -> !llvm.i64 (i64) -> i64
// CHECK: 0 // CHECK: 0
llvm.call @printI64(%val) : (!llvm.i64) -> () llvm.call @printI64(%val) : (i64) -> ()
llvm.return llvm.return
} }
} }

mlir/integration_test/Dialect/LLVMIR/CPU/test-vector-reductions-fp.mlir

// RUN: mlir-cpu-runner %s -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner %s -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// End-to-end test of all fp reduction intrinsics (not exhaustive unit tests). // End-to-end test of all fp reduction intrinsics (not exhaustive unit tests).
module { module {
llvm.func @printNewline() llvm.func @printNewline()
llvm.func @printF32(!llvm.float) llvm.func @printF32(!llvm.float)
llvm.func @entry() { llvm.func @entry() {
// Setup (1,2,3,4). // Setup (1,2,3,4).
%0 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float %0 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float
%1 = llvm.mlir.constant(2.000000e+00 : f32) : !llvm.float %1 = llvm.mlir.constant(2.000000e+00 : f32) : !llvm.float
%2 = llvm.mlir.constant(3.000000e+00 : f32) : !llvm.float %2 = llvm.mlir.constant(3.000000e+00 : f32) : !llvm.float
%3 = llvm.mlir.constant(4.000000e+00 : f32) : !llvm.float %3 = llvm.mlir.constant(4.000000e+00 : f32) : !llvm.float
%4 = llvm.mlir.undef : !llvm.vec<4 x float> %4 = llvm.mlir.undef : !llvm.vec<4 x float>
%5 = llvm.mlir.constant(0 : index) : !llvm.i64 %5 = llvm.mlir.constant(0 : index) : i64
%6 = llvm.insertelement %0, %4[%5 : !llvm.i64] : !llvm.vec<4 x float> %6 = llvm.insertelement %0, %4[%5 : i64] : !llvm.vec<4 x float>
%7 = llvm.shufflevector %6, %4 [0 : i32, 0 : i32, 0 : i32, 0 : i32] %7 = llvm.shufflevector %6, %4 [0 : i32, 0 : i32, 0 : i32, 0 : i32]
: !llvm.vec<4 x float>, !llvm.vec<4 x float> : !llvm.vec<4 x float>, !llvm.vec<4 x float>
%8 = llvm.mlir.constant(1 : i64) : !llvm.i64 %8 = llvm.mlir.constant(1 : i64) : i64
%9 = llvm.insertelement %1, %7[%8 : !llvm.i64] : !llvm.vec<4 x float> %9 = llvm.insertelement %1, %7[%8 : i64] : !llvm.vec<4 x float>
%10 = llvm.mlir.constant(2 : i64) : !llvm.i64 %10 = llvm.mlir.constant(2 : i64) : i64
%11 = llvm.insertelement %2, %9[%10 : !llvm.i64] : !llvm.vec<4 x float> %11 = llvm.insertelement %2, %9[%10 : i64] : !llvm.vec<4 x float>
%12 = llvm.mlir.constant(3 : i64) : !llvm.i64 %12 = llvm.mlir.constant(3 : i64) : i64
%v = llvm.insertelement %3, %11[%12 : !llvm.i64] : !llvm.vec<4 x float> %v = llvm.insertelement %3, %11[%12 : i64] : !llvm.vec<4 x float>
%max = "llvm.intr.vector.reduce.fmax"(%v) %max = "llvm.intr.vector.reduce.fmax"(%v)
: (!llvm.vec<4 x float>) -> !llvm.float : (!llvm.vec<4 x float>) -> !llvm.float
llvm.call @printF32(%max) : (!llvm.float) -> () llvm.call @printF32(%max) : (!llvm.float) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 4 // CHECK: 4
%min = "llvm.intr.vector.reduce.fmin"(%v) %min = "llvm.intr.vector.reduce.fmin"(%v)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

mlir/integration_test/Dialect/LLVMIR/CPU/test-vector-reductions-int.mlir

// RUN: mlir-cpu-runner %s -e entry -entry-point-result=void \ // RUN: mlir-cpu-runner %s -e entry -entry-point-result=void \
// RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \ // RUN: -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
// RUN: FileCheck %s // RUN: FileCheck %s
// End-to-end test of all int reduction intrinsics (not exhaustive unit tests). // End-to-end test of all int reduction intrinsics (not exhaustive unit tests).
module { module {
llvm.func @printNewline() llvm.func @printNewline()
llvm.func @printI64(!llvm.i64) llvm.func @printI64(i64)
llvm.func @entry() { llvm.func @entry() {
// Setup (1,2,3,4). // Setup (1,2,3,4).
%0 = llvm.mlir.constant(1 : i64) : !llvm.i64 %0 = llvm.mlir.constant(1 : i64) : i64
%1 = llvm.mlir.constant(2 : i64) : !llvm.i64 %1 = llvm.mlir.constant(2 : i64) : i64
%2 = llvm.mlir.constant(3 : i64) : !llvm.i64 %2 = llvm.mlir.constant(3 : i64) : i64
%3 = llvm.mlir.constant(4 : i64) : !llvm.i64 %3 = llvm.mlir.constant(4 : i64) : i64
%4 = llvm.mlir.undef : !llvm.vec<4 x i64> %4 = llvm.mlir.undef : !llvm.vec<4 x i64>
%5 = llvm.mlir.constant(0 : index) : !llvm.i64 %5 = llvm.mlir.constant(0 : index) : i64
%6 = llvm.insertelement %0, %4[%5 : !llvm.i64] : !llvm.vec<4 x i64> %6 = llvm.insertelement %0, %4[%5 : i64] : !llvm.vec<4 x i64>
%7 = llvm.shufflevector %6, %4 [0 : i64, 0 : i64, 0 : i64, 0 : i64] %7 = llvm.shufflevector %6, %4 [0 : i64, 0 : i64, 0 : i64, 0 : i64]
: !llvm.vec<4 x i64>, !llvm.vec<4 x i64> : !llvm.vec<4 x i64>, !llvm.vec<4 x i64>
%8 = llvm.mlir.constant(1 : i64) : !llvm.i64 %8 = llvm.mlir.constant(1 : i64) : i64
%9 = llvm.insertelement %1, %7[%8 : !llvm.i64] : !llvm.vec<4 x i64> %9 = llvm.insertelement %1, %7[%8 : i64] : !llvm.vec<4 x i64>
%10 = llvm.mlir.constant(2 : i64) : !llvm.i64 %10 = llvm.mlir.constant(2 : i64) : i64
%11 = llvm.insertelement %2, %9[%10 : !llvm.i64] : !llvm.vec<4 x i64> %11 = llvm.insertelement %2, %9[%10 : i64] : !llvm.vec<4 x i64>
%12 = llvm.mlir.constant(3 : i64) : !llvm.i64 %12 = llvm.mlir.constant(3 : i64) : i64
%v = llvm.insertelement %3, %11[%12 : !llvm.i64] : !llvm.vec<4 x i64> %v = llvm.insertelement %3, %11[%12 : i64] : !llvm.vec<4 x i64>
%add = "llvm.intr.vector.reduce.add"(%v) %add = "llvm.intr.vector.reduce.add"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%add) : (!llvm.i64) -> () llvm.call @printI64(%add) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 10 // CHECK: 10
%and = "llvm.intr.vector.reduce.and"(%v) %and = "llvm.intr.vector.reduce.and"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%and) : (!llvm.i64) -> () llvm.call @printI64(%and) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 0 // CHECK: 0
%mul = "llvm.intr.vector.reduce.mul"(%v) %mul = "llvm.intr.vector.reduce.mul"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%mul) : (!llvm.i64) -> () llvm.call @printI64(%mul) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 24 // CHECK: 24
%or = "llvm.intr.vector.reduce.or"(%v) %or = "llvm.intr.vector.reduce.or"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%or) : (!llvm.i64) -> () llvm.call @printI64(%or) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 7 // CHECK: 7
%smax = "llvm.intr.vector.reduce.smax"(%v) %smax = "llvm.intr.vector.reduce.smax"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%smax) : (!llvm.i64) -> () llvm.call @printI64(%smax) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 4 // CHECK: 4
%smin = "llvm.intr.vector.reduce.smin"(%v) %smin = "llvm.intr.vector.reduce.smin"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%smin) : (!llvm.i64) -> () llvm.call @printI64(%smin) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 1 // CHECK: 1
%umax = "llvm.intr.vector.reduce.umax"(%v) %umax = "llvm.intr.vector.reduce.umax"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%umax) : (!llvm.i64) -> () llvm.call @printI64(%umax) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 4 // CHECK: 4
%umin = "llvm.intr.vector.reduce.umin"(%v) %umin = "llvm.intr.vector.reduce.umin"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%umin) : (!llvm.i64) -> () llvm.call @printI64(%umin) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 1 // CHECK: 1
%xor = "llvm.intr.vector.reduce.xor"(%v) %xor = "llvm.intr.vector.reduce.xor"(%v)
: (!llvm.vec<4 x i64>) -> !llvm.i64 : (!llvm.vec<4 x i64>) -> i64
llvm.call @printI64(%xor) : (!llvm.i64) -> () llvm.call @printI64(%xor) : (i64) -> ()
llvm.call @printNewline() : () -> () llvm.call @printNewline() : () -> ()
// CHECK: 4 // CHECK: 4
llvm.return llvm.return
} }
} }

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
/// Async Runtime API function types. /// Async Runtime API function types.
/// ///
/// Because we can't create API function signature for type parametrized /// Because we can't create API function signature for type parametrized
/// async.value type, we use opaque pointers (!llvm.ptr<i8>) instead. After /// async.value type, we use opaque pointers (!llvm.ptr<i8>) instead. After
/// lowering all async data types become opaque pointers at runtime. /// lowering all async data types become opaque pointers at runtime.
struct AsyncAPI { struct AsyncAPI {
// All async types are lowered to opaque i8* LLVM pointers at runtime. // All async types are lowered to opaque i8* LLVM pointers at runtime.
static LLVM::LLVMPointerType opaquePointerType(MLIRContext *ctx) { static LLVM::LLVMPointerType opaquePointerType(MLIRContext *ctx) {
return LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(ctx, 8)); return LLVM::LLVMPointerType::get(IntegerType::get(ctx, 8));
} }
static FunctionType addOrDropRefFunctionType(MLIRContext *ctx) { static FunctionType addOrDropRefFunctionType(MLIRContext *ctx) {
auto ref = opaquePointerType(ctx); auto ref = opaquePointerType(ctx);
auto count = IntegerType::get(ctx, 32); auto count = IntegerType::get(ctx, 32);
return FunctionType::get(ctx, {ref, count}, {}); return FunctionType::get(ctx, {ref, count}, {});
} }
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Linesstatic void addCoroutineIntrinsicsDeclarations(ModuleOp module) {
MLIRContext *ctx = module.getContext(); MLIRContext *ctx = module.getContext();
ImplicitLocOpBuilder builder(module.getLoc(), ImplicitLocOpBuilder builder(module.getLoc(),
module.getBody()->getTerminator()); module.getBody()->getTerminator());
auto token = LLVMTokenType::get(ctx); auto token = LLVMTokenType::get(ctx);
auto voidTy = LLVMVoidType::get(ctx); auto voidTy = LLVMVoidType::get(ctx);
auto i8 = LLVMIntegerType::get(ctx, 8); auto i8 = IntegerType::get(ctx, 8);
auto i1 = LLVMIntegerType::get(ctx, 1); auto i1 = IntegerType::get(ctx, 1);
auto i32 = LLVMIntegerType::get(ctx, 32); auto i32 = IntegerType::get(ctx, 32);
auto i64 = LLVMIntegerType::get(ctx, 64); auto i64 = IntegerType::get(ctx, 64);
auto i8Ptr = LLVMPointerType::get(i8); auto i8Ptr = LLVMPointerType::get(i8);
addLLVMFuncDecl(module, builder, kCoroId, token, {i32, i8Ptr, i8Ptr, i8Ptr}); addLLVMFuncDecl(module, builder, kCoroId, token, {i32, i8Ptr, i8Ptr, i8Ptr});
addLLVMFuncDecl(module, builder, kCoroSizeI64, i64, {}); addLLVMFuncDecl(module, builder, kCoroSizeI64, i64, {});
addLLVMFuncDecl(module, builder, kCoroBegin, i8Ptr, {token, i8Ptr}); addLLVMFuncDecl(module, builder, kCoroBegin, i8Ptr, {token, i8Ptr});
addLLVMFuncDecl(module, builder, kCoroSave, token, {i8Ptr}); addLLVMFuncDecl(module, builder, kCoroSave, token, {i8Ptr});
addLLVMFuncDecl(module, builder, kCoroSuspend, i8, {token, i1}); addLLVMFuncDecl(module, builder, kCoroSuspend, i8, {token, i1});
addLLVMFuncDecl(module, builder, kCoroEnd, i1, {i8Ptr, i1}); addLLVMFuncDecl(module, builder, kCoroEnd, i1, {i8Ptr, i1});
Show All 12 Lines
static void addCRuntimeDeclarations(ModuleOp module) { static void addCRuntimeDeclarations(ModuleOp module) {
using namespace mlir::LLVM; using namespace mlir::LLVM;
MLIRContext *ctx = module.getContext(); MLIRContext *ctx = module.getContext();
ImplicitLocOpBuilder builder(module.getLoc(), ImplicitLocOpBuilder builder(module.getLoc(),
module.getBody()->getTerminator()); module.getBody()->getTerminator());
auto voidTy = LLVMVoidType::get(ctx); auto voidTy = LLVMVoidType::get(ctx);
auto i64 = LLVMIntegerType::get(ctx, 64); auto i64 = IntegerType::get(ctx, 64);
auto i8Ptr = LLVMPointerType::get(LLVMIntegerType::get(ctx, 8)); auto i8Ptr = LLVMPointerType::get(IntegerType::get(ctx, 8));
addLLVMFuncDecl(module, builder, kMalloc, i8Ptr, {i64}); addLLVMFuncDecl(module, builder, kMalloc, i8Ptr, {i64});
addLLVMFuncDecl(module, builder, kFree, voidTy, {i8Ptr}); addLLVMFuncDecl(module, builder, kFree, voidTy, {i8Ptr});
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Coroutine resume function wrapper. // Coroutine resume function wrapper.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static constexpr const char *kResume = "__resume"; static constexpr const char *kResume = "__resume";
/// A function that takes a coroutine handle and calls a `llvm.coro.resume` /// A function that takes a coroutine handle and calls a `llvm.coro.resume`
/// intrinsics. We need this function to be able to pass it to the async /// intrinsics. We need this function to be able to pass it to the async
/// runtime execute API. /// runtime execute API.
static void addResumeFunction(ModuleOp module) { static void addResumeFunction(ModuleOp module) {
MLIRContext *ctx = module.getContext(); MLIRContext *ctx = module.getContext();
OpBuilder moduleBuilder(module.getBody()->getTerminator()); OpBuilder moduleBuilder(module.getBody()->getTerminator());
Location loc = module.getLoc(); Location loc = module.getLoc();
if (module.lookupSymbol(kResume)) if (module.lookupSymbol(kResume))
return; return;
auto voidTy = LLVM::LLVMVoidType::get(ctx); auto voidTy = LLVM::LLVMVoidType::get(ctx);
auto i8Ptr = LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(ctx, 8)); auto i8Ptr = LLVM::LLVMPointerType::get(IntegerType::get(ctx, 8));
auto resumeOp = moduleBuilder.create<LLVM::LLVMFuncOp>( auto resumeOp = moduleBuilder.create<LLVM::LLVMFuncOp>(
loc, kResume, LLVM::LLVMFunctionType::get(voidTy, {i8Ptr})); loc, kResume, LLVM::LLVMFunctionType::get(voidTy, {i8Ptr}));
resumeOp.setPrivate(); resumeOp.setPrivate();
auto *block = resumeOp.addEntryBlock(); auto *block = resumeOp.addEntryBlock();
auto blockBuilder = ImplicitLocOpBuilder::atBlockEnd(loc, block); auto blockBuilder = ImplicitLocOpBuilder::atBlockEnd(loc, block);
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
/// ///
/// ///
static CoroMachinery setupCoroMachinery(FuncOp func) { static CoroMachinery setupCoroMachinery(FuncOp func) {
assert(func.getBody().empty() && "Function must have empty body"); assert(func.getBody().empty() && "Function must have empty body");
MLIRContext *ctx = func.getContext(); MLIRContext *ctx = func.getContext();
auto token = LLVM::LLVMTokenType::get(ctx); auto token = LLVM::LLVMTokenType::get(ctx);
auto i1 = LLVM::LLVMIntegerType::get(ctx, 1); auto i1 = IntegerType::get(ctx, 1);
auto i32 = LLVM::LLVMIntegerType::get(ctx, 32); auto i32 = IntegerType::get(ctx, 32);
auto i64 = LLVM::LLVMIntegerType::get(ctx, 64); auto i64 = IntegerType::get(ctx, 64);
auto i8Ptr = LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(ctx, 8)); auto i8Ptr = LLVM::LLVMPointerType::get(IntegerType::get(ctx, 8));
Block *entryBlock = func.addEntryBlock(); Block *entryBlock = func.addEntryBlock();
Location loc = func.getBody().getLoc(); Location loc = func.getBody().getLoc();
auto builder = ImplicitLocOpBuilder::atBlockBegin(loc, entryBlock); auto builder = ImplicitLocOpBuilder::atBlockBegin(loc, entryBlock);
// ------------------------------------------------------------------------ // // ------------------------------------------------------------------------ //
// Allocate async tokens/values that we will return from a ramp function. // Allocate async tokens/values that we will return from a ramp function.
Show All 12 Lines auto sizeOf = [&](ValueType valueType) -> Value {
// %Size = getelementptr %T* null, int 1 // %Size = getelementptr %T* null, int 1
// %SizeI = ptrtoint %T* %Size to i32 // %SizeI = ptrtoint %T* %Size to i32
auto nullPtr = builder.create<LLVM::NullOp>(loc, storagePtrType); auto nullPtr = builder.create<LLVM::NullOp>(loc, storagePtrType);
auto one = builder.create<LLVM::ConstantOp>(loc, i32, auto one = builder.create<LLVM::ConstantOp>(loc, i32,
builder.getI32IntegerAttr(1)); builder.getI32IntegerAttr(1));
auto gep = builder.create<LLVM::GEPOp>(loc, storagePtrType, nullPtr, auto gep = builder.create<LLVM::GEPOp>(loc, storagePtrType, nullPtr,
one.getResult()); one.getResult());
auto size = builder.create<LLVM::PtrToIntOp>(loc, i32, gep); return builder.create<LLVM::PtrToIntOp>(loc, i32, gep);
// Cast to std type because runtime API defined using std types.
return builder.create<LLVM::DialectCastOp>(loc, builder.getI32Type(),
size.getResult());
}; };
// We use the `async.value` type as a return type although it does not match // We use the `async.value` type as a return type although it does not match
// the `kCreateValue` function signature, because it will be later lowered to // the `kCreateValue` function signature, because it will be later lowered to
// the runtime type (opaque i8* pointer). // the runtime type (opaque i8* pointer).
llvm::SmallVector<CallOp, 4> createValues; llvm::SmallVector<CallOp, 4> createValues;
for (auto resultType : func.getCallableResults().drop_front(1)) for (auto resultType : func.getCallableResults().drop_front(1))
createValues.emplace_back(builder.create<CallOp>( createValues.emplace_back(builder.create<CallOp>(
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
/// ^cleanup: ... /// ^cleanup: ...
/// ^suspend: ... /// ^suspend: ...
/// ///
static void addSuspensionPoint(CoroMachinery coro, Value coroState, static void addSuspensionPoint(CoroMachinery coro, Value coroState,
Operation *op, Block *suspended, Block *resume, Operation *op, Block *suspended, Block *resume,
OpBuilder &builder) { OpBuilder &builder) {
Location loc = op->getLoc(); Location loc = op->getLoc();
MLIRContext *ctx = op->getContext(); MLIRContext *ctx = op->getContext();
auto i1 = LLVM::LLVMIntegerType::get(ctx, 1); auto i1 = IntegerType::get(ctx, 1);
auto i8 = LLVM::LLVMIntegerType::get(ctx, 8); auto i8 = IntegerType::get(ctx, 8);
// Add a coroutine suspension in place of original `op` in the split block. // Add a coroutine suspension in place of original `op` in the split block.
OpBuilder::InsertionGuard guard(builder); OpBuilder::InsertionGuard guard(builder);
builder.setInsertionPointToEnd(suspended); builder.setInsertionPointToEnd(suspended);
auto constFalse = auto constFalse =
builder.create<LLVM::ConstantOp>(loc, i1, builder.getBoolAttr(false)); builder.create<LLVM::ConstantOp>(loc, i1, builder.getBoolAttr(false));
▲ Show 20 Lines • Show All 604 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUCommon/ConvertLaunchFuncToRuntimeCalls.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linespublic:
explicit ConvertOpToGpuRuntimeCallPattern(LLVMTypeConverter &typeConverter) explicit ConvertOpToGpuRuntimeCallPattern(LLVMTypeConverter &typeConverter)
: ConvertOpToLLVMPattern<OpTy>(typeConverter) {} : ConvertOpToLLVMPattern<OpTy>(typeConverter) {}
protected: protected:
MLIRContext *context = &this->getTypeConverter()->getContext(); MLIRContext *context = &this->getTypeConverter()->getContext();
Type llvmVoidType = LLVM::LLVMVoidType::get(context); Type llvmVoidType = LLVM::LLVMVoidType::get(context);
Type llvmPointerType = Type llvmPointerType =
LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8)); LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
Type llvmPointerPointerType = LLVM::LLVMPointerType::get(llvmPointerType); Type llvmPointerPointerType = LLVM::LLVMPointerType::get(llvmPointerType);
Type llvmInt8Type = LLVM::LLVMIntegerType::get(context, 8); Type llvmInt8Type = IntegerType::get(context, 8);
Type llvmInt32Type = LLVM::LLVMIntegerType::get(context, 32); Type llvmInt32Type = IntegerType::get(context, 32);
Type llvmInt64Type = LLVM::LLVMIntegerType::get(context, 64); Type llvmInt64Type = IntegerType::get(context, 64);
Type llvmIntPtrType = LLVM::LLVMIntegerType::get( Type llvmIntPtrType = IntegerType::get(
context, this->getTypeConverter()->getPointerBitwidth(0)); context, this->getTypeConverter()->getPointerBitwidth(0));
FunctionCallBuilder moduleLoadCallBuilder = { FunctionCallBuilder moduleLoadCallBuilder = {
"mgpuModuleLoad", "mgpuModuleLoad",
llvmPointerType /* void *module */, llvmPointerType /* void *module */,
{llvmPointerType /* void *cubin */}}; {llvmPointerType /* void *cubin */}};
FunctionCallBuilder moduleUnloadCallBuilder = { FunctionCallBuilder moduleUnloadCallBuilder = {
"mgpuModuleUnload", llvmVoidType, {llvmPointerType /* void *module */}}; "mgpuModuleUnload", llvmVoidType, {llvmPointerType /* void *module */}};
▲ Show 20 Lines • Show All 619 Lines • ▼ Show 20 Lines
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
mlir::createGpuToLLVMConversionPass(StringRef gpuBinaryAnnotation) { mlir::createGpuToLLVMConversionPass(StringRef gpuBinaryAnnotation) {
return std::make_unique<GpuToLLVMConversionPass>(gpuBinaryAnnotation); return std::make_unique<GpuToLLVMConversionPass>(gpuBinaryAnnotation);
} }
void mlir::populateGpuToLLVMConversionPatterns( void mlir::populateGpuToLLVMConversionPatterns(
LLVMTypeConverter &converter, OwningRewritePatternList &patterns, LLVMTypeConverter &converter, OwningRewritePatternList &patterns,
StringRef gpuBinaryAnnotation) { StringRef gpuBinaryAnnotation) {
converter.addConversion([context = &converter.getContext()]( converter.addConversion(
gpu::AsyncTokenType type) -> Type { [context = &converter.getContext()](gpu::AsyncTokenType type) -> Type {
return LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8)); return LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
}); });
patterns.insert<ConvertAllocOpToGpuRuntimeCallPattern, patterns.insert<ConvertAllocOpToGpuRuntimeCallPattern,
ConvertDeallocOpToGpuRuntimeCallPattern, ConvertDeallocOpToGpuRuntimeCallPattern,
ConvertHostRegisterOpToGpuRuntimeCallPattern, ConvertHostRegisterOpToGpuRuntimeCallPattern,
ConvertMemcpyOpToGpuRuntimeCallPattern, ConvertMemcpyOpToGpuRuntimeCallPattern,
ConvertWaitAsyncOpToGpuRuntimeCallPattern, ConvertWaitAsyncOpToGpuRuntimeCallPattern,
ConvertWaitOpToGpuRuntimeCallPattern>(converter); ConvertWaitOpToGpuRuntimeCallPattern>(converter);
patterns.insert<ConvertLaunchFuncOpToGpuRuntimeCallPattern>( patterns.insert<ConvertLaunchFuncOpToGpuRuntimeCallPattern>(
converter, gpuBinaryAnnotation); converter, gpuBinaryAnnotation);
patterns.insert<EraseGpuModuleOpPattern>(&converter.getContext()); patterns.insert<EraseGpuModuleOpPattern>(&converter.getContext());
} }

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines auto llvmFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
// the original function, before the body region is inlined in the new // the original function, before the body region is inlined in the new
// function to maintain the relation between block arguments and the // function to maintain the relation between block arguments and the
// parent operation that assigns their semantics. // parent operation that assigns their semantics.
OpBuilder::InsertionGuard guard(rewriter); OpBuilder::InsertionGuard guard(rewriter);
// Rewrite workgroup memory attributions to addresses of global buffers. // Rewrite workgroup memory attributions to addresses of global buffers.
rewriter.setInsertionPointToStart(&gpuFuncOp.front()); rewriter.setInsertionPointToStart(&gpuFuncOp.front());
unsigned numProperArguments = gpuFuncOp.getNumArguments(); unsigned numProperArguments = gpuFuncOp.getNumArguments();
auto i32Type = LLVM::LLVMIntegerType::get(rewriter.getContext(), 32); auto i32Type = IntegerType::get(rewriter.getContext(), 32);
Value zero = nullptr; Value zero = nullptr;
if (!workgroupBuffers.empty()) if (!workgroupBuffers.empty())
zero = rewriter.create<LLVM::ConstantOp>(loc, i32Type, zero = rewriter.create<LLVM::ConstantOp>(loc, i32Type,
rewriter.getI32IntegerAttr(0)); rewriter.getI32IntegerAttr(0));
for (auto en : llvm::enumerate(workgroupBuffers)) { for (auto en : llvm::enumerate(workgroupBuffers)) {
LLVM::GlobalOp global = en.value(); LLVM::GlobalOp global = en.value();
Value address = rewriter.create<LLVM::AddressOfOp>(loc, global); Value address = rewriter.create<LLVM::AddressOfOp>(loc, global);
Show All 12 Lines auto llvmFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
auto descr = MemRefDescriptor::fromStaticShape( auto descr = MemRefDescriptor::fromStaticShape(
rewriter, loc, *getTypeConverter(), type, memory); rewriter, loc, *getTypeConverter(), type, memory);
signatureConversion.remapInput(numProperArguments + en.index(), descr); signatureConversion.remapInput(numProperArguments + en.index(), descr);
} }
// Rewrite private memory attributions to alloca'ed buffers. // Rewrite private memory attributions to alloca'ed buffers.
unsigned numWorkgroupAttributions = unsigned numWorkgroupAttributions =
gpuFuncOp.getNumWorkgroupAttributions(); gpuFuncOp.getNumWorkgroupAttributions();
auto int64Ty = LLVM::LLVMIntegerType::get(rewriter.getContext(), 64); auto int64Ty = IntegerType::get(rewriter.getContext(), 64);
for (auto en : llvm::enumerate(gpuFuncOp.getPrivateAttributions())) { for (auto en : llvm::enumerate(gpuFuncOp.getPrivateAttributions())) {
Value attribution = en.value(); Value attribution = en.value();
auto type = attribution.getType().cast<MemRefType>(); auto type = attribution.getType().cast<MemRefType>();
assert(type && type.hasStaticShape() && assert(type && type.hasStaticShape() &&
"unexpected type in attribution"); "unexpected type in attribution");
// Explicitly drop memory space when lowering private memory // Explicitly drop memory space when lowering private memory
// attributions since NVVM models it as `alloca`s in the default // attributions since NVVM models it as `alloca`s in the default
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUCommon/IndexIntrinsicsOpLowering.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linespublic:
LogicalResult LogicalResult
matchAndRewrite(Op op, ArrayRef<Value> operands, matchAndRewrite(Op op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
auto loc = op->getLoc(); auto loc = op->getLoc();
MLIRContext *context = rewriter.getContext(); MLIRContext *context = rewriter.getContext();
Value newOp; Value newOp;
switch (dimensionToIndex(op)) { switch (dimensionToIndex(op)) {
case X: case X:
newOp = newOp = rewriter.create<XOp>(loc, IntegerType::get(context, 32));
rewriter.create<XOp>(loc, LLVM::LLVMIntegerType::get(context, 32));
break; break;
case Y: case Y:
newOp = newOp = rewriter.create<YOp>(loc, IntegerType::get(context, 32));
rewriter.create<YOp>(loc, LLVM::LLVMIntegerType::get(context, 32));
break; break;
case Z: case Z:
newOp = newOp = rewriter.create<ZOp>(loc, IntegerType::get(context, 32));
rewriter.create<ZOp>(loc, LLVM::LLVMIntegerType::get(context, 32));
break; break;
default: default:
return failure(); return failure();
} }
if (indexBitwidth > 32) { if (indexBitwidth > 32) {
newOp = rewriter.create<LLVM::SExtOp>( newOp = rewriter.create<LLVM::SExtOp>(
loc, LLVM::LLVMIntegerType::get(context, indexBitwidth), newOp); loc, IntegerType::get(context, indexBitwidth), newOp);
} else if (indexBitwidth < 32) { } else if (indexBitwidth < 32) {
newOp = rewriter.create<LLVM::TruncOp>( newOp = rewriter.create<LLVM::TruncOp>(
loc, LLVM::LLVMIntegerType::get(context, indexBitwidth), newOp); loc, IntegerType::get(context, indexBitwidth), newOp);
} }
rewriter.replaceOp(op, {newOp}); rewriter.replaceOp(op, {newOp});
return success(); return success();
} }
}; };
} // namespace mlir } // namespace mlir
#endif // MLIR_CONVERSION_GPUCOMMON_INDEXINTRINSICSOPLOWERING_H_ #endif // MLIR_CONVERSION_GPUCOMMON_INDEXINTRINSICSOPLOWERING_H_

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

Show All 34 Linesstruct GPUShuffleOpLowering : public ConvertOpToLLVMPattern<gpu::ShuffleOp> {
using ConvertOpToLLVMPattern<gpu::ShuffleOp>::ConvertOpToLLVMPattern; using ConvertOpToLLVMPattern<gpu::ShuffleOp>::ConvertOpToLLVMPattern;
/// Lowers a shuffle to the corresponding NVVM op. /// Lowers a shuffle to the corresponding NVVM op.
/// ///
/// Convert the `width` argument into an activeMask (a bitmask which specifies /// Convert the `width` argument into an activeMask (a bitmask which specifies
/// which threads participate in the shuffle) and a maskAndClamp (specifying /// which threads participate in the shuffle) and a maskAndClamp (specifying
/// the highest lane which participates in the shuffle). /// the highest lane which participates in the shuffle).
/// ///
/// %one = llvm.constant(1 : i32) : !llvm.i32 /// %one = llvm.constant(1 : i32) : i32
/// %shl = llvm.shl %one, %width : !llvm.i32 /// %shl = llvm.shl %one, %width : i32
/// %active_mask = llvm.sub %shl, %one : !llvm.i32 /// %active_mask = llvm.sub %shl, %one : i32
/// %mask_and_clamp = llvm.sub %width, %one : !llvm.i32 /// %mask_and_clamp = llvm.sub %width, %one : i32
/// %shfl = nvvm.shfl.sync.bfly %active_mask, %value, %offset, /// %shfl = nvvm.shfl.sync.bfly %active_mask, %value, %offset,
/// %mask_and_clamp : !llvm<"{ float, i1 }"> /// %mask_and_clamp : !llvm<"{ float, i1 }">
/// %shfl_value = llvm.extractvalue %shfl[0 : index] : /// %shfl_value = llvm.extractvalue %shfl[0 : index] :
/// !llvm<"{ float, i1 }"> /// !llvm<"{ float, i1 }">
/// %shfl_pred = llvm.extractvalue %shfl[1 : index] : /// %shfl_pred = llvm.extractvalue %shfl[1 : index] :
/// !llvm<"{ float, i1 }"> /// !llvm<"{ float, i1 }">
LogicalResult LogicalResult
matchAndRewrite(gpu::ShuffleOp op, ArrayRef<Value> operands, matchAndRewrite(gpu::ShuffleOp op, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
Location loc = op->getLoc(); Location loc = op->getLoc();
gpu::ShuffleOpAdaptor adaptor(operands); gpu::ShuffleOpAdaptor adaptor(operands);
auto valueTy = adaptor.value().getType(); auto valueTy = adaptor.value().getType();
auto int32Type = LLVM::LLVMIntegerType::get(rewriter.getContext(), 32); auto int32Type = IntegerType::get(rewriter.getContext(), 32);
auto predTy = LLVM::LLVMIntegerType::get(rewriter.getContext(), 1); auto predTy = IntegerType::get(rewriter.getContext(), 1);
auto resultTy = LLVM::LLVMStructType::getLiteral(rewriter.getContext(), auto resultTy = LLVM::LLVMStructType::getLiteral(rewriter.getContext(),
{valueTy, predTy}); {valueTy, predTy});
Value one = rewriter.create<LLVM::ConstantOp>( Value one = rewriter.create<LLVM::ConstantOp>(
loc, int32Type, rewriter.getI32IntegerAttr(1)); loc, int32Type, rewriter.getI32IntegerAttr(1));
// Bit mask of active lanes: `(1 << activeWidth) - 1`. // Bit mask of active lanes: `(1 << activeWidth) - 1`.
Value activeMask = rewriter.create<LLVM::SubOp>( Value activeMask = rewriter.create<LLVM::SubOp>(
loc, int32Type, loc, int32Type,
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
/// ///
class VulkanLaunchFuncToVulkanCallsPass class VulkanLaunchFuncToVulkanCallsPass
: public ConvertVulkanLaunchFuncToVulkanCallsBase< : public ConvertVulkanLaunchFuncToVulkanCallsBase<
VulkanLaunchFuncToVulkanCallsPass> { VulkanLaunchFuncToVulkanCallsPass> {
private: private:
void initializeCachedTypes() { void initializeCachedTypes() {
llvmFloatType = LLVM::LLVMFloatType::get(&getContext()); llvmFloatType = LLVM::LLVMFloatType::get(&getContext());
llvmVoidType = LLVM::LLVMVoidType::get(&getContext()); llvmVoidType = LLVM::LLVMVoidType::get(&getContext());
llvmPointerType = LLVM::LLVMPointerType::get( llvmPointerType =
LLVM::LLVMIntegerType::get(&getContext(), 8)); LLVM::LLVMPointerType::get(IntegerType::get(&getContext(), 8));
llvmInt32Type = LLVM::LLVMIntegerType::get(&getContext(), 32); llvmInt32Type = IntegerType::get(&getContext(), 32);
llvmInt64Type = LLVM::LLVMIntegerType::get(&getContext(), 64); llvmInt64Type = IntegerType::get(&getContext(), 64);
} }
Type getMemRefType(uint32_t rank, Type elemenType) { Type getMemRefType(uint32_t rank, Type elemenType) {
// According to the MLIR doc memref argument is converted into a // According to the MLIR doc memref argument is converted into a
// pointer-to-struct argument of type: // pointer-to-struct argument of type:
// template <typename Elem, size_t Rank> // template <typename Elem, size_t Rank>
// struct { // struct {
// Elem *allocated; // Elem *allocated;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines LogicalResult deduceMemRefRankAndType(Value ptrToMemRefDescriptor,
uint32_t &rank, Type &type); uint32_t &rank, Type &type);
/// Returns a string representation from the given `type`. /// Returns a string representation from the given `type`.
StringRef stringifyType(Type type) { StringRef stringifyType(Type type) {
if (type.isa<LLVM::LLVMFloatType>()) if (type.isa<LLVM::LLVMFloatType>())
return "Float"; return "Float";
if (type.isa<LLVM::LLVMHalfType>()) if (type.isa<LLVM::LLVMHalfType>())
return "Half"; return "Half";
if (auto intType = type.dyn_cast<LLVM::LLVMIntegerType>()) { if (auto intType = type.dyn_cast<IntegerType>()) {
if (intType.getBitWidth() == 32) if (intType.getWidth() == 32)
return "Int32"; return "Int32";
if (intType.getBitWidth() == 16) if (intType.getWidth() == 16)
return "Int16"; return "Int16";
if (intType.getBitWidth() == 8) if (intType.getWidth() == 8)
return "Int8"; return "Int8";
} }
llvm_unreachable("unsupported type"); llvm_unreachable("unsupported type");
} }
public: public:
void runOnOperation() override; void runOnOperation() override;
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines if (failed(deduceMemRefRankAndType(ptrToMemRefDescriptor, rank, type))) {
return signalPassFailure(); return signalPassFailure();
} }
auto symbolName = auto symbolName =
llvm::formatv("bindMemRef{0}D{1}", rank, stringifyType(type)).str(); llvm::formatv("bindMemRef{0}D{1}", rank, stringifyType(type)).str();
// Special case for fp16 type. Since it is not a supported type in C we use // Special case for fp16 type. Since it is not a supported type in C we use
// int16_t and bitcast the descriptor. // int16_t and bitcast the descriptor.
if (type.isa<LLVM::LLVMHalfType>()) { if (type.isa<LLVM::LLVMHalfType>()) {
auto memRefTy = auto memRefTy = getMemRefType(rank, IntegerType::get(&getContext(), 16));
getMemRefType(rank, LLVM::LLVMIntegerType::get(&getContext(), 16));
ptrToMemRefDescriptor = builder.create<LLVM::BitcastOp>( ptrToMemRefDescriptor = builder.create<LLVM::BitcastOp>(
loc, LLVM::LLVMPointerType::get(memRefTy), ptrToMemRefDescriptor); loc, LLVM::LLVMPointerType::get(memRefTy), ptrToMemRefDescriptor);
} }
// Create call to `bindMemRef`. // Create call to `bindMemRef`.
builder.create<LLVM::CallOp>( builder.create<LLVM::CallOp>(
loc, TypeRange{getVoidType()}, loc, TypeRange{getVoidType()},
builder.getSymbolRefAttr( builder.getSymbolRefAttr(
StringRef(symbolName.data(), symbolName.size())), StringRef(symbolName.data(), symbolName.size())),
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesvoid VulkanLaunchFuncToVulkanCallsPass::declareVulkanFunctions(Location loc) {
if (!module.lookupSymbol(kRunOnVulkan)) { if (!module.lookupSymbol(kRunOnVulkan)) {
builder.create<LLVM::LLVMFuncOp>( builder.create<LLVM::LLVMFuncOp>(
loc, kRunOnVulkan, loc, kRunOnVulkan,
LLVM::LLVMFunctionType::get(getVoidType(), {getPointerType()})); LLVM::LLVMFunctionType::get(getVoidType(), {getPointerType()}));
} }
for (unsigned i = 1; i <= 3; i++) { for (unsigned i = 1; i <= 3; i++) {
SmallVector<Type, 5> types{LLVM::LLVMFloatType::get(&getContext()), SmallVector<Type, 5> types{LLVM::LLVMFloatType::get(&getContext()),
LLVM::LLVMIntegerType::get(&getContext(), 32), IntegerType::get(&getContext(), 32),
LLVM::LLVMIntegerType::get(&getContext(), 16), IntegerType::get(&getContext(), 16),
LLVM::LLVMIntegerType::get(&getContext(), 8), IntegerType::get(&getContext(), 8),
LLVM::LLVMHalfType::get(&getContext())}; LLVM::LLVMHalfType::get(&getContext())};
for (auto type : types) { for (auto type : types) {
std::string fnName = "bindMemRef" + std::to_string(i) + "D" + std::string fnName = "bindMemRef" + std::to_string(i) + "D" +
std::string(stringifyType(type)); std::string(stringifyType(type));
if (type.isa<LLVM::LLVMHalfType>()) if (type.isa<LLVM::LLVMHalfType>())
type = LLVM::LLVMIntegerType::get(&getContext(), 16); type = IntegerType::get(&getContext(), 16);
if (!module.lookupSymbol(fnName)) { if (!module.lookupSymbol(fnName)) {
auto fnType = LLVM::LLVMFunctionType::get( auto fnType = LLVM::LLVMFunctionType::get(
getVoidType(), getVoidType(),
{getPointerType(), getInt32Type(), getInt32Type(), {getPointerType(), getInt32Type(), getInt32Type(),
LLVM::LLVMPointerType::get(getMemRefType(i, type))}, LLVM::LLVMPointerType::get(getMemRefType(i, type))},
/*isVarArg=*/false); /*isVarArg=*/false);
builder.create<LLVM::LLVMFuncOp>(loc, fnName, fnType); builder.create<LLVM::LLVMFuncOp>(loc, fnName, fnType);
} }
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesstatic unsigned calculateGlobalIndex(spirv::GlobalVariableOp op) {
IntegerAttr binding = op->getAttrOfType<IntegerAttr>(bindingName()); IntegerAttr binding = op->getAttrOfType<IntegerAttr>(bindingName());
return binding.getInt(); return binding.getInt();
} }
/// Copies the given number of bytes from src to dst pointers. /// Copies the given number of bytes from src to dst pointers.
static void copy(Location loc, Value dst, Value src, Value size, static void copy(Location loc, Value dst, Value src, Value size,
OpBuilder &builder) { OpBuilder &builder) {
MLIRContext *context = builder.getContext(); MLIRContext *context = builder.getContext();
auto llvmI1Type = LLVM::LLVMIntegerType::get(context, 1); auto llvmI1Type = IntegerType::get(context, 1);
Value isVolatile = builder.create<LLVM::ConstantOp>( Value isVolatile = builder.create<LLVM::ConstantOp>(
loc, llvmI1Type, builder.getBoolAttr(false)); loc, llvmI1Type, builder.getBoolAttr(false));
builder.create<LLVM::MemcpyOp>(loc, dst, src, size, isVolatile); builder.create<LLVM::MemcpyOp>(loc, dst, src, size, isVolatile);
} }
/// Encodes the binding and descriptor set numbers into a new symbolic name. /// Encodes the binding and descriptor set numbers into a new symbolic name.
/// The name is specified by /// The name is specified by
/// {kernel_module_name}_{variable_name}_descriptor_set{ds}_binding{b} /// {kernel_module_name}_{variable_name}_descriptor_set{ds}_binding{b}
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines assert(elementType.isIntOrFloat() &&
"only integers and floats have a bitwidth"); "only integers and floats have a bitwidth");
return elementType.getIntOrFloatBitWidth(); return elementType.getIntOrFloatBitWidth();
} }
/// Returns the bit width of LLVMType integer or vector. /// Returns the bit width of LLVMType integer or vector.
static unsigned getLLVMTypeBitWidth(Type type) { static unsigned getLLVMTypeBitWidth(Type type) {
auto vectorType = type.dyn_cast<LLVM::LLVMVectorType>(); auto vectorType = type.dyn_cast<LLVM::LLVMVectorType>();
return (vectorType ? vectorType.getElementType() : type) return (vectorType ? vectorType.getElementType() : type)
.cast<LLVM::LLVMIntegerType>() .cast<IntegerType>()
.getBitWidth(); .getWidth();
} }
/// Creates `IntegerAttribute` with all bits set for given type /// Creates `IntegerAttribute` with all bits set for given type
static IntegerAttr minusOneIntegerAttribute(Type type, Builder builder) { static IntegerAttr minusOneIntegerAttribute(Type type, Builder builder) {
if (auto vecType = type.dyn_cast<VectorType>()) { if (auto vecType = type.dyn_cast<VectorType>()) {
auto integerType = vecType.getElementType().cast<IntegerType>(); auto integerType = vecType.getElementType().cast<IntegerType>();
return builder.getIntegerAttr(integerType, -1); return builder.getIntegerAttr(integerType, -1);
} }
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Linesstatic Type convertStructTypePacked(spirv::StructType type,
return LLVM::LLVMStructType::getLiteral(type.getContext(), elementsVector, return LLVM::LLVMStructType::getLiteral(type.getContext(), elementsVector,
/*isPacked=*/true); /*isPacked=*/true);
} }
/// Creates LLVM dialect constant with the given value. /// Creates LLVM dialect constant with the given value.
static Value createI32ConstantOf(Location loc, PatternRewriter &rewriter, static Value createI32ConstantOf(Location loc, PatternRewriter &rewriter,
unsigned value) { unsigned value) {
return rewriter.create<LLVM::ConstantOp>( return rewriter.create<LLVM::ConstantOp>(
loc, LLVM::LLVMIntegerType::get(rewriter.getContext(), 32), loc, IntegerType::get(rewriter.getContext(), 32),
rewriter.getIntegerAttr(rewriter.getI32Type(), value)); rewriter.getIntegerAttr(rewriter.getI32Type(), value));
} }
/// Utility for `spv.Load` and `spv.Store` conversion. /// Utility for `spv.Load` and `spv.Store` conversion.
static LogicalResult replaceWithLoadOrStore(Operation *op, static LogicalResult replaceWithLoadOrStore(Operation *op,
ConversionPatternRewriter &rewriter, ConversionPatternRewriter &rewriter,
LLVMTypeConverter &typeConverter, LLVMTypeConverter &typeConverter,
unsigned alignment, bool isVolatile, unsigned alignment, bool isVolatile,
▲ Show 20 Lines • Show All 431 Lines • ▼ Show 20 Lines matchAndRewrite(spirv::ExecutionModeOp op, ArrayRef<Value> operands,
OpBuilder::InsertionGuard guard(rewriter); OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToStart(module.getBody()); rewriter.setInsertionPointToStart(module.getBody());
// Create a struct type, corresponding to the C struct below. // Create a struct type, corresponding to the C struct below.
// struct { // struct {
// int32_t executionMode; // int32_t executionMode;
// int32_t values[]; // optional values // int32_t values[]; // optional values
// }; // };
auto llvmI32Type = LLVM::LLVMIntegerType::get(context, 32); auto llvmI32Type = IntegerType::get(context, 32);
SmallVector<Type, 2> fields; SmallVector<Type, 2> fields;
fields.push_back(llvmI32Type); fields.push_back(llvmI32Type);
ArrayAttr values = op.values(); ArrayAttr values = op.values();
if (!values.empty()) { if (!values.empty()) {
auto arrayType = LLVM::LLVMArrayType::get(llvmI32Type, values.size()); auto arrayType = LLVM::LLVMArrayType::get(llvmI32Type, values.size());
fields.push_back(arrayType); fields.push_back(arrayType);
} }
auto structType = LLVM::LLVMStructType::getLiteral(context, fields); auto structType = LLVM::LLVMStructType::getLiteral(context, fields);
▲ Show 20 Lines • Show All 884 Lines • Show Last 20 Lines

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
} }
/// Returns the MLIR context. /// Returns the MLIR context.
MLIRContext &LLVMTypeConverter::getContext() { MLIRContext &LLVMTypeConverter::getContext() {
return *getDialect()->getContext(); return *getDialect()->getContext();
} }
Type LLVMTypeConverter::getIndexType() { Type LLVMTypeConverter::getIndexType() {
return LLVM::LLVMIntegerType::get(&getContext(), getIndexTypeBitwidth()); return IntegerType::get(&getContext(), getIndexTypeBitwidth());
} }
unsigned LLVMTypeConverter::getPointerBitwidth(unsigned addressSpace) { unsigned LLVMTypeConverter::getPointerBitwidth(unsigned addressSpace) {
return options.dataLayout.getPointerSizeInBits(addressSpace); return options.dataLayout.getPointerSizeInBits(addressSpace);
} }
Type LLVMTypeConverter::convertIndexType(IndexType type) { Type LLVMTypeConverter::convertIndexType(IndexType type) {
return getIndexType(); return getIndexType();
} }
Type LLVMTypeConverter::convertIntegerType(IntegerType type) { Type LLVMTypeConverter::convertIntegerType(IntegerType type) {
return LLVM::LLVMIntegerType::get(&getContext(), type.getWidth()); return IntegerType::get(&getContext(), type.getWidth());
} }
Type LLVMTypeConverter::convertFloatType(FloatType type) { Type LLVMTypeConverter::convertFloatType(FloatType type) {
if (type.isa<Float32Type>()) if (type.isa<Float32Type>())
return LLVM::LLVMFloatType::get(&getContext()); return LLVM::LLVMFloatType::get(&getContext());
if (type.isa<Float64Type>()) if (type.isa<Float64Type>())
return LLVM::LLVMDoubleType::get(&getContext()); return LLVM::LLVMDoubleType::get(&getContext());
if (type.isa<Float16Type>()) if (type.isa<Float16Type>())
▲ Show 20 Lines • Show All 158 Lines • ▼ Show 20 Lines
/// Convert an unranked memref type into a list of non-aggregate LLVM IR types /// Convert an unranked memref type into a list of non-aggregate LLVM IR types
/// that will form the unranked memref descriptor. In particular, the fields /// that will form the unranked memref descriptor. In particular, the fields
/// for an unranked memref descriptor are: /// for an unranked memref descriptor are:
/// 1. index-typed rank, the dynamic rank of this MemRef /// 1. index-typed rank, the dynamic rank of this MemRef
/// 2. void* ptr, pointer to the static ranked MemRef descriptor. This will be /// 2. void* ptr, pointer to the static ranked MemRef descriptor. This will be
/// stack allocated (alloca) copy of a MemRef descriptor that got casted to /// stack allocated (alloca) copy of a MemRef descriptor that got casted to
/// be unranked. /// be unranked.
SmallVector<Type, 2> LLVMTypeConverter::getUnrankedMemRefDescriptorFields() { SmallVector<Type, 2> LLVMTypeConverter::getUnrankedMemRefDescriptorFields() {
return {getIndexType(), LLVM::LLVMPointerType::get( return {getIndexType(),
LLVM::LLVMIntegerType::get(&getContext(), 8))}; LLVM::LLVMPointerType::get(IntegerType::get(&getContext(), 8))};
} }
Type LLVMTypeConverter::convertUnrankedMemRefType(UnrankedMemRefType type) { Type LLVMTypeConverter::convertUnrankedMemRefType(UnrankedMemRefType type) {
return LLVM::LLVMStructType::getLiteral(&getContext(), return LLVM::LLVMStructType::getLiteral(&getContext(),
getUnrankedMemRefDescriptorFields()); getUnrankedMemRefDescriptorFields());
} }
/// Convert a memref type to a bare pointer to the memref element type. /// Convert a memref type to a bare pointer to the memref element type.
▲ Show 20 Lines • Show All 642 Lines • ▼ Show 20 LinesLLVM::LLVMDialect &ConvertToLLVMPattern::getDialect() const {
return *getTypeConverter()->getDialect(); return *getTypeConverter()->getDialect();
} }
Type ConvertToLLVMPattern::getIndexType() const { Type ConvertToLLVMPattern::getIndexType() const {
return getTypeConverter()->getIndexType(); return getTypeConverter()->getIndexType();
} }
Type ConvertToLLVMPattern::getIntPtrType(unsigned addressSpace) const { Type ConvertToLLVMPattern::getIntPtrType(unsigned addressSpace) const {
return LLVM::LLVMIntegerType::get( return IntegerType::get(&getTypeConverter()->getContext(),
&getTypeConverter()->getContext(),
getTypeConverter()->getPointerBitwidth(addressSpace)); getTypeConverter()->getPointerBitwidth(addressSpace));
} }
Type ConvertToLLVMPattern::getVoidType() const { Type ConvertToLLVMPattern::getVoidType() const {
return LLVM::LLVMVoidType::get(&getTypeConverter()->getContext()); return LLVM::LLVMVoidType::get(&getTypeConverter()->getContext());
} }
Type ConvertToLLVMPattern::getVoidPtrType() const { Type ConvertToLLVMPattern::getVoidPtrType() const {
return LLVM::LLVMPointerType::get( return LLVM::LLVMPointerType::get(
LLVM::LLVMIntegerType::get(&getTypeConverter()->getContext(), 8)); IntegerType::get(&getTypeConverter()->getContext(), 8));
} }
Value ConvertToLLVMPattern::createIndexConstant( Value ConvertToLLVMPattern::createIndexConstant(
ConversionPatternRewriter &builder, Location loc, uint64_t value) const { ConversionPatternRewriter &builder, Location loc, uint64_t value) const {
return createIndexAttrConstant(builder, loc, getIndexType(), value); return createIndexAttrConstant(builder, loc, getIndexType(), value);
} }
Value ConvertToLLVMPattern::getStridedElementPtr( Value ConvertToLLVMPattern::getStridedElementPtr(
▲ Show 20 Lines • Show All 1,148 Lines • ▼ Show 20 Linesstatic LogicalResult copyUnrankedDescriptors(OpBuilder &builder, Location loc,
// Compute allocation sizes. // Compute allocation sizes.
SmallVector<Value, 4> sizes; SmallVector<Value, 4> sizes;
UnrankedMemRefDescriptor::computeSizes(builder, loc, typeConverter, UnrankedMemRefDescriptor::computeSizes(builder, loc, typeConverter,
unrankedMemrefs, sizes); unrankedMemrefs, sizes);
// Get frequently used types. // Get frequently used types.
MLIRContext *context = builder.getContext(); MLIRContext *context = builder.getContext();
auto voidType = LLVM::LLVMVoidType::get(context); auto voidType = LLVM::LLVMVoidType::get(context);
Type voidPtrType = Type voidPtrType = LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
LLVM::LLVMPointerType::get(LLVM::LLVMIntegerType::get(context, 8)); auto i1Type = IntegerType::get(context, 1);
auto i1Type = LLVM::LLVMIntegerType::get(context, 1);
Type indexType = typeConverter.getIndexType(); Type indexType = typeConverter.getIndexType();
// Find the malloc and free, or declare them if necessary. // Find the malloc and free, or declare them if necessary.
auto module = builder.getInsertionPoint()->getParentOfType<ModuleOp>(); auto module = builder.getInsertionPoint()->getParentOfType<ModuleOp>();
auto mallocFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("malloc"); auto mallocFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("malloc");
if (!mallocFunc && toDynamic) { if (!mallocFunc && toDynamic) {
OpBuilder::InsertionGuard guard(builder); OpBuilder::InsertionGuard guard(builder);
builder.setInsertionPointToStart(module.getBody()); builder.setInsertionPointToStart(module.getBody());
▲ Show 20 Lines • Show All 622 Lines • ▼ Show 20 Lines convertSourceMemRefToDescriptor(ConversionPatternRewriter &rewriter,
rewriter.create<LLVM::BrOp>(loc, ValueRange({resultRankMinusOne, oneIndex}), rewriter.create<LLVM::BrOp>(loc, ValueRange({resultRankMinusOne, oneIndex}),
condBlock); condBlock);
rewriter.setInsertionPointToStart(condBlock); rewriter.setInsertionPointToStart(condBlock);
Value indexArg = condBlock->getArgument(0); Value indexArg = condBlock->getArgument(0);
Value strideArg = condBlock->getArgument(1); Value strideArg = condBlock->getArgument(1);
Value zeroIndex = createIndexConstant(rewriter, loc, 0); Value zeroIndex = createIndexConstant(rewriter, loc, 0);
Value pred = rewriter.create<LLVM::ICmpOp>( Value pred = rewriter.create<LLVM::ICmpOp>(
loc, LLVM::LLVMIntegerType::get(rewriter.getContext(), 1), loc, IntegerType::get(rewriter.getContext(), 1),
LLVM::ICmpPredicate::sge, indexArg, zeroIndex); LLVM::ICmpPredicate::sge, indexArg, zeroIndex);
Block *bodyBlock = Block *bodyBlock =
rewriter.splitBlock(condBlock, rewriter.getInsertionPoint()); rewriter.splitBlock(condBlock, rewriter.getInsertionPoint());
rewriter.setInsertionPointToStart(bodyBlock); rewriter.setInsertionPointToStart(bodyBlock);
// Copy size from shape to descriptor. // Copy size from shape to descriptor.
Type llvmIndexPtrType = LLVM::LLVMPointerType::get(indexType); Type llvmIndexPtrType = LLVM::LLVMPointerType::get(indexType);
▲ Show 20 Lines • Show All 252 Lines • ▼ Show 20 Linesstruct IndexCastOpLowering : public ConvertOpToLLVMPattern<IndexCastOp> {
LogicalResult LogicalResult
matchAndRewrite(IndexCastOp indexCastOp, ArrayRef<Value> operands, matchAndRewrite(IndexCastOp indexCastOp, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override { ConversionPatternRewriter &rewriter) const override {
IndexCastOpAdaptor transformed(operands); IndexCastOpAdaptor transformed(operands);
auto targetType = auto targetType =
typeConverter->convertType(indexCastOp.getResult().getType()) typeConverter->convertType(indexCastOp.getResult().getType())
.cast<LLVM::LLVMIntegerType>(); .cast<IntegerType>();
auto sourceType = transformed.in().getType().cast<LLVM::LLVMIntegerType>(); auto sourceType = transformed.in().getType().cast<IntegerType>();
unsigned targetBits = targetType.getBitWidth(); unsigned targetBits = targetType.getWidth();
unsigned sourceBits = sourceType.getBitWidth(); unsigned sourceBits = sourceType.getWidth();
if (targetBits == sourceBits) if (targetBits == sourceBits)
rewriter.replaceOp(indexCastOp, transformed.in()); rewriter.replaceOp(indexCastOp, transformed.in());
else if (targetBits < sourceBits) else if (targetBits < sourceBits)
rewriter.replaceOpWithNewOp<LLVM::TruncOp>(indexCastOp, targetType, rewriter.replaceOpWithNewOp<LLVM::TruncOp>(indexCastOp, targetType,
transformed.in()); transformed.in());
else else
rewriter.replaceOpWithNewOp<LLVM::SExtOp>(indexCastOp, targetType, rewriter.replaceOpWithNewOp<LLVM::SExtOp>(indexCastOp, targetType,
▲ Show 20 Lines • Show All 743 Lines • ▼ Show 20 Lines for (auto &nestedOp : entryBlock.without_terminator()) {
mapping.map(nestedOp.getResults(), clone->getResults()); mapping.map(nestedOp.getResults(), clone->getResults());
} }
Value result = mapping.lookup(entryBlock.getTerminator()->getOperand(0)); Value result = mapping.lookup(entryBlock.getTerminator()->getOperand(0));
// Prepare the epilog of the loop block. // Prepare the epilog of the loop block.
// Append the cmpxchg op to the end of the loop block. // Append the cmpxchg op to the end of the loop block.
auto successOrdering = LLVM::AtomicOrdering::acq_rel; auto successOrdering = LLVM::AtomicOrdering::acq_rel;
auto failureOrdering = LLVM::AtomicOrdering::monotonic; auto failureOrdering = LLVM::AtomicOrdering::monotonic;
auto boolType = LLVM::LLVMIntegerType::get(rewriter.getContext(), 1); auto boolType = IntegerType::get(rewriter.getContext(), 1);
auto pairType = LLVM::LLVMStructType::getLiteral(rewriter.getContext(), auto pairType = LLVM::LLVMStructType::getLiteral(rewriter.getContext(),
{valueType, boolType}); {valueType, boolType});
auto cmpxchg = rewriter.create<LLVM::AtomicCmpXchgOp>( auto cmpxchg = rewriter.create<LLVM::AtomicCmpXchgOp>(
loc, pairType, dataPtr, loopArgument, result, successOrdering, loc, pairType, dataPtr, loopArgument, result, successOrdering,
failureOrdering); failureOrdering);
// Extract the %new_loaded and %ok values from the pair. // Extract the %new_loaded and %ok values from the pair.
Value newLoaded = rewriter.create<LLVM::ExtractValueOp>( Value newLoaded = rewriter.create<LLVM::ExtractValueOp>(
loc, valueType, cmpxchg, rewriter.getI64ArrayAttr({0})); loc, valueType, cmpxchg, rewriter.getI64ArrayAttr({0}));
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 LinesType LLVMTypeConverter::packFunctionResults(ArrayRef<Type> types) {
} }
return LLVM::LLVMStructType::getLiteral(&getContext(), resultTypes); return LLVM::LLVMStructType::getLiteral(&getContext(), resultTypes);
} }
Value LLVMTypeConverter::promoteOneMemRefDescriptor(Location loc, Value operand, Value LLVMTypeConverter::promoteOneMemRefDescriptor(Location loc, Value operand,
OpBuilder &builder) { OpBuilder &builder) {
auto *context = builder.getContext(); auto *context = builder.getContext();
auto int64Ty = LLVM::LLVMIntegerType::get(builder.getContext(), 64); auto int64Ty = IntegerType::get(builder.getContext(), 64);
auto indexType = IndexType::get(context); auto indexType = IndexType::get(context);
// Alloca with proper alignment. We do not expect optimizations of this // Alloca with proper alignment. We do not expect optimizations of this
// alloca op and so we omit allocating at the entry block. // alloca op and so we omit allocating at the entry block.
auto ptrType = LLVM::LLVMPointerType::get(operand.getType()); auto ptrType = LLVM::LLVMPointerType::get(operand.getType());
Value one = builder.create<LLVM::ConstantOp>(loc, int64Ty, Value one = builder.create<LLVM::ConstantOp>(loc, int64Ty,
IntegerAttr::get(indexType, 1)); IntegerAttr::get(indexType, 1));
Value allocated = Value allocated =
builder.create<LLVM::AllocaOp>(loc, ptrType, one, /*alignment=*/0); builder.create<LLVM::AllocaOp>(loc, ptrType, one, /*alignment=*/0);
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

Show First 20 Lines • Show All 741 Lines • ▼ Show 20 Lines if (positionAttrs.size() > 1) {
ArrayAttr::get(positionAttrs.drop_back(), context); ArrayAttr::get(positionAttrs.drop_back(), context);
extracted = rewriter.create<LLVM::ExtractValueOp>( extracted = rewriter.create<LLVM::ExtractValueOp>(
loc, typeConverter->convertType(oneDVectorType), extracted, loc, typeConverter->convertType(oneDVectorType), extracted,
nMinusOnePositionAttrs); nMinusOnePositionAttrs);
} }
// Remaining extraction of element from 1-D LLVM vector // Remaining extraction of element from 1-D LLVM vector
auto position = positionAttrs.back().cast<IntegerAttr>(); auto position = positionAttrs.back().cast<IntegerAttr>();
auto i64Type = LLVM::LLVMIntegerType::get(rewriter.getContext(), 64); auto i64Type = IntegerType::get(rewriter.getContext(), 64);
auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position); auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
extracted = extracted =
rewriter.create<LLVM::ExtractElementOp>(loc, extracted, constant); rewriter.create<LLVM::ExtractElementOp>(loc, extracted, constant);
rewriter.replaceOp(extractOp, extracted); rewriter.replaceOp(extractOp, extracted);
return success(); return success();
} }
}; };
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines if (positionAttrs.size() > 1) {
auto nMinusOnePositionAttrs = auto nMinusOnePositionAttrs =
ArrayAttr::get(positionAttrs.drop_back(), context); ArrayAttr::get(positionAttrs.drop_back(), context);
extracted = rewriter.create<LLVM::ExtractValueOp>( extracted = rewriter.create<LLVM::ExtractValueOp>(
loc, typeConverter->convertType(oneDVectorType), extracted, loc, typeConverter->convertType(oneDVectorType), extracted,
nMinusOnePositionAttrs); nMinusOnePositionAttrs);
} }
// Insertion of an element into a 1-D LLVM vector. // Insertion of an element into a 1-D LLVM vector.
auto i64Type = LLVM::LLVMIntegerType::get(rewriter.getContext(), 64); auto i64Type = IntegerType::get(rewriter.getContext(), 64);
auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position); auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
Value inserted = rewriter.create<LLVM::InsertElementOp>( Value inserted = rewriter.create<LLVM::InsertElementOp>(
loc, typeConverter->convertType(oneDVectorType), extracted, loc, typeConverter->convertType(oneDVectorType), extracted,
adaptor.source(), constant); adaptor.source(), constant);
// Potential insertion of resulting 1-D vector into array. // Potential insertion of resulting 1-D vector into array.
if (positionAttrs.size() > 1) { if (positionAttrs.size() > 1) {
auto nMinusOnePositionAttrs = auto nMinusOnePositionAttrs =
▲ Show 20 Lines • Show All 249 Lines • ▼ Show 20 Lines matchAndRewrite(vector::TypeCastOp castOp, ArrayRef<Value> operands,
if (!targetStrides) if (!targetStrides)
return failure(); return failure();
// Only support static strides for now, regardless of contiguity. // Only support static strides for now, regardless of contiguity.
if (llvm::any_of(*targetStrides, [](int64_t stride) { if (llvm::any_of(*targetStrides, [](int64_t stride) {
return ShapedType::isDynamicStrideOrOffset(stride); return ShapedType::isDynamicStrideOrOffset(stride);
})) }))
return failure(); return failure();
auto int64Ty = LLVM::LLVMIntegerType::get(rewriter.getContext(), 64); auto int64Ty = IntegerType::get(rewriter.getContext(), 64);
// Create descriptor. // Create descriptor.
auto desc = MemRefDescriptor::undef(rewriter, loc, llvmTargetDescriptorTy); auto desc = MemRefDescriptor::undef(rewriter, loc, llvmTargetDescriptorTy);
Type llvmTargetElementTy = desc.getElementPtrType(); Type llvmTargetElementTy = desc.getElementPtrType();
// Set allocated ptr. // Set allocated ptr.
Value allocated = sourceMemRef.allocatedPtr(rewriter, loc); Value allocated = sourceMemRef.allocatedPtr(rewriter, loc);
allocated = allocated =
rewriter.create<LLVM::BitcastOp>(loc, llvmTargetElementTy, allocated); rewriter.create<LLVM::BitcastOp>(loc, llvmTargetElementTy, allocated);
▲ Show 20 Lines • Show All 222 Lines • ▼ Show 20 Linesprivate:
void emitRanks(ConversionPatternRewriter &rewriter, Operation *op, void emitRanks(ConversionPatternRewriter &rewriter, Operation *op,
Value value, VectorType vectorType, Operation *printer, Value value, VectorType vectorType, Operation *printer,
int64_t rank, PrintConversion conversion) const { int64_t rank, PrintConversion conversion) const {
Location loc = op->getLoc(); Location loc = op->getLoc();
if (rank == 0) { if (rank == 0) {
switch (conversion) { switch (conversion) {
case PrintConversion::ZeroExt64: case PrintConversion::ZeroExt64:
value = rewriter.create<ZeroExtendIOp>( value = rewriter.create<ZeroExtendIOp>(
loc, value, LLVM::LLVMIntegerType::get(rewriter.getContext(), 64)); loc, value, IntegerType::get(rewriter.getContext(), 64));
break; break;
case PrintConversion::SignExt64: case PrintConversion::SignExt64:
value = rewriter.create<SignExtendIOp>( value = rewriter.create<SignExtendIOp>(
loc, value, LLVM::LLVMIntegerType::get(rewriter.getContext(), 64)); loc, value, IntegerType::get(rewriter.getContext(), 64));
break; break;
case PrintConversion::None: case PrintConversion::None:
break; break;
} }
emitCall(rewriter, loc, printer, value); emitCall(rewriter, loc, printer, value);
return; return;
} }
Show All 33 Lines static Operation *getPrint(Operation *op, StringRef name,
return moduleBuilder.create<LLVM::LLVMFuncOp>( return moduleBuilder.create<LLVM::LLVMFuncOp>(
op->getLoc(), name, op->getLoc(), name,
LLVM::LLVMFunctionType::get(LLVM::LLVMVoidType::get(op->getContext()), LLVM::LLVMFunctionType::get(LLVM::LLVMVoidType::get(op->getContext()),
params)); params));
} }
// Helpers for method names. // Helpers for method names.
Operation *getPrintI64(Operation *op) const { Operation *getPrintI64(Operation *op) const {
return getPrint(op, "printI64", return getPrint(op, "printI64", IntegerType::get(op->getContext(), 64));
LLVM::LLVMIntegerType::get(op->getContext(), 64));
} }
Operation *getPrintU64(Operation *op) const { Operation *getPrintU64(Operation *op) const {
return getPrint(op, "printU64", return getPrint(op, "printU64", IntegerType::get(op->getContext(), 64));
LLVM::LLVMIntegerType::get(op->getContext(), 64));
} }
Operation *getPrintFloat(Operation *op) const { Operation *getPrintFloat(Operation *op) const {
return getPrint(op, "printF32", LLVM::LLVMFloatType::get(op->getContext())); return getPrint(op, "printF32", LLVM::LLVMFloatType::get(op->getContext()));
} }
Operation *getPrintDouble(Operation *op) const { Operation *getPrintDouble(Operation *op) const {
return getPrint(op, "printF64", return getPrint(op, "printF64",
LLVM::LLVMDoubleType::get(op->getContext())); LLVM::LLVMDoubleType::get(op->getContext()));
} }
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines if (std::is_same<CmpPredicateType, ICmpPredicate>()) {
predicateValue = static_cast<int64_t>(predicate.getValue()); predicateValue = static_cast<int64_t>(predicate.getValue());
} }
result.attributes.set("predicate", result.attributes.set("predicate",
parser.getBuilder().getI64IntegerAttr(predicateValue)); parser.getBuilder().getI64IntegerAttr(predicateValue));
// The result type is either i1 or a vector type <? x i1> if the inputs are // The result type is either i1 or a vector type <? x i1> if the inputs are
// vectors. // vectors.
Type resultType = LLVMIntegerType::get(builder.getContext(), 1); Type resultType = IntegerType::get(builder.getContext(), 1);
if (!isCompatibleType(type)) if (!isCompatibleType(type))
return parser.emitError(trailingTypeLoc, return parser.emitError(trailingTypeLoc,
"expected LLVM dialect-compatible type"); "expected LLVM dialect-compatible type");
if (auto vecArgType = type.dyn_cast<LLVM::LLVMFixedVectorType>()) if (auto vecArgType = type.dyn_cast<LLVM::LLVMFixedVectorType>())
resultType = resultType =
LLVMFixedVectorType::get(resultType, vecArgType.getNumElements()); LLVMFixedVectorType::get(resultType, vecArgType.getNumElements());
assert(!type.isa<LLVM::LLVMScalableVectorType>() && assert(!type.isa<LLVM::LLVMScalableVectorType>() &&
"unhandled scalable vector"); "unhandled scalable vector");
▲ Show 20 Lines • Show All 1,091 Lines • ▼ Show 20 Lines
// Verifier for LLVM::DialectCastOp. // Verifier for LLVM::DialectCastOp.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Checks if `llvmType` is dialect cast-compatible with `index` type. Does not /// Checks if `llvmType` is dialect cast-compatible with `index` type. Does not
/// report the error, the user is expected to produce an appropriate message. /// report the error, the user is expected to produce an appropriate message.
// TODO: make the size depend on data layout rather than on the conversion // TODO: make the size depend on data layout rather than on the conversion
// pass option, and pull that information here. // pass option, and pull that information here.
static LogicalResult verifyCastWithIndex(Type llvmType) { static LogicalResult verifyCastWithIndex(Type llvmType) {
return success(llvmType.isa<LLVMIntegerType>()); return success(llvmType.isa<IntegerType>());
} }
/// Checks if `llvmType` is dialect cast-compatible with built-in `type` and /// Checks if `llvmType` is dialect cast-compatible with built-in `type` and
/// reports errors to the location of `op`. /// reports errors to the location of `op`.
static LogicalResult verifyCast(DialectCastOp op, Type llvmType, Type type) { static LogicalResult verifyCast(DialectCastOp op, Type llvmType, Type type) {
// Index is compatible with any integer. // Index is compatible with any integer.
if (type.isIndex()) { if (type.isIndex()) {
if (succeeded(verifyCastWithIndex(llvmType))) if (succeeded(verifyCastWithIndex(llvmType)))
Show All 23 Linesstatic LogicalResult verifyCast(DialectCastOp op, Type llvmType, Type type) {
} }
if (type.isF64()) { if (type.isF64()) {
if (llvmType.isa<LLVMDoubleType>()) if (llvmType.isa<LLVMDoubleType>())
return success(); return success();
return op->emitOpError( return op->emitOpError(
"invalid cast between f64 and a type other than !llvm.double"); "invalid cast between f64 and a type other than !llvm.double");
} }
// Singless integers are compatible with LLVM integer of the same bitwidth.
if (type.isSignlessInteger()) {
auto llvmInt = llvmType.dyn_cast<LLVMIntegerType>();
if (!llvmInt)
return op->emitOpError(
"invalid cast between integer and non-integer type");
if (llvmInt.getBitWidth() == type.getIntOrFloatBitWidth())
return success();
return op->emitOpError(
"invalid cast between integers with mismatching bitwidth");
}
// Vectors are compatible if they are 1D non-scalable, and their element types // Vectors are compatible if they are 1D non-scalable, and their element types
// are compatible. // are compatible.
if (auto vectorType = type.dyn_cast<VectorType>()) { if (auto vectorType = type.dyn_cast<VectorType>()) {
if (vectorType.getRank() != 1) if (vectorType.getRank() != 1)
return op->emitOpError("only 1-d vector is allowed"); return op->emitOpError("only 1-d vector is allowed");
auto llvmVector = llvmType.dyn_cast<LLVMFixedVectorType>(); auto llvmVector = llvmType.dyn_cast<LLVMFixedVectorType>();
if (!llvmVector) if (!llvmVector)
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines if (!structType || structType.getBody().size() != 2)
"expected descriptor to be a struct with two elements"); "expected descriptor to be a struct with two elements");
if (failed(verifyCastWithIndex(structType.getBody()[0]))) if (failed(verifyCastWithIndex(structType.getBody()[0])))
return op->emitOpError("expected first element of a memref descriptor to " return op->emitOpError("expected first element of a memref descriptor to "
"be an index-compatible integer"); "be an index-compatible integer");
auto ptrType = structType.getBody()[1].dyn_cast<LLVMPointerType>(); auto ptrType = structType.getBody()[1].dyn_cast<LLVMPointerType>();
auto ptrElementType = auto ptrElementType =
ptrType ? ptrType.getElementType().dyn_cast<LLVMIntegerType>() ptrType ? ptrType.getElementType().dyn_cast<IntegerType>() : nullptr;
: nullptr; if (!ptrElementType || ptrElementType.getWidth() != 8)
if (!ptrElementType || ptrElementType.getBitWidth() != 8)
return op->emitOpError("expected second element of a memref descriptor " return op->emitOpError("expected second element of a memref descriptor "
"to be an !llvm.ptr<i8>"); "to be an !llvm.ptr<i8>");
return success(); return success();
} }
// Everything else is not supported. // Everything else is not supported.
return op->emitError("unsupported cast"); return op->emitError("unsupported cast");
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesstatic ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
if (types.size() > 1) if (types.size() > 1)
return parser.emitError(parser.getNameLoc(), "expected zero or one type"); return parser.emitError(parser.getNameLoc(), "expected zero or one type");
Region &initRegion = *result.addRegion(); Region &initRegion = *result.addRegion();
if (types.empty()) { if (types.empty()) {
if (auto strAttr = value.dyn_cast_or_null<StringAttr>()) { if (auto strAttr = value.dyn_cast_or_null<StringAttr>()) {
MLIRContext *context = parser.getBuilder().getContext(); MLIRContext *context = parser.getBuilder().getContext();
auto arrayType = LLVM::LLVMArrayType::get( auto arrayType = LLVM::LLVMArrayType::get(IntegerType::get(context, 8),
LLVM::LLVMIntegerType::get(context, 8), strAttr.getValue().size()); strAttr.getValue().size());
types.push_back(arrayType); types.push_back(arrayType);
} else { } else {
return parser.emitError(parser.getNameLoc(), return parser.emitError(parser.getNameLoc(),
"type can only be omitted for string globals"); "type can only be omitted for string globals");
} }
} else { } else {
OptionalParseResult parseResult = OptionalParseResult parseResult =
parser.parseOptionalRegion(initRegion, /*arguments=*/{}, parser.parseOptionalRegion(initRegion, /*arguments=*/{},
Show All 10 Linesstatic LogicalResult verify(GlobalOp op) {
if (!LLVMPointerType::isValidElementType(op.getType())) if (!LLVMPointerType::isValidElementType(op.getType()))
return op.emitOpError( return op.emitOpError(
"expects type to be a valid element type for an LLVM pointer"); "expects type to be a valid element type for an LLVM pointer");
if (op->getParentOp() && !satisfiesLLVMModule(op->getParentOp())) if (op->getParentOp() && !satisfiesLLVMModule(op->getParentOp()))
return op.emitOpError("must appear at the module level"); return op.emitOpError("must appear at the module level");
if (auto strAttr = op.getValueOrNull().dyn_cast_or_null<StringAttr>()) { if (auto strAttr = op.getValueOrNull().dyn_cast_or_null<StringAttr>()) {
auto type = op.getType().dyn_cast<LLVMArrayType>(); auto type = op.getType().dyn_cast<LLVMArrayType>();
LLVMIntegerType elementType = IntegerType elementType =
type ? type.getElementType().dyn_cast<LLVMIntegerType>() : nullptr; type ? type.getElementType().dyn_cast<IntegerType>() : nullptr;
if (!elementType || elementType.getBitWidth() != 8 || if (!elementType || elementType.getWidth() != 8 ||
type.getNumElements() != strAttr.getValue().size()) type.getNumElements() != strAttr.getValue().size())
return op.emitOpError( return op.emitOpError(
"requires an i8 array type of the length equal to that of the string " "requires an i8 array type of the length equal to that of the string "
"attribute"); "attribute");
} }
if (Block *b = op.getInitializerBlock()) { if (Block *b = op.getInitializerBlock()) {
ReturnOp ret = cast<ReturnOp>(b->getTerminator()); ReturnOp ret = cast<ReturnOp>(b->getTerminator());
▲ Show 20 Lines • Show All 395 Lines • ▼ Show 20 Linesstatic LogicalResult verify(AtomicRMWOp op) {
auto resType = op.res().getType(); auto resType = op.res().getType();
if (resType != valType) if (resType != valType)
return op.emitOpError( return op.emitOpError(
"expected LLVM IR result type to match type for operand #1"); "expected LLVM IR result type to match type for operand #1");
if (op.bin_op() == AtomicBinOp::fadd || op.bin_op() == AtomicBinOp::fsub) { if (op.bin_op() == AtomicBinOp::fadd || op.bin_op() == AtomicBinOp::fsub) {
if (!mlir::LLVM::isCompatibleFloatingPointType(valType)) if (!mlir::LLVM::isCompatibleFloatingPointType(valType))
return op.emitOpError("expected LLVM IR floating point type"); return op.emitOpError("expected LLVM IR floating point type");
} else if (op.bin_op() == AtomicBinOp::xchg) { } else if (op.bin_op() == AtomicBinOp::xchg) {
auto intType = valType.dyn_cast<LLVMIntegerType>(); auto intType = valType.dyn_cast<IntegerType>();
unsigned intBitWidth = intType ? intType.getBitWidth() : 0; unsigned intBitWidth = intType ? intType.getWidth() : 0;
if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 && if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 &&
intBitWidth != 64 && !valType.isa<LLVMBFloatType>() && intBitWidth != 64 && !valType.isa<LLVMBFloatType>() &&
!valType.isa<LLVMHalfType>() && !valType.isa<LLVMFloatType>() && !valType.isa<LLVMHalfType>() && !valType.isa<LLVMFloatType>() &&
!valType.isa<LLVMDoubleType>()) !valType.isa<LLVMDoubleType>())
return op.emitOpError("unexpected LLVM IR type for 'xchg' bin_op"); return op.emitOpError("unexpected LLVM IR type for 'xchg' bin_op");
} else { } else {
auto intType = valType.dyn_cast<LLVMIntegerType>(); auto intType = valType.dyn_cast<IntegerType>();
unsigned intBitWidth = intType ? intType.getBitWidth() : 0; unsigned intBitWidth = intType ? intType.getWidth() : 0;
if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 && if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 &&
intBitWidth != 64) intBitWidth != 64)
return op.emitOpError("expected LLVM IR integer type"); return op.emitOpError("expected LLVM IR integer type");
} }
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 24 Lines if (parser.parseOperand(ptr) || parser.parseComma() ||
parser.parseOptionalAttrDict(result.attributes) || parser.parseOptionalAttrDict(result.attributes) ||
parser.parseColonType(type) || parser.parseColonType(type) ||
parser.resolveOperand(ptr, LLVM::LLVMPointerType::get(type), parser.resolveOperand(ptr, LLVM::LLVMPointerType::get(type),
result.operands) || result.operands) ||
parser.resolveOperand(cmp, type, result.operands) || parser.resolveOperand(cmp, type, result.operands) ||
parser.resolveOperand(val, type, result.operands)) parser.resolveOperand(val, type, result.operands))
return failure(); return failure();
auto boolType = LLVMIntegerType::get(builder.getContext(), 1); auto boolType = IntegerType::get(builder.getContext(), 1);
auto resultType = auto resultType =
LLVMStructType::getLiteral(builder.getContext(), {type, boolType}); LLVMStructType::getLiteral(builder.getContext(), {type, boolType});
result.addTypes(resultType); result.addTypes(resultType);
return success(); return success();
} }
static LogicalResult verify(AtomicCmpXchgOp op) { static LogicalResult verify(AtomicCmpXchgOp op) {
auto ptrType = op.ptr().getType().cast<LLVM::LLVMPointerType>(); auto ptrType = op.ptr().getType().cast<LLVM::LLVMPointerType>();
if (!ptrType) if (!ptrType)
return op.emitOpError("expected LLVM IR pointer type for operand #0"); return op.emitOpError("expected LLVM IR pointer type for operand #0");
auto cmpType = op.cmp().getType(); auto cmpType = op.cmp().getType();
auto valType = op.val().getType(); auto valType = op.val().getType();
if (cmpType != ptrType.getElementType() || cmpType != valType) if (cmpType != ptrType.getElementType() || cmpType != valType)
return op.emitOpError("expected LLVM IR element type for operand #0 to " return op.emitOpError("expected LLVM IR element type for operand #0 to "
"match type for all other operands"); "match type for all other operands");
auto intType = valType.dyn_cast<LLVMIntegerType>(); auto intType = valType.dyn_cast<IntegerType>();
unsigned intBitWidth = intType ? intType.getBitWidth() : 0; unsigned intBitWidth = intType ? intType.getWidth() : 0;
if (!valType.isa<LLVMPointerType>() && intBitWidth != 8 && if (!valType.isa<LLVMPointerType>() && intBitWidth != 8 &&
intBitWidth != 16 && intBitWidth != 32 && intBitWidth != 64 && intBitWidth != 16 && intBitWidth != 32 && intBitWidth != 64 &&
!valType.isa<LLVMBFloatType>() && !valType.isa<LLVMHalfType>() && !valType.isa<LLVMBFloatType>() && !valType.isa<LLVMHalfType>() &&
!valType.isa<LLVMFloatType>() && !valType.isa<LLVMDoubleType>()) !valType.isa<LLVMFloatType>() && !valType.isa<LLVMDoubleType>())
return op.emitOpError("unexpected LLVM IR type"); return op.emitOpError("unexpected LLVM IR type");
if (op.success_ordering() < AtomicOrdering::monotonic || if (op.success_ordering() < AtomicOrdering::monotonic ||
op.failure_ordering() < AtomicOrdering::monotonic) op.failure_ordering() < AtomicOrdering::monotonic)
return op.emitOpError("ordering must be at least 'monotonic'"); return op.emitOpError("ordering must be at least 'monotonic'");
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines addTypes<LLVMVoidType,
LLVMFP128Type, LLVMFP128Type,
LLVMX86FP80Type, LLVMX86FP80Type,
LLVMPPCFP128Type, LLVMPPCFP128Type,
LLVMX86MMXType, LLVMX86MMXType,
LLVMTokenType, LLVMTokenType,
LLVMLabelType, LLVMLabelType,
LLVMMetadataType, LLVMMetadataType,
LLVMFunctionType, LLVMFunctionType,
LLVMIntegerType,
LLVMPointerType, LLVMPointerType,
LLVMFixedVectorType, LLVMFixedVectorType,
LLVMScalableVectorType, LLVMScalableVectorType,
LLVMArrayType, LLVMArrayType,
LLVMStructType>(); LLVMStructType>();
// clang-format on // clang-format on
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines assert(builder.getInsertionBlock() &&
"expected builder to point to a block constrained in an op"); "expected builder to point to a block constrained in an op");
auto module = auto module =
builder.getInsertionBlock()->getParentOp()->getParentOfType<ModuleOp>(); builder.getInsertionBlock()->getParentOp()->getParentOfType<ModuleOp>();
assert(module && "builder points to an op outside of a module"); assert(module && "builder points to an op outside of a module");
// Create the global at the entry of the module. // Create the global at the entry of the module.
OpBuilder moduleBuilder(module.getBodyRegion()); OpBuilder moduleBuilder(module.getBodyRegion());
MLIRContext *ctx = builder.getContext(); MLIRContext *ctx = builder.getContext();
auto type = LLVM::LLVMArrayType::get(LLVM::LLVMIntegerType::get(ctx, 8), auto type = LLVM::LLVMArrayType::get(IntegerType::get(ctx, 8), value.size());
value.size());
auto global = moduleBuilder.create<LLVM::GlobalOp>( auto global = moduleBuilder.create<LLVM::GlobalOp>(
loc, type, /*isConstant=*/true, linkage, name, loc, type, /*isConstant=*/true, linkage, name,
builder.getStringAttr(value)); builder.getStringAttr(value));
// Get the pointer to the first character in the global string. // Get the pointer to the first character in the global string.
Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global); Value globalPtr = builder.create<LLVM::AddressOfOp>(loc, global);
Value cst0 = builder.create<LLVM::ConstantOp>( Value cst0 = builder.create<LLVM::ConstantOp>(
loc, LLVM::LLVMIntegerType::get(ctx, 64), loc, IntegerType::get(ctx, 64),
builder.getIntegerAttr(builder.getIndexType(), 0)); builder.getIntegerAttr(builder.getIndexType(), 0));
return builder.create<LLVM::GEPOp>( return builder.create<LLVM::GEPOp>(
loc, LLVM::LLVMPointerType::get(LLVMIntegerType::get(ctx, 8)), globalPtr, loc, LLVM::LLVMPointerType::get(IntegerType::get(ctx, 8)), globalPtr,
ValueRange{cst0, cst0}); ValueRange{cst0, cst0});
} }
bool mlir::LLVM::satisfiesLLVMModule(Operation *op) { bool mlir::LLVM::satisfiesLLVMModule(Operation *op) {
return op->hasTrait<OpTrait::SymbolTable>() && return op->hasTrait<OpTrait::SymbolTable>() &&
op->hasTrait<OpTrait::IsIsolatedFromAbove>(); op->hasTrait<OpTrait::IsIsolatedFromAbove>();
} }
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

Show All 18 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Printing. // Printing.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// If the given type is compatible with the LLVM dialect, prints it using /// If the given type is compatible with the LLVM dialect, prints it using
/// internal functions to avoid getting a verbose `!llvm` prefix. Otherwise /// internal functions to avoid getting a verbose `!llvm` prefix. Otherwise
/// prints it as usual. /// prints it as usual.
static void dispatchPrint(DialectAsmPrinter &printer, Type type) { static void dispatchPrint(DialectAsmPrinter &printer, Type type) {
if (isCompatibleType(type)) if (isCompatibleType(type) && !type.isa<IntegerType>())
return mlir::LLVM::detail::printType(type, printer); return mlir::LLVM::detail::printType(type, printer);
printer.printType(type); printer.printType(type);
} }
/// Returns the keyword to use for the given type. /// Returns the keyword to use for the given type.
static StringRef getTypeKeyword(Type type) { static StringRef getTypeKeyword(Type type) {
return TypeSwitch<Type, StringRef>(type) return TypeSwitch<Type, StringRef>(type)
.Case<LLVMVoidType>([&](Type) { return "void"; }) .Case<LLVMVoidType>([&](Type) { return "void"; })
.Case<LLVMHalfType>([&](Type) { return "half"; }) .Case<LLVMHalfType>([&](Type) { return "half"; })
.Case<LLVMBFloatType>([&](Type) { return "bfloat"; }) .Case<LLVMBFloatType>([&](Type) { return "bfloat"; })
.Case<LLVMFloatType>([&](Type) { return "float"; }) .Case<LLVMFloatType>([&](Type) { return "float"; })
.Case<LLVMDoubleType>([&](Type) { return "double"; }) .Case<LLVMDoubleType>([&](Type) { return "double"; })
.Case<LLVMFP128Type>([&](Type) { return "fp128"; }) .Case<LLVMFP128Type>([&](Type) { return "fp128"; })
.Case<LLVMX86FP80Type>([&](Type) { return "x86_fp80"; }) .Case<LLVMX86FP80Type>([&](Type) { return "x86_fp80"; })
.Case<LLVMPPCFP128Type>([&](Type) { return "ppc_fp128"; }) .Case<LLVMPPCFP128Type>([&](Type) { return "ppc_fp128"; })
.Case<LLVMX86MMXType>([&](Type) { return "x86_mmx"; }) .Case<LLVMX86MMXType>([&](Type) { return "x86_mmx"; })
.Case<LLVMTokenType>([&](Type) { return "token"; }) .Case<LLVMTokenType>([&](Type) { return "token"; })
.Case<LLVMLabelType>([&](Type) { return "label"; }) .Case<LLVMLabelType>([&](Type) { return "label"; })
.Case<LLVMMetadataType>([&](Type) { return "metadata"; }) .Case<LLVMMetadataType>([&](Type) { return "metadata"; })
.Case<LLVMFunctionType>([&](Type) { return "func"; }) .Case<LLVMFunctionType>([&](Type) { return "func"; })
.Case<LLVMIntegerType>([&](Type) { return "i"; })
.Case<LLVMPointerType>([&](Type) { return "ptr"; }) .Case<LLVMPointerType>([&](Type) { return "ptr"; })
.Case<LLVMVectorType>([&](Type) { return "vec"; }) .Case<LLVMVectorType>([&](Type) { return "vec"; })
.Case<LLVMArrayType>([&](Type) { return "array"; }) .Case<LLVMArrayType>([&](Type) { return "array"; })
.Case<LLVMStructType>([&](Type) { return "struct"; }) .Case<LLVMStructType>([&](Type) { return "struct"; })
.Default([](Type) -> StringRef { .Default([](Type) -> StringRef {
llvm_unreachable("unexpected 'llvm' type kind"); llvm_unreachable("unexpected 'llvm' type kind");
}); });
} }
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
void mlir::LLVM::detail::printType(Type type, DialectAsmPrinter &printer) { void mlir::LLVM::detail::printType(Type type, DialectAsmPrinter &printer) {
if (!type) { if (!type) {
printer << "<<NULL-TYPE>>"; printer << "<<NULL-TYPE>>";
return; return;
} }
printer << getTypeKeyword(type); printer << getTypeKeyword(type);
if (auto intType = type.dyn_cast<LLVMIntegerType>()) {
printer << intType.getBitWidth();
return;
}
if (auto ptrType = type.dyn_cast<LLVMPointerType>()) { if (auto ptrType = type.dyn_cast<LLVMPointerType>()) {
printer << '<'; printer << '<';
dispatchPrint(printer, ptrType.getElementType()); dispatchPrint(printer, ptrType.getElementType());
if (ptrType.getAddressSpace() != 0) if (ptrType.getAddressSpace() != 0)
printer << ", " << ptrType.getAddressSpace(); printer << ", " << ptrType.getAddressSpace();
printer << '>'; printer << '>';
return; return;
} }
▲ Show 20 Lines • Show All 248 Lines • ▼ Show 20 Linesstatic LLVMStructType parseStructType(DialectAsmParser &parser) {
auto type = LLVMStructType::getIdentifiedChecked(loc, name); auto type = LLVMStructType::getIdentifiedChecked(loc, name);
return trySetStructBody(type, subtypes, isPacked, parser, subtypesLoc); return trySetStructBody(type, subtypes, isPacked, parser, subtypesLoc);
} }
/// Parses a type appearing inside another LLVM dialect-compatible type. This /// Parses a type appearing inside another LLVM dialect-compatible type. This
/// will try to parse any type in full form (including types with the `!llvm` /// will try to parse any type in full form (including types with the `!llvm`
/// prefix), and on failure fall back to parsing the short-hand version of the /// prefix), and on failure fall back to parsing the short-hand version of the
/// LLVM dialect types without the `!llvm` prefix. /// LLVM dialect types without the `!llvm` prefix.
static Type dispatchParse(DialectAsmParser &parser) { static Type dispatchParse(DialectAsmParser &parser, bool allowAny = true) {
Type type;
llvm::SMLoc keyLoc = parser.getCurrentLocation(); llvm::SMLoc keyLoc = parser.getCurrentLocation();
Location loc = parser.getEncodedSourceLoc(keyLoc);
OptionalParseResult parseResult = parser.parseOptionalType(type);
if (parseResult.hasValue()) {
if (failed(*parseResult))
return Type();
// Special case for integers (i[1-9][0-9]*) that are literals rather than // Try parsing any MLIR type.
// keywords for the parser, so they are not caught by the main dispatch Type type;
// below. Try parsing it a built-in integer type instead. OptionalParseResult result = parser.parseOptionalType(type);
if (result.hasValue()) {
if (failed(result.getValue()))
return nullptr;
// TODO: integer types are temporarily allowed for compatibility with the
// deprecated !llvm.i[0-9]+ syntax.
mehdi_aminiUnsubmitted
Not Done
ReplyInline Actions

I'm not sure why we need to maintain this? This seems like an entire mechanical change?

mehdi_amini: I'm not sure why we need to maintain this? This seems like an entire mechanical change?
if (!allowAny) {
auto intType = type.dyn_cast<IntegerType>(); auto intType = type.dyn_cast<IntegerType>();
if (!intType || !intType.isSignless()) if (!intType || !intType.isSignless()) {
parser.emitError(keyLoc) << "unexpected type, expected keyword";
return nullptr;
}
Location loc = parser.getEncodedSourceLoc(keyLoc);
emitWarning(loc) << "deprecated syntax, drop '!llvm.' for integers";
}
return type; return type;
return LLVMIntegerType::getChecked(loc, intType.getWidth());
} }
// Dispatch to concrete functions. // If no type found, fallback to the shorthand form.
StringRef key; StringRef key;
if (failed(parser.parseKeyword(&key))) if (failed(parser.parseKeyword(&key)))
return Type(); return Type();
MLIRContext *ctx = parser.getBuilder().getContext(); MLIRContext *ctx = parser.getBuilder().getContext();
return StringSwitch<function_ref<Type()>>(key) return StringSwitch<function_ref<Type()>>(key)
.Case("void", [&] { return LLVMVoidType::get(ctx); }) .Case("void", [&] { return LLVMVoidType::get(ctx); })
.Case("half", [&] { return LLVMHalfType::get(ctx); }) .Case("half", [&] { return LLVMHalfType::get(ctx); })
Show All 22 Lines
static ParseResult dispatchParse(DialectAsmParser &parser, Type &type) { static ParseResult dispatchParse(DialectAsmParser &parser, Type &type) {
type = dispatchParse(parser); type = dispatchParse(parser);
return success(type != nullptr); return success(type != nullptr);
} }
/// Parses one of the LLVM dialect types. /// Parses one of the LLVM dialect types.
Type mlir::LLVM::detail::parseType(DialectAsmParser &parser) { Type mlir::LLVM::detail::parseType(DialectAsmParser &parser) {
llvm::SMLoc loc = parser.getCurrentLocation(); llvm::SMLoc loc = parser.getCurrentLocation();
Type type = dispatchParse(parser); Type type = dispatchParse(parser, /*allowAny=*/false);
if (!type) if (!type)
return type; return type;
if (!isCompatibleType(type)) { if (!isCompatibleType(type)) {
parser.emitError(loc) << "unexpected type, expected i* or keyword"; parser.emitError(loc) << "unexpected type, expected keyword";
return nullptr; return nullptr;
} }
return type; return type;
} }

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

Show All 9 Lines
// correspond to the LLVM IR type system. // correspond to the LLVM IR type system.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TypeDetail.h" #include "TypeDetail.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMTypes.h" #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/TypeSupport.h" #include "mlir/IR/TypeSupport.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/TypeSize.h" #include "llvm/Support/TypeSize.h"
using namespace mlir; using namespace mlir;
using namespace mlir::LLVM; using namespace mlir::LLVM;
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 LinesLLVMFunctionType::verifyConstructionInvariants(Location loc, Type result,
for (Type arg : arguments) for (Type arg : arguments)
if (!isValidArgumentType(arg)) if (!isValidArgumentType(arg))
return emitError(loc, "invalid function argument type: ") << arg; return emitError(loc, "invalid function argument type: ") << arg;
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Integer type.
//===----------------------------------------------------------------------===//
LLVMIntegerType LLVMIntegerType::get(MLIRContext *ctx, unsigned bitwidth) {
return Base::get(ctx, bitwidth);
}
LLVMIntegerType LLVMIntegerType::getChecked(Location loc, unsigned bitwidth) {
return Base::getChecked(loc, bitwidth);
}
unsigned LLVMIntegerType::getBitWidth() { return getImpl()->bitwidth; }
LogicalResult LLVMIntegerType::verifyConstructionInvariants(Location loc,
unsigned bitwidth) {
constexpr int maxSupportedBitwidth = (1 << 24);
if (bitwidth >= maxSupportedBitwidth)
return emitError(loc, "integer type too wide");
return success();
}
//===----------------------------------------------------------------------===//
// Pointer type. // Pointer type.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool LLVMPointerType::isValidElementType(Type type) { bool LLVMPointerType::isValidElementType(Type type) {
return !type.isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType, return !type.isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType,
LLVMLabelType>(); LLVMLabelType>();
} }
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 LinesLogicalResult LLVMStructType::verifyConstructionInvariants(Location loc,
return success(); return success();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Vector types. // Vector types.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool LLVMVectorType::isValidElementType(Type type) { bool LLVMVectorType::isValidElementType(Type type) {
return type.isa<LLVMIntegerType, LLVMPointerType>() || if (auto intType = type.dyn_cast<IntegerType>())
return intType.isSignless();
return type.isa<LLVMPointerType>() ||
mlir::LLVM::isCompatibleFloatingPointType(type); mlir::LLVM::isCompatibleFloatingPointType(type);
} }
/// Support type casting functionality. /// Support type casting functionality.
bool LLVMVectorType::classof(Type type) { bool LLVMVectorType::classof(Type type) {
return type.isa<LLVMFixedVectorType, LLVMScalableVectorType>(); return type.isa<LLVMFixedVectorType, LLVMScalableVectorType>();
} }
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
unsigned LLVMScalableVectorType::getMinNumElements() { unsigned LLVMScalableVectorType::getMinNumElements() {
return getImpl()->numElements; return getImpl()->numElements;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Utility functions. // Utility functions.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
bool mlir::LLVM::isCompatibleType(Type type) {
// Only signless integers are compatible.
if (auto intType = type.dyn_cast<IntegerType>())
return intType.isSignless();
// clang-format off
return type.isa<
LLVMArrayType,
LLVMBFloatType,
LLVMDoubleType,
LLVMFP128Type,
LLVMFloatType,
LLVMFunctionType,
LLVMHalfType,
LLVMLabelType,
LLVMMetadataType,
LLVMPPCFP128Type,
LLVMPointerType,
LLVMStructType,
LLVMTokenType,
LLVMVectorType,
LLVMVoidType,
LLVMX86FP80Type,
LLVMX86MMXType
>();
// clang-format on
}
llvm::TypeSize mlir::LLVM::getPrimitiveTypeSizeInBits(Type type) { llvm::TypeSize mlir::LLVM::getPrimitiveTypeSizeInBits(Type type) {
assert(isCompatibleType(type) && assert(isCompatibleType(type) &&
"expected a type compatible with the LLVM dialect"); "expected a type compatible with the LLVM dialect");
return llvm::TypeSwitch<Type, llvm::TypeSize>(type) return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
.Case<LLVMHalfType, LLVMBFloatType>( .Case<LLVMHalfType, LLVMBFloatType>(
[](Type) { return llvm::TypeSize::Fixed(16); }) [](Type) { return llvm::TypeSize::Fixed(16); })
.Case<LLVMFloatType>([](Type) { return llvm::TypeSize::Fixed(32); }) .Case<LLVMFloatType>([](Type) { return llvm::TypeSize::Fixed(32); })
.Case<LLVMDoubleType, LLVMX86MMXType>( .Case<LLVMDoubleType, LLVMX86MMXType>(
[](Type) { return llvm::TypeSize::Fixed(64); }) [](Type) { return llvm::TypeSize::Fixed(64); })
.Case<LLVMIntegerType>([](LLVMIntegerType intTy) { .Case<IntegerType>([](IntegerType intTy) {
return llvm::TypeSize::Fixed(intTy.getBitWidth()); return llvm::TypeSize::Fixed(intTy.getWidth());
}) })
.Case<LLVMX86FP80Type>([](Type) { return llvm::TypeSize::Fixed(80); }) .Case<LLVMX86FP80Type>([](Type) { return llvm::TypeSize::Fixed(80); })
.Case<LLVMPPCFP128Type, LLVMFP128Type>( .Case<LLVMPPCFP128Type, LLVMFP128Type>(
[](Type) { return llvm::TypeSize::Fixed(128); }) [](Type) { return llvm::TypeSize::Fixed(128); })
.Case<LLVMVectorType>([](LLVMVectorType t) { .Case<LLVMVectorType>([](LLVMVectorType t) {
llvm::TypeSize elementSize = llvm::TypeSize elementSize =
getPrimitiveTypeSizeInBits(t.getElementType()); getPrimitiveTypeSizeInBits(t.getElementType());
llvm::ElementCount elementCount = t.getElementCount(); llvm::ElementCount elementCount = t.getElementCount();
Show All 14 Lines

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines for (auto &attr : result.attributes) {
if (attr.first != "return_value_and_is_valid") if (attr.first != "return_value_and_is_valid")
continue; continue;
auto structType = resultType.dyn_cast<LLVM::LLVMStructType>(); auto structType = resultType.dyn_cast<LLVM::LLVMStructType>();
if (structType && !structType.getBody().empty()) if (structType && !structType.getBody().empty())
resultType = structType.getBody()[0]; resultType = structType.getBody()[0];
break; break;
} }
auto int32Ty = auto int32Ty = IntegerType::get(parser.getBuilder().getContext(), 32);
LLVM::LLVMIntegerType::get(parser.getBuilder().getContext(), 32);
return parser.resolveOperands(ops, {int32Ty, resultType, int32Ty, int32Ty}, return parser.resolveOperands(ops, {int32Ty, resultType, int32Ty, int32Ty},
parser.getNameLoc(), result.operands); parser.getNameLoc(), result.operands);
} }
// <operation> ::= `llvm.nvvm.vote.ballot.sync %mask, %pred` : result_type // <operation> ::= `llvm.nvvm.vote.ballot.sync %mask, %pred` : result_type
static ParseResult parseNVVMVoteBallotOp(OpAsmParser &parser, static ParseResult parseNVVMVoteBallotOp(OpAsmParser &parser,
OperationState &result) { OperationState &result) {
MLIRContext *context = parser.getBuilder().getContext(); MLIRContext *context = parser.getBuilder().getContext();
auto int32Ty = LLVM::LLVMIntegerType::get(context, 32); auto int32Ty = IntegerType::get(context, 32);
auto int1Ty = LLVM::LLVMIntegerType::get(context, 1); auto int1Ty = IntegerType::get(context, 1);
SmallVector<OpAsmParser::OperandType, 8> ops; SmallVector<OpAsmParser::OperandType, 8> ops;
Type type; Type type;
return failure(parser.parseOperandList(ops) || return failure(parser.parseOperandList(ops) ||
parser.parseOptionalAttrDict(result.attributes) || parser.parseOptionalAttrDict(result.attributes) ||
parser.parseColonType(type) || parser.parseColonType(type) ||
parser.addTypeToList(type, result.types) || parser.addTypeToList(type, result.types) ||
parser.resolveOperands(ops, {int32Ty, int1Ty}, parser.resolveOperands(ops, {int32Ty, int1Ty},
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

Show All 40 Linesstatic ParseResult parseROCDLMubufLoadOp(OpAsmParser &parser,
OperationState &result) { OperationState &result) {
SmallVector<OpAsmParser::OperandType, 8> ops; SmallVector<OpAsmParser::OperandType, 8> ops;
Type type; Type type;
if (parser.parseOperandList(ops, 5) || parser.parseColonType(type) || if (parser.parseOperandList(ops, 5) || parser.parseColonType(type) ||
parser.addTypeToList(type, result.types)) parser.addTypeToList(type, result.types))
return failure(); return failure();
MLIRContext *context = parser.getBuilder().getContext(); MLIRContext *context = parser.getBuilder().getContext();
auto int32Ty = LLVM::LLVMIntegerType::get(context, 32); auto int32Ty = IntegerType::get(context, 32);
auto int1Ty = LLVM::LLVMIntegerType::get(context, 1); auto int1Ty = IntegerType::get(context, 1);
auto i32x4Ty = LLVM::LLVMFixedVectorType::get(int32Ty, 4); auto i32x4Ty = LLVM::LLVMFixedVectorType::get(int32Ty, 4);
return parser.resolveOperands(ops, return parser.resolveOperands(ops,
{i32x4Ty, int32Ty, int32Ty, int1Ty, int1Ty}, {i32x4Ty, int32Ty, int32Ty, int1Ty, int1Ty},
parser.getNameLoc(), result.operands); parser.getNameLoc(), result.operands);
} }
// <operation> ::= // <operation> ::=
// `llvm.amdgcn.buffer.store.* %vdata, %rsrc, %vindex, %offset, %glc, %slc : // `llvm.amdgcn.buffer.store.* %vdata, %rsrc, %vindex, %offset, %glc, %slc :
// result_type` // result_type`
static ParseResult parseROCDLMubufStoreOp(OpAsmParser &parser, static ParseResult parseROCDLMubufStoreOp(OpAsmParser &parser,
OperationState &result) { OperationState &result) {
SmallVector<OpAsmParser::OperandType, 8> ops; SmallVector<OpAsmParser::OperandType, 8> ops;
Type type; Type type;
if (parser.parseOperandList(ops, 6) || parser.parseColonType(type)) if (parser.parseOperandList(ops, 6) || parser.parseColonType(type))
return failure(); return failure();
MLIRContext *context = parser.getBuilder().getContext(); MLIRContext *context = parser.getBuilder().getContext();
auto int32Ty = LLVM::LLVMIntegerType::get(context, 32); auto int32Ty = IntegerType::get(context, 32);
auto int1Ty = LLVM::LLVMIntegerType::get(context, 1); auto int1Ty = IntegerType::get(context, 1);
auto i32x4Ty = LLVM::LLVMFixedVectorType::get(int32Ty, 4); auto i32x4Ty = LLVM::LLVMFixedVectorType::get(int32Ty, 4);
if (parser.resolveOperands(ops, if (parser.resolveOperands(ops,
{type, i32x4Ty, int32Ty, int32Ty, int1Ty, int1Ty}, {type, i32x4Ty, int32Ty, int32Ty, int1Ty, int1Ty},
parser.getNameLoc(), result.operands)) parser.getNameLoc(), result.operands))
return failure(); return failure();
return success(); return success();
} }
Show All 18 Lines

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

Show First 20 Lines • Show All 368 Lines • ▼ Show 20 Lines
private: private:
/// Function result type packed with the variadic bit. /// Function result type packed with the variadic bit.
llvm::PointerIntPair<Type, 1, bool> returnTypeAndVariadic; llvm::PointerIntPair<Type, 1, bool> returnTypeAndVariadic;
/// Argument types. /// Argument types.
ArrayRef<Type> argumentTypes; ArrayRef<Type> argumentTypes;
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LLVMIntegerTypeStorage.
//===----------------------------------------------------------------------===//
/// Storage type for LLVM dialect integer types. These are uniqued by bitwidth.
struct LLVMIntegerTypeStorage : public TypeStorage {
using KeyTy = unsigned;
LLVMIntegerTypeStorage(unsigned width) : bitwidth(width) {}
static LLVMIntegerTypeStorage *construct(TypeStorageAllocator &allocator,
const KeyTy &key) {
return new (allocator.allocate<LLVMIntegerTypeStorage>())
LLVMIntegerTypeStorage(key);
}
bool operator==(const KeyTy &key) const { return key == bitwidth; }
unsigned bitwidth;
};
//===----------------------------------------------------------------------===//
// LLVMPointerTypeStorage. // LLVMPointerTypeStorage.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Storage type for LLVM dialect pointer types. These are uniqued by a pair of /// Storage type for LLVM dialect pointer types. These are uniqued by a pair of
/// element type and address space. /// element type and address space.
struct LLVMPointerTypeStorage : public TypeStorage { struct LLVMPointerTypeStorage : public TypeStorage {
using KeyTy = std::tuple<Type, unsigned>; using KeyTy = std::tuple<Type, unsigned>;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/lib/ExecutionEngine/JitRunner.cpp

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
template <typename Type> template <typename Type>
Error checkCompatibleReturnType(LLVM::LLVMFuncOp mainFunction); Error checkCompatibleReturnType(LLVM::LLVMFuncOp mainFunction);
template <> template <>
Error checkCompatibleReturnType<int32_t>(LLVM::LLVMFuncOp mainFunction) { Error checkCompatibleReturnType<int32_t>(LLVM::LLVMFuncOp mainFunction) {
auto resultType = mainFunction.getType() auto resultType = mainFunction.getType()
.cast<LLVM::LLVMFunctionType>() .cast<LLVM::LLVMFunctionType>()
.getReturnType() .getReturnType()
.dyn_cast<LLVM::LLVMIntegerType>(); .dyn_cast<IntegerType>();
if (!resultType || resultType.getBitWidth() != 32) if (!resultType || resultType.getWidth() != 32)
return make_string_error("only single llvm.i32 function result supported"); return make_string_error("only single llvm.i32 function result supported");
return Error::success(); return Error::success();
} }
template <> template <>
Error checkCompatibleReturnType<int64_t>(LLVM::LLVMFuncOp mainFunction) { Error checkCompatibleReturnType<int64_t>(LLVM::LLVMFuncOp mainFunction) {
auto resultType = mainFunction.getType() auto resultType = mainFunction.getType()
.cast<LLVM::LLVMFunctionType>() .cast<LLVM::LLVMFunctionType>()
.getReturnType() .getReturnType()
.dyn_cast<LLVM::LLVMIntegerType>(); .dyn_cast<IntegerType>();
if (!resultType || resultType.getBitWidth() != 64) if (!resultType || resultType.getWidth() != 64)
return make_string_error("only single llvm.i64 function result supported"); return make_string_error("only single llvm.i64 function result supported");
return Error::success(); return Error::success();
} }
template <> template <>
Error checkCompatibleReturnType<float>(LLVM::LLVMFuncOp mainFunction) { Error checkCompatibleReturnType<float>(LLVM::LLVMFuncOp mainFunction) {
if (!mainFunction.getType() if (!mainFunction.getType()
.cast<LLVM::LLVMFunctionType>() .cast<LLVM::LLVMFunctionType>()
.getReturnType() .getReturnType()
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
// attributes. Scalar and vector types are converted to the standard // attributes. Scalar and vector types are converted to the standard
// equivalents. Array types are converted to ranked tensors; nested array types // equivalents. Array types are converted to ranked tensors; nested array types
// are converted to multi-dimensional tensors or vectors, depending on the // are converted to multi-dimensional tensors or vectors, depending on the
// innermost type being a scalar or a vector. // innermost type being a scalar or a vector.
Type Importer::getStdTypeForAttr(Type type) { Type Importer::getStdTypeForAttr(Type type) {
if (!type) if (!type)
return nullptr; return nullptr;
if (auto intType = type.dyn_cast<LLVMIntegerType>()) if (auto intType = type.dyn_cast<IntegerType>())
return b.getIntegerType(intType.getBitWidth()); return intType;
if (type.isa<LLVMFloatType>()) if (type.isa<LLVMFloatType>())
return b.getF32Type(); return b.getF32Type();
if (type.isa<LLVMDoubleType>()) if (type.isa<LLVMDoubleType>())
return b.getF64Type(); return b.getF64Type();
// LLVM vectors can only contain scalars. // LLVM vectors can only contain scalars.
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines return b.getIntegerAttr(
IntegerType::get(context, ci->getType()->getBitWidth()), IntegerType::get(context, ci->getType()->getBitWidth()),
ci->getValue()); ci->getValue());
if (auto *c = dyn_cast<llvm::ConstantDataArray>(value)) if (auto *c = dyn_cast<llvm::ConstantDataArray>(value))
if (c->isString()) if (c->isString())
return b.getStringAttr(c->getAsString()); return b.getStringAttr(c->getAsString());
if (auto *c = dyn_cast<llvm::ConstantFP>(value)) { if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
if (c->getType()->isDoubleTy()) if (c->getType()->isDoubleTy())
return b.getFloatAttr(FloatType::getF64(context), c->getValueAPF()); return b.getFloatAttr(FloatType::getF64(context), c->getValueAPF());
else if (c->getType()->isFloatingPointTy()) if (c->getType()->isFloatingPointTy())
return b.getFloatAttr(FloatType::getF32(context), c->getValueAPF()); return b.getFloatAttr(FloatType::getF32(context), c->getValueAPF());
} }
if (auto *f = dyn_cast<llvm::Function>(value)) if (auto *f = dyn_cast<llvm::Function>(value))
return b.getSymbolRefAttr(f->getName()); return b.getSymbolRefAttr(f->getName());
// Convert constant data to a dense elements attribute. // Convert constant data to a dense elements attribute.
if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) { if (auto *cd = dyn_cast<llvm::ConstantDataSequential>(value)) {
Type type = processType(cd->getElementType()); Type type = processType(cd->getElementType());
if (!type) if (!type)
return nullptr; return nullptr;
auto attrType = getStdTypeForAttr(processType(cd->getType())) auto attrType = getStdTypeForAttr(processType(cd->getType()))
.dyn_cast_or_null<ShapedType>(); .dyn_cast_or_null<ShapedType>();
if (!attrType) if (!attrType)
return nullptr; return nullptr;
if (type.isa<LLVMIntegerType>()) { if (type.isa<IntegerType>()) {
SmallVector<APInt, 8> values; SmallVector<APInt, 8> values;
values.reserve(cd->getNumElements()); values.reserve(cd->getNumElements());
for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i) for (unsigned i = 0, e = cd->getNumElements(); i < e; ++i)
values.push_back(cd->getElementAsAPInt(i)); values.push_back(cd->getElementAsAPInt(i));
return DenseElementsAttr::get(attrType, values); return DenseElementsAttr::get(attrType, values);
} }
if (type.isa<LLVMFloatType>() || type.isa<LLVMDoubleType>()) { if (type.isa<LLVMFloatType>() || type.isa<LLVMDoubleType>()) {
▲ Show 20 Lines • Show All 611 Lines • Show Last 20 Lines

mlir/lib/Target/LLVMIR/TypeTranslation.cpp

//===- TypeTranslation.cpp - type translation between MLIR LLVM & LLVM IR -===// //===- TypeTranslation.cpp - type translation between MLIR LLVM & LLVM IR -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Target/LLVMIR/TypeTranslation.h" #include "mlir/Target/LLVMIR/TypeTranslation.h"
#include "mlir/Dialect/LLVMIR/LLVMTypes.h" #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/IR/DataLayout.h" #include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h" #include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines llvm::Type *translated =
return llvm::Type::getTokenTy(context); return llvm::Type::getTokenTy(context);
}) })
.Case([this](LLVM::LLVMLabelType) { .Case([this](LLVM::LLVMLabelType) {
return llvm::Type::getLabelTy(context); return llvm::Type::getLabelTy(context);
}) })
.Case([this](LLVM::LLVMMetadataType) { .Case([this](LLVM::LLVMMetadataType) {
return llvm::Type::getMetadataTy(context); return llvm::Type::getMetadataTy(context);
}) })
.Case<LLVM::LLVMArrayType, LLVM::LLVMIntegerType, .Case<LLVM::LLVMArrayType, IntegerType, LLVM::LLVMFunctionType,
LLVM::LLVMFunctionType, LLVM::LLVMPointerType, LLVM::LLVMPointerType, LLVM::LLVMStructType,
LLVM::LLVMStructType, LLVM::LLVMFixedVectorType, LLVM::LLVMFixedVectorType, LLVM::LLVMScalableVectorType>(
LLVM::LLVMScalableVectorType>(
[this](auto type) { return this->translate(type); }) [this](auto type) { return this->translate(type); })
.Default([](Type t) -> llvm::Type * { .Default([](Type t) -> llvm::Type * {
llvm_unreachable("unknown LLVM dialect type"); llvm_unreachable("unknown LLVM dialect type");
}); });
// Cache the result of the conversion and return. // Cache the result of the conversion and return.
knownTranslations.try_emplace(type, translated); knownTranslations.try_emplace(type, translated);
return translated; return translated;
Show All 10 Linesprivate:
llvm::Type *translate(LLVM::LLVMFunctionType type) { llvm::Type *translate(LLVM::LLVMFunctionType type) {
SmallVector<llvm::Type *, 8> paramTypes; SmallVector<llvm::Type *, 8> paramTypes;
translateTypes(type.getParams(), paramTypes); translateTypes(type.getParams(), paramTypes);
return llvm::FunctionType::get(translateType(type.getReturnType()), return llvm::FunctionType::get(translateType(type.getReturnType()),
paramTypes, type.isVarArg()); paramTypes, type.isVarArg());
} }
/// Translates the given integer type. /// Translates the given integer type.
llvm::Type *translate(LLVM::LLVMIntegerType type) { llvm::Type *translate(IntegerType type) {
return llvm::IntegerType::get(context, type.getBitWidth()); return llvm::IntegerType::get(context, type.getWidth());
} }
/// Translates the given pointer type. /// Translates the given pointer type.
llvm::Type *translate(LLVM::LLVMPointerType type) { llvm::Type *translate(LLVM::LLVMPointerType type) {
return llvm::PointerType::get(translateType(type.getElementType()), return llvm::PointerType::get(translateType(type.getElementType()),
type.getAddressSpace()); type.getAddressSpace());
} }
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines Type translate(llvm::FunctionType *type) {
SmallVector<Type, 8> paramTypes; SmallVector<Type, 8> paramTypes;
translateTypes(type->params(), paramTypes); translateTypes(type->params(), paramTypes);
return LLVM::LLVMFunctionType::get(translateType(type->getReturnType()), return LLVM::LLVMFunctionType::get(translateType(type->getReturnType()),
paramTypes, type->isVarArg()); paramTypes, type->isVarArg());
} }
/// Translates the given integer type. /// Translates the given integer type.
Type translate(llvm::IntegerType *type) { Type translate(llvm::IntegerType *type) {
return LLVM::LLVMIntegerType::get(&context, type->getBitWidth()); return IntegerType::get(&context, type->getBitWidth());
} }
/// Translates the given pointer type. /// Translates the given pointer type.
Type translate(llvm::PointerType *type) { Type translate(llvm::PointerType *type) {
return LLVM::LLVMPointerType::get(translateType(type->getElementType()), return LLVM::LLVMPointerType::get(translateType(type->getElementType()),
type->getAddressSpace()); type->getAddressSpace());
} }
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

mlir/test/Conversion/GPUCommon/lower-launch-func-to-gpu-runtime-calls.mlir

// RUN: mlir-opt %s --gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" | FileCheck %s // RUN: mlir-opt %s --gpu-to-llvm="gpu-binary-annotation=nvvm.cubin" | FileCheck %s
// RUN: mlir-opt %s --gpu-to-llvm="gpu-binary-annotation=rocdl.hsaco" | FileCheck %s --check-prefix=ROCDL // RUN: mlir-opt %s --gpu-to-llvm="gpu-binary-annotation=rocdl.hsaco" | FileCheck %s --check-prefix=ROCDL
module attributes {gpu.container_module} { module attributes {gpu.container_module} {
// CHECK: llvm.mlir.global internal constant @[[KERNEL_NAME:.*]]("kernel\00") // CHECK: llvm.mlir.global internal constant @[[KERNEL_NAME:.*]]("kernel\00")
// CHECK: llvm.mlir.global internal constant @[[GLOBAL:.*]]("CUBIN") // CHECK: llvm.mlir.global internal constant @[[GLOBAL:.*]]("CUBIN")
// ROCDL: llvm.mlir.global internal constant @[[GLOBAL:.*]]("HSACO") // ROCDL: llvm.mlir.global internal constant @[[GLOBAL:.*]]("HSACO")
gpu.module @kernel_module attributes { gpu.module @kernel_module attributes {
nvvm.cubin = "CUBIN", rocdl.hsaco = "HSACO" nvvm.cubin = "CUBIN", rocdl.hsaco = "HSACO"
} { } {
llvm.func @kernel(%arg0: !llvm.i32, %arg1: !llvm.ptr<float>, llvm.func @kernel(%arg0: i32, %arg1: !llvm.ptr<float>,
%arg2: !llvm.ptr<float>, %arg3: !llvm.i64, %arg4: !llvm.i64, %arg2: !llvm.ptr<float>, %arg3: i64, %arg4: i64,
%arg5: !llvm.i64) attributes {gpu.kernel} { %arg5: i64) attributes {gpu.kernel} {
llvm.return llvm.return
} }
} }
func @foo(%buffer: memref<?xf32>) { func @foo(%buffer: memref<?xf32>) {
%c8 = constant 8 : index %c8 = constant 8 : index
%c32 = constant 32 : i32 %c32 = constant 32 : i32
gpu.launch_func @kernel_module::@kernel gpu.launch_func @kernel_module::@kernel
blocks in (%c8, %c8, %c8) blocks in (%c8, %c8, %c8)
threads in (%c8, %c8, %c8) threads in (%c8, %c8, %c8)
args(%c32 : i32, %buffer : memref<?xf32>) args(%c32 : i32, %buffer : memref<?xf32>)
return return
} }
// CHECK: [[C8:%.*]] = llvm.mlir.constant(8 : index) : !llvm.i64 // CHECK: [[C8:%.*]] = llvm.mlir.constant(8 : index) : i64
// CHECK: [[ADDRESSOF:%.*]] = llvm.mlir.addressof @[[GLOBAL]] // CHECK: [[ADDRESSOF:%.*]] = llvm.mlir.addressof @[[GLOBAL]]
// CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : index) // CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : index)
// CHECK: [[BINARY:%.*]] = llvm.getelementptr [[ADDRESSOF]]{{\[}}[[C0]], [[C0]]] // CHECK: [[BINARY:%.*]] = llvm.getelementptr [[ADDRESSOF]]{{\[}}[[C0]], [[C0]]]
// CHECK-SAME: -> !llvm.ptr<i8> // CHECK-SAME: -> !llvm.ptr<i8>
// CHECK: [[MODULE:%.*]] = llvm.call @mgpuModuleLoad([[BINARY]]) // CHECK: [[MODULE:%.*]] = llvm.call @mgpuModuleLoad([[BINARY]])
// CHECK: [[FUNC:%.*]] = llvm.call @mgpuModuleGetFunction([[MODULE]], {{.*}}) // CHECK: [[FUNC:%.*]] = llvm.call @mgpuModuleGetFunction([[MODULE]], {{.*}})
// CHECK: [[C0_I32:%.*]] = llvm.mlir.constant(0 : i32) // CHECK: [[C0_I32:%.*]] = llvm.mlir.constant(0 : i32)
// CHECK: [[STREAM:%.*]] = llvm.call @mgpuStreamCreate // CHECK: [[STREAM:%.*]] = llvm.call @mgpuStreamCreate
// CHECK: [[NUM_PARAMS:%.*]] = llvm.mlir.constant(6 : i32) : !llvm.i32 // CHECK: [[NUM_PARAMS:%.*]] = llvm.mlir.constant(6 : i32) : i32
// CHECK-NEXT: [[PARAMS:%.*]] = llvm.alloca [[NUM_PARAMS]] x !llvm.ptr<i8> // CHECK-NEXT: [[PARAMS:%.*]] = llvm.alloca [[NUM_PARAMS]] x !llvm.ptr<i8>
// CHECK: [[EXTRA_PARAMS:%.*]] = llvm.mlir.null : !llvm.ptr<ptr<i8>> // CHECK: [[EXTRA_PARAMS:%.*]] = llvm.mlir.null : !llvm.ptr<ptr<i8>>
// CHECK: llvm.call @mgpuLaunchKernel([[FUNC]], [[C8]], [[C8]], [[C8]], // CHECK: llvm.call @mgpuLaunchKernel([[FUNC]], [[C8]], [[C8]], [[C8]],
// CHECK-SAME: [[C8]], [[C8]], [[C8]], [[C0_I32]], [[STREAM]], // CHECK-SAME: [[C8]], [[C8]], [[C8]], [[C0_I32]], [[STREAM]],
// CHECK-SAME: [[PARAMS]], [[EXTRA_PARAMS]]) // CHECK-SAME: [[PARAMS]], [[EXTRA_PARAMS]])
// CHECK: llvm.call @mgpuStreamSynchronize // CHECK: llvm.call @mgpuStreamSynchronize
// CHECK: llvm.call @mgpuStreamDestroy // CHECK: llvm.call @mgpuStreamDestroy
// CHECK: llvm.call @mgpuModuleUnload // CHECK: llvm.call @mgpuModuleUnload
} }

mlir/test/Conversion/GPUCommon/memory-attrbution.mlir

// RUN: mlir-opt -allow-unregistered-dialect --convert-gpu-to-nvvm --split-input-file %s | FileCheck --check-prefix=NVVM %s // RUN: mlir-opt -allow-unregistered-dialect --convert-gpu-to-nvvm --split-input-file %s | FileCheck --check-prefix=NVVM %s
// RUN: mlir-opt -allow-unregistered-dialect --convert-gpu-to-rocdl --split-input-file %s | FileCheck --check-prefix=ROCDL %s // RUN: mlir-opt -allow-unregistered-dialect --convert-gpu-to-rocdl --split-input-file %s | FileCheck --check-prefix=ROCDL %s
gpu.module @kernel { gpu.module @kernel {
// NVVM-LABEL: llvm.func @private // NVVM-LABEL: llvm.func @private
gpu.func @private(%arg0: f32) private(%arg1: memref<4xf32, 5>) { gpu.func @private(%arg0: f32) private(%arg1: memref<4xf32, 5>) {
// Allocate private memory inside the function. // Allocate private memory inside the function.
// NVVM: %[[size:.*]] = llvm.mlir.constant(4 : i64) : !llvm.i64 // NVVM: %[[size:.*]] = llvm.mlir.constant(4 : i64) : i64
// NVVM: %[[raw:.*]] = llvm.alloca %[[size]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float> // NVVM: %[[raw:.*]] = llvm.alloca %[[size]] x !llvm.float : (i64) -> !llvm.ptr<float>
// ROCDL: %[[size:.*]] = llvm.mlir.constant(4 : i64) : !llvm.i64 // ROCDL: %[[size:.*]] = llvm.mlir.constant(4 : i64) : i64
// ROCDL: %[[raw:.*]] = llvm.alloca %[[size]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float, 5> // ROCDL: %[[raw:.*]] = llvm.alloca %[[size]] x !llvm.float : (i64) -> !llvm.ptr<float, 5>
// Populate the memref descriptor. // Populate the memref descriptor.
// NVVM: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // NVVM: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// NVVM: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0] // NVVM: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0]
// NVVM: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1] // NVVM: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1]
// NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// NVVM: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2] // NVVM: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2]
// NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// NVVM: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0] // NVVM: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0]
// NVVM: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // NVVM: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// NVVM: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0] // NVVM: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0]
// ROCDL: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 5>, ptr<float, 5>, i64, array<1 x i64>, array<1 x i64>)> // ROCDL: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 5>, ptr<float, 5>, i64, array<1 x i64>, array<1 x i64>)>
// ROCDL: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0] // ROCDL: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0]
// ROCDL: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1] // ROCDL: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1]
// ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// ROCDL: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2] // ROCDL: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2]
// ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// ROCDL: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0] // ROCDL: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0]
// ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// ROCDL: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0] // ROCDL: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0]
// "Store" lowering should work just as any other memref, only check that // "Store" lowering should work just as any other memref, only check that
// we emit some core instructions. // we emit some core instructions.
// NVVM: llvm.extractvalue %[[descr6:.*]] // NVVM: llvm.extractvalue %[[descr6:.*]]
// NVVM: llvm.getelementptr // NVVM: llvm.getelementptr
// NVVM: llvm.store // NVVM: llvm.store
Show All 21 Linesgpu.module @kernel {
// NVVM-LABEL: llvm.func @workgroup // NVVM-LABEL: llvm.func @workgroup
// NVVM-SAME: { // NVVM-SAME: {
// ROCDL-LABEL: llvm.func @workgroup // ROCDL-LABEL: llvm.func @workgroup
// ROCDL-SAME: { // ROCDL-SAME: {
gpu.func @workgroup(%arg0: f32) workgroup(%arg1: memref<4xf32, 3>) { gpu.func @workgroup(%arg0: f32) workgroup(%arg1: memref<4xf32, 3>) {
// Get the address of the first element in the global array. // Get the address of the first element in the global array.
// NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : i32
// NVVM: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<4 x float>, 3> // NVVM: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<4 x float>, 3>
// NVVM: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]] // NVVM: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]]
// NVVM-SAME: !llvm.ptr<float, 3> // NVVM-SAME: !llvm.ptr<float, 3>
// ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : i32
// ROCDL: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<4 x float>, 3> // ROCDL: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<4 x float>, 3>
// ROCDL: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]] // ROCDL: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]]
// ROCDL-SAME: !llvm.ptr<float, 3> // ROCDL-SAME: !llvm.ptr<float, 3>
// Populate the memref descriptor. // Populate the memref descriptor.
// NVVM: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<1 x i64>, array<1 x i64>)> // NVVM: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<1 x i64>, array<1 x i64>)>
// NVVM: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0] // NVVM: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0]
// NVVM: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1] // NVVM: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1]
// NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// NVVM: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2] // NVVM: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2]
// NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// NVVM: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0] // NVVM: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0]
// NVVM: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // NVVM: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// NVVM: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0] // NVVM: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0]
// ROCDL: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<1 x i64>, array<1 x i64>)> // ROCDL: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<1 x i64>, array<1 x i64>)>
// ROCDL: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0] // ROCDL: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0]
// ROCDL: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1] // ROCDL: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1]
// ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// ROCDL: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2] // ROCDL: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2]
// ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// ROCDL: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0] // ROCDL: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0]
// ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// ROCDL: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0] // ROCDL: %[[descr6:.*]] = llvm.insertvalue %[[c1]], %[[descr5]][4, 0]
// "Store" lowering should work just as any other memref, only check that // "Store" lowering should work just as any other memref, only check that
// we emit some core instructions. // we emit some core instructions.
// NVVM: llvm.extractvalue %[[descr6:.*]] // NVVM: llvm.extractvalue %[[descr6:.*]]
// NVVM: llvm.getelementptr // NVVM: llvm.getelementptr
// NVVM: llvm.store // NVVM: llvm.store
Show All 18 Linesgpu.module @kernel {
// ROCDL: llvm.mlir.global internal @[[$buffer:.*]]() // ROCDL: llvm.mlir.global internal @[[$buffer:.*]]()
// ROCDL-SAME: addr_space = 3 // ROCDL-SAME: addr_space = 3
// ROCDL-SAME: !llvm.array<48 x float> // ROCDL-SAME: !llvm.array<48 x float>
// NVVM-LABEL: llvm.func @workgroup3d // NVVM-LABEL: llvm.func @workgroup3d
// ROCDL-LABEL: llvm.func @workgroup3d // ROCDL-LABEL: llvm.func @workgroup3d
gpu.func @workgroup3d(%arg0: f32) workgroup(%arg1: memref<4x2x6xf32, 3>) { gpu.func @workgroup3d(%arg0: f32) workgroup(%arg1: memref<4x2x6xf32, 3>) {
// Get the address of the first element in the global array. // Get the address of the first element in the global array.
// NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : i32
// NVVM: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<48 x float>, 3> // NVVM: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<48 x float>, 3>
// NVVM: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]] // NVVM: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]]
// NVVM-SAME: !llvm.ptr<float, 3> // NVVM-SAME: !llvm.ptr<float, 3>
// ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : i32
// ROCDL: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<48 x float>, 3> // ROCDL: %[[addr:.*]] = llvm.mlir.addressof @[[$buffer]] : !llvm.ptr<array<48 x float>, 3>
// ROCDL: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]] // ROCDL: %[[raw:.*]] = llvm.getelementptr %[[addr]][%[[c0]], %[[c0]]]
// ROCDL-SAME: !llvm.ptr<float, 3> // ROCDL-SAME: !llvm.ptr<float, 3>
// Populate the memref descriptor. // Populate the memref descriptor.
// NVVM: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<3 x i64>, array<3 x i64>)> // NVVM: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<3 x i64>, array<3 x i64>)>
// NVVM: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0] // NVVM: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0]
// NVVM: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1] // NVVM: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1]
// NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // NVVM: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// NVVM: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2] // NVVM: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2]
// NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// NVVM: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0] // NVVM: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0]
// NVVM: %[[c12:.*]] = llvm.mlir.constant(12 : index) : !llvm.i64 // NVVM: %[[c12:.*]] = llvm.mlir.constant(12 : index) : i64
// NVVM: %[[descr6:.*]] = llvm.insertvalue %[[c12]], %[[descr5]][4, 0] // NVVM: %[[descr6:.*]] = llvm.insertvalue %[[c12]], %[[descr5]][4, 0]
// NVVM: %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // NVVM: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64
// NVVM: %[[descr7:.*]] = llvm.insertvalue %[[c2]], %[[descr6]][3, 1] // NVVM: %[[descr7:.*]] = llvm.insertvalue %[[c2]], %[[descr6]][3, 1]
// NVVM: %[[c6:.*]] = llvm.mlir.constant(6 : index) : !llvm.i64 // NVVM: %[[c6:.*]] = llvm.mlir.constant(6 : index) : i64
// NVVM: %[[descr8:.*]] = llvm.insertvalue %[[c6]], %[[descr7]][4, 1] // NVVM: %[[descr8:.*]] = llvm.insertvalue %[[c6]], %[[descr7]][4, 1]
// NVVM: %[[c6:.*]] = llvm.mlir.constant(6 : index) : !llvm.i64 // NVVM: %[[c6:.*]] = llvm.mlir.constant(6 : index) : i64
// NVVM: %[[descr9:.*]] = llvm.insertvalue %[[c6]], %[[descr8]][3, 2] // NVVM: %[[descr9:.*]] = llvm.insertvalue %[[c6]], %[[descr8]][3, 2]
// NVVM: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // NVVM: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// NVVM: %[[descr10:.*]] = llvm.insertvalue %[[c1]], %[[descr9]][4, 2] // NVVM: %[[descr10:.*]] = llvm.insertvalue %[[c1]], %[[descr9]][4, 2]
// ROCDL: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<3 x i64>, array<3 x i64>)> // ROCDL: %[[descr1:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<3 x i64>, array<3 x i64>)>
// ROCDL: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0] // ROCDL: %[[descr2:.*]] = llvm.insertvalue %[[raw]], %[[descr1]][0]
// ROCDL: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1] // ROCDL: %[[descr3:.*]] = llvm.insertvalue %[[raw]], %[[descr2]][1]
// ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // ROCDL: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// ROCDL: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2] // ROCDL: %[[descr4:.*]] = llvm.insertvalue %[[c0]], %[[descr3]][2]
// ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// ROCDL: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0] // ROCDL: %[[descr5:.*]] = llvm.insertvalue %[[c4]], %[[descr4]][3, 0]
// ROCDL: %[[c12:.*]] = llvm.mlir.constant(12 : index) : !llvm.i64 // ROCDL: %[[c12:.*]] = llvm.mlir.constant(12 : index) : i64
// ROCDL: %[[descr6:.*]] = llvm.insertvalue %[[c12]], %[[descr5]][4, 0] // ROCDL: %[[descr6:.*]] = llvm.insertvalue %[[c12]], %[[descr5]][4, 0]
// ROCDL: %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // ROCDL: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64
// ROCDL: %[[descr7:.*]] = llvm.insertvalue %[[c2]], %[[descr6]][3, 1] // ROCDL: %[[descr7:.*]] = llvm.insertvalue %[[c2]], %[[descr6]][3, 1]
// ROCDL: %[[c6:.*]] = llvm.mlir.constant(6 : index) : !llvm.i64 // ROCDL: %[[c6:.*]] = llvm.mlir.constant(6 : index) : i64
// ROCDL: %[[descr8:.*]] = llvm.insertvalue %[[c6]], %[[descr7]][4, 1] // ROCDL: %[[descr8:.*]] = llvm.insertvalue %[[c6]], %[[descr7]][4, 1]
// ROCDL: %[[c6:.*]] = llvm.mlir.constant(6 : index) : !llvm.i64 // ROCDL: %[[c6:.*]] = llvm.mlir.constant(6 : index) : i64
// ROCDL: %[[descr9:.*]] = llvm.insertvalue %[[c6]], %[[descr8]][3, 2] // ROCDL: %[[descr9:.*]] = llvm.insertvalue %[[c6]], %[[descr8]][3, 2]
// ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // ROCDL: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// ROCDL: %[[descr10:.*]] = llvm.insertvalue %[[c1]], %[[descr9]][4, 2] // ROCDL: %[[descr10:.*]] = llvm.insertvalue %[[c1]], %[[descr9]][4, 2]
%c0 = constant 0 : index %c0 = constant 0 : index
store %arg0, %arg1[%c0,%c0,%c0] : memref<4x2x6xf32, 3> store %arg0, %arg1[%c0,%c0,%c0] : memref<4x2x6xf32, 3>
"terminator"() : () -> () "terminator"() : () -> ()
} }
} }
Show All 21 Lines gpu.func @multiple(%arg0: f32)
// NVVM: llvm.mlir.addressof @[[$buffer1]] // NVVM: llvm.mlir.addressof @[[$buffer1]]
// NVVM: llvm.mlir.addressof @[[$buffer2]] // NVVM: llvm.mlir.addressof @[[$buffer2]]
// ROCDL: llvm.mlir.addressof @[[$buffer1]] // ROCDL: llvm.mlir.addressof @[[$buffer1]]
// ROCDL: llvm.mlir.addressof @[[$buffer2]] // ROCDL: llvm.mlir.addressof @[[$buffer2]]
// Private buffers. // Private buffers.
// NVVM: %[[c3:.*]] = llvm.mlir.constant(3 : i64) // NVVM: %[[c3:.*]] = llvm.mlir.constant(3 : i64)
// NVVM: llvm.alloca %[[c3]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float> // NVVM: llvm.alloca %[[c3]] x !llvm.float : (i64) -> !llvm.ptr<float>
// NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : i64) // NVVM: %[[c4:.*]] = llvm.mlir.constant(4 : i64)
// NVVM: llvm.alloca %[[c4]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float> // NVVM: llvm.alloca %[[c4]] x !llvm.float : (i64) -> !llvm.ptr<float>
// ROCDL: %[[c3:.*]] = llvm.mlir.constant(3 : i64) // ROCDL: %[[c3:.*]] = llvm.mlir.constant(3 : i64)
// ROCDL: llvm.alloca %[[c3]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float, 5> // ROCDL: llvm.alloca %[[c3]] x !llvm.float : (i64) -> !llvm.ptr<float, 5>
// ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : i64) // ROCDL: %[[c4:.*]] = llvm.mlir.constant(4 : i64)
// ROCDL: llvm.alloca %[[c4]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float, 5> // ROCDL: llvm.alloca %[[c4]] x !llvm.float : (i64) -> !llvm.ptr<float, 5>
%c0 = constant 0 : index %c0 = constant 0 : index
store %arg0, %arg1[%c0] : memref<1xf32, 3> store %arg0, %arg1[%c0] : memref<1xf32, 3>
store %arg0, %arg2[%c0] : memref<2xf32, 3> store %arg0, %arg2[%c0] : memref<2xf32, 3>
store %arg0, %arg3[%c0] : memref<3xf32, 5> store %arg0, %arg3[%c0] : memref<3xf32, 5>
store %arg0, %arg4[%c0] : memref<4xf32, 5> store %arg0, %arg4[%c0] : memref<4xf32, 5>
"terminator"() : () -> () "terminator"() : () -> ()
} }
} }

mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm.mlir

// RUN: mlir-opt %s -convert-gpu-to-nvvm -split-input-file | FileCheck %s // RUN: mlir-opt %s -convert-gpu-to-nvvm -split-input-file | FileCheck %s
// RUN: mlir-opt %s -convert-gpu-to-nvvm='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt %s -convert-gpu-to-nvvm='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_ops() // CHECK-LABEL: func @gpu_index_ops()
// CHECK32-LABEL: func @gpu_index_ops() // CHECK32-LABEL: func @gpu_index_ops()
func @gpu_index_ops() func @gpu_index_ops()
-> (index, index, index, index, index, index, -> (index, index, index, index, index, index,
index, index, index, index, index, index) { index, index, index, index, index, index) {
// CHECK32-NOT: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK32-NOT: = llvm.sext %{{.*}} : i32 to i64
// CHECK: = nvvm.read.ptx.sreg.tid.x : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.tid.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index) %tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.tid.y : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.tid.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdY = "gpu.thread_id"() {dimension = "y"} : () -> (index) %tIdY = "gpu.thread_id"() {dimension = "y"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.tid.z : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.tid.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdZ = "gpu.thread_id"() {dimension = "z"} : () -> (index) %tIdZ = "gpu.thread_id"() {dimension = "z"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.ntid.x : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.ntid.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bDimX = "gpu.block_dim"() {dimension = "x"} : () -> (index) %bDimX = "gpu.block_dim"() {dimension = "x"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.ntid.y : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.ntid.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bDimY = "gpu.block_dim"() {dimension = "y"} : () -> (index) %bDimY = "gpu.block_dim"() {dimension = "y"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.ntid.z : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.ntid.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bDimZ = "gpu.block_dim"() {dimension = "z"} : () -> (index) %bDimZ = "gpu.block_dim"() {dimension = "z"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.ctaid.x : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.ctaid.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bIdX = "gpu.block_id"() {dimension = "x"} : () -> (index) %bIdX = "gpu.block_id"() {dimension = "x"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.ctaid.y : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.ctaid.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bIdY = "gpu.block_id"() {dimension = "y"} : () -> (index) %bIdY = "gpu.block_id"() {dimension = "y"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.ctaid.z : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.ctaid.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bIdZ = "gpu.block_id"() {dimension = "z"} : () -> (index) %bIdZ = "gpu.block_id"() {dimension = "z"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.nctaid.x : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.nctaid.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%gDimX = "gpu.grid_dim"() {dimension = "x"} : () -> (index) %gDimX = "gpu.grid_dim"() {dimension = "x"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.nctaid.y : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.nctaid.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%gDimY = "gpu.grid_dim"() {dimension = "y"} : () -> (index) %gDimY = "gpu.grid_dim"() {dimension = "y"} : () -> (index)
// CHECK: = nvvm.read.ptx.sreg.nctaid.z : !llvm.i32 // CHECK: = nvvm.read.ptx.sreg.nctaid.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%gDimZ = "gpu.grid_dim"() {dimension = "z"} : () -> (index) %gDimZ = "gpu.grid_dim"() {dimension = "z"} : () -> (index)
std.return %tIdX, %tIdY, %tIdZ, %bDimX, %bDimY, %bDimZ, std.return %tIdX, %tIdY, %tIdZ, %bDimX, %bDimY, %bDimZ,
%bIdX, %bIdY, %bIdZ, %gDimX, %gDimY, %gDimZ %bIdX, %bIdY, %bIdZ, %gDimX, %gDimY, %gDimZ
: index, index, index, index, index, index, : index, index, index, index, index, index,
index, index, index, index, index, index index, index, index, index, index, index
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_comp // CHECK-LABEL: func @gpu_index_comp
// CHECK32-LABEL: func @gpu_index_comp // CHECK32-LABEL: func @gpu_index_comp
func @gpu_index_comp(%idx : index) -> index { func @gpu_index_comp(%idx : index) -> index {
// CHECK: = llvm.add %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: = llvm.add %{{.*}}, %{{.*}} : i64
// CHECK32: = llvm.add %{{.*}}, %{{.*}} : !llvm.i32 // CHECK32: = llvm.add %{{.*}}, %{{.*}} : i32
%0 = addi %idx, %idx : index %0 = addi %idx, %idx : index
// CHECK: llvm.return %{{.*}} : !llvm.i64 // CHECK: llvm.return %{{.*}} : i64
// CHECK32: llvm.return %{{.*}} : !llvm.i32 // CHECK32: llvm.return %{{.*}} : i32
std.return %0 : index std.return %0 : index
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_all_reduce_op() // CHECK-LABEL: func @gpu_all_reduce_op()
Show All 29 Lines
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_shuffle() // CHECK-LABEL: func @gpu_shuffle()
func @gpu_shuffle() -> (f32) { func @gpu_shuffle() -> (f32) {
// CHECK: %[[#VALUE:]] = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float // CHECK: %[[#VALUE:]] = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float
%arg0 = constant 1.0 : f32 %arg0 = constant 1.0 : f32
// CHECK: %[[#OFFSET:]] = llvm.mlir.constant(4 : i32) : !llvm.i32 // CHECK: %[[#OFFSET:]] = llvm.mlir.constant(4 : i32) : i32
%arg1 = constant 4 : i32 %arg1 = constant 4 : i32
// CHECK: %[[#WIDTH:]] = llvm.mlir.constant(23 : i32) : !llvm.i32 // CHECK: %[[#WIDTH:]] = llvm.mlir.constant(23 : i32) : i32
%arg2 = constant 23 : i32 %arg2 = constant 23 : i32
// CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[#ONE:]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[#SHL:]] = llvm.shl %[[#ONE]], %[[#WIDTH]] : !llvm.i32 // CHECK: %[[#SHL:]] = llvm.shl %[[#ONE]], %[[#WIDTH]] : i32
// CHECK: %[[#MASK:]] = llvm.sub %[[#SHL]], %[[#ONE]] : !llvm.i32 // CHECK: %[[#MASK:]] = llvm.sub %[[#SHL]], %[[#ONE]] : i32
// CHECK: %[[#CLAMP:]] = llvm.sub %[[#WIDTH]], %[[#ONE]] : !llvm.i32 // CHECK: %[[#CLAMP:]] = llvm.sub %[[#WIDTH]], %[[#ONE]] : i32
// CHECK: %[[#SHFL:]] = nvvm.shfl.sync.bfly %[[#MASK]], %[[#VALUE]], %[[#OFFSET]], %[[#CLAMP]] : !llvm.struct<(float, i1)> // CHECK: %[[#SHFL:]] = nvvm.shfl.sync.bfly %[[#MASK]], %[[#VALUE]], %[[#OFFSET]], %[[#CLAMP]] : !llvm.struct<(float, i1)>
// CHECK: llvm.extractvalue %[[#SHFL]][0 : index] : !llvm.struct<(float, i1)> // CHECK: llvm.extractvalue %[[#SHFL]][0 : index] : !llvm.struct<(float, i1)>
// CHECK: llvm.extractvalue %[[#SHFL]][1 : index] : !llvm.struct<(float, i1)> // CHECK: llvm.extractvalue %[[#SHFL]][1 : index] : !llvm.struct<(float, i1)>
%shfl, %pred = "gpu.shuffle"(%arg0, %arg1, %arg2) { mode = "xor" } : (f32, i32, i32) -> (f32, i1) %shfl, %pred = "gpu.shuffle"(%arg0, %arg1, %arg2) { mode = "xor" } : (f32, i32, i32) -> (f32, i1)
std.return %shfl : f32 std.return %shfl : f32
} }
} }
▲ Show 20 Lines • Show All 280 Lines • Show Last 20 Lines

mlir/test/Conversion/GPUToROCDL/gpu-to-rocdl.mlir

// RUN: mlir-opt %s -convert-gpu-to-rocdl -split-input-file | FileCheck %s // RUN: mlir-opt %s -convert-gpu-to-rocdl -split-input-file | FileCheck %s
// RUN: mlir-opt %s -convert-gpu-to-rocdl='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt %s -convert-gpu-to-rocdl='index-bitwidth=32' -split-input-file | FileCheck --check-prefix=CHECK32 %s
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_ops() // CHECK-LABEL: func @gpu_index_ops()
// CHECK32-LABEL: func @gpu_index_ops() // CHECK32-LABEL: func @gpu_index_ops()
func @gpu_index_ops() func @gpu_index_ops()
-> (index, index, index, index, index, index, -> (index, index, index, index, index, index,
index, index, index, index, index, index) { index, index, index, index, index, index) {
// CHECK32-NOT: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK32-NOT: = llvm.sext %{{.*}} : i32 to i64
// CHECK: rocdl.workitem.id.x : !llvm.i32 // CHECK: rocdl.workitem.id.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index) %tIdX = "gpu.thread_id"() {dimension = "x"} : () -> (index)
// CHECK: rocdl.workitem.id.y : !llvm.i32 // CHECK: rocdl.workitem.id.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdY = "gpu.thread_id"() {dimension = "y"} : () -> (index) %tIdY = "gpu.thread_id"() {dimension = "y"} : () -> (index)
// CHECK: rocdl.workitem.id.z : !llvm.i32 // CHECK: rocdl.workitem.id.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%tIdZ = "gpu.thread_id"() {dimension = "z"} : () -> (index) %tIdZ = "gpu.thread_id"() {dimension = "z"} : () -> (index)
// CHECK: rocdl.workgroup.dim.x : !llvm.i32 // CHECK: rocdl.workgroup.dim.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bDimX = "gpu.block_dim"() {dimension = "x"} : () -> (index) %bDimX = "gpu.block_dim"() {dimension = "x"} : () -> (index)
// CHECK: rocdl.workgroup.dim.y : !llvm.i32 // CHECK: rocdl.workgroup.dim.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bDimY = "gpu.block_dim"() {dimension = "y"} : () -> (index) %bDimY = "gpu.block_dim"() {dimension = "y"} : () -> (index)
// CHECK: rocdl.workgroup.dim.z : !llvm.i32 // CHECK: rocdl.workgroup.dim.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bDimZ = "gpu.block_dim"() {dimension = "z"} : () -> (index) %bDimZ = "gpu.block_dim"() {dimension = "z"} : () -> (index)
// CHECK: rocdl.workgroup.id.x : !llvm.i32 // CHECK: rocdl.workgroup.id.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bIdX = "gpu.block_id"() {dimension = "x"} : () -> (index) %bIdX = "gpu.block_id"() {dimension = "x"} : () -> (index)
// CHECK: rocdl.workgroup.id.y : !llvm.i32 // CHECK: rocdl.workgroup.id.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bIdY = "gpu.block_id"() {dimension = "y"} : () -> (index) %bIdY = "gpu.block_id"() {dimension = "y"} : () -> (index)
// CHECK: rocdl.workgroup.id.z : !llvm.i32 // CHECK: rocdl.workgroup.id.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%bIdZ = "gpu.block_id"() {dimension = "z"} : () -> (index) %bIdZ = "gpu.block_id"() {dimension = "z"} : () -> (index)
// CHECK: rocdl.grid.dim.x : !llvm.i32 // CHECK: rocdl.grid.dim.x : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%gDimX = "gpu.grid_dim"() {dimension = "x"} : () -> (index) %gDimX = "gpu.grid_dim"() {dimension = "x"} : () -> (index)
// CHECK: rocdl.grid.dim.y : !llvm.i32 // CHECK: rocdl.grid.dim.y : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%gDimY = "gpu.grid_dim"() {dimension = "y"} : () -> (index) %gDimY = "gpu.grid_dim"() {dimension = "y"} : () -> (index)
// CHECK: rocdl.grid.dim.z : !llvm.i32 // CHECK: rocdl.grid.dim.z : i32
// CHECK: = llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: = llvm.sext %{{.*}} : i32 to i64
%gDimZ = "gpu.grid_dim"() {dimension = "z"} : () -> (index) %gDimZ = "gpu.grid_dim"() {dimension = "z"} : () -> (index)
std.return %tIdX, %tIdY, %tIdZ, %bDimX, %bDimY, %bDimZ, std.return %tIdX, %tIdY, %tIdZ, %bDimX, %bDimY, %bDimZ,
%bIdX, %bIdY, %bIdZ, %gDimX, %gDimY, %gDimZ %bIdX, %bIdY, %bIdZ, %gDimX, %gDimY, %gDimZ
: index, index, index, index, index, index, : index, index, index, index, index, index,
index, index, index, index, index, index index, index, index, index, index, index
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_index_comp // CHECK-LABEL: func @gpu_index_comp
// CHECK32-LABEL: func @gpu_index_comp // CHECK32-LABEL: func @gpu_index_comp
func @gpu_index_comp(%idx : index) -> index { func @gpu_index_comp(%idx : index) -> index {
// CHECK: = llvm.add %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: = llvm.add %{{.*}}, %{{.*}} : i64
// CHECK32: = llvm.add %{{.*}}, %{{.*}} : !llvm.i32 // CHECK32: = llvm.add %{{.*}}, %{{.*}} : i32
%0 = addi %idx, %idx : index %0 = addi %idx, %idx : index
// CHECK: llvm.return %{{.*}} : !llvm.i64 // CHECK: llvm.return %{{.*}} : i64
// CHECK32: llvm.return %{{.*}} : !llvm.i32 // CHECK32: llvm.return %{{.*}} : i32
std.return %0 : index std.return %0 : index
} }
} }
// ----- // -----
gpu.module @test_module { gpu.module @test_module {
// CHECK-LABEL: func @gpu_sync() // CHECK-LABEL: func @gpu_sync()
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

mlir/test/Conversion/GPUToVulkan/invoke-vulkan.mlir

// RUN: mlir-opt %s -launch-func-to-vulkan | FileCheck %s // RUN: mlir-opt %s -launch-func-to-vulkan | FileCheck %s
// CHECK: llvm.mlir.global internal constant @kernel_spv_entry_point_name // CHECK: llvm.mlir.global internal constant @kernel_spv_entry_point_name
// CHECK: llvm.mlir.global internal constant @SPIRV_BIN // CHECK: llvm.mlir.global internal constant @SPIRV_BIN
// CHECK: %[[Vulkan_Runtime_ptr:.*]] = llvm.call @initVulkan() : () -> !llvm.ptr<i8> // CHECK: %[[Vulkan_Runtime_ptr:.*]] = llvm.call @initVulkan() : () -> !llvm.ptr<i8>
// CHECK: %[[addressof_SPIRV_BIN:.*]] = llvm.mlir.addressof @SPIRV_BIN // CHECK: %[[addressof_SPIRV_BIN:.*]] = llvm.mlir.addressof @SPIRV_BIN
// CHECK: %[[SPIRV_BIN_ptr:.*]] = llvm.getelementptr %[[addressof_SPIRV_BIN]] // CHECK: %[[SPIRV_BIN_ptr:.*]] = llvm.getelementptr %[[addressof_SPIRV_BIN]]
// CHECK: %[[SPIRV_BIN_size:.*]] = llvm.mlir.constant // CHECK: %[[SPIRV_BIN_size:.*]] = llvm.mlir.constant
// CHECK: llvm.call @bindMemRef1DFloat(%[[Vulkan_Runtime_ptr]], %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.i32, !llvm.i32, !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>) -> !llvm.void // CHECK: llvm.call @bindMemRef1DFloat(%[[Vulkan_Runtime_ptr]], %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, i32, i32, !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>) -> !llvm.void
// CHECK: llvm.call @setBinaryShader(%[[Vulkan_Runtime_ptr]], %[[SPIRV_BIN_ptr]], %[[SPIRV_BIN_size]]) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32) -> !llvm.void // CHECK: llvm.call @setBinaryShader(%[[Vulkan_Runtime_ptr]], %[[SPIRV_BIN_ptr]], %[[SPIRV_BIN_size]]) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32) -> !llvm.void
// CHECK: %[[addressof_entry_point:.*]] = llvm.mlir.addressof @kernel_spv_entry_point_name // CHECK: %[[addressof_entry_point:.*]] = llvm.mlir.addressof @kernel_spv_entry_point_name
// CHECK: %[[entry_point_ptr:.*]] = llvm.getelementptr %[[addressof_entry_point]] // CHECK: %[[entry_point_ptr:.*]] = llvm.getelementptr %[[addressof_entry_point]]
// CHECK: llvm.call @setEntryPoint(%[[Vulkan_Runtime_ptr]], %[[entry_point_ptr]]) : (!llvm.ptr<i8>, !llvm.ptr<i8>) -> !llvm.void // CHECK: llvm.call @setEntryPoint(%[[Vulkan_Runtime_ptr]], %[[entry_point_ptr]]) : (!llvm.ptr<i8>, !llvm.ptr<i8>) -> !llvm.void
// CHECK: llvm.call @setNumWorkGroups(%[[Vulkan_Runtime_ptr]], %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.i64, !llvm.i64, !llvm.i64) -> !llvm.void // CHECK: llvm.call @setNumWorkGroups(%[[Vulkan_Runtime_ptr]], %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, i64, i64, i64) -> !llvm.void
// CHECK: llvm.call @runOnVulkan(%[[Vulkan_Runtime_ptr]]) : (!llvm.ptr<i8>) -> !llvm.void // CHECK: llvm.call @runOnVulkan(%[[Vulkan_Runtime_ptr]]) : (!llvm.ptr<i8>) -> !llvm.void
// CHECK: llvm.call @deinitVulkan(%[[Vulkan_Runtime_ptr]]) : (!llvm.ptr<i8>) -> !llvm.void // CHECK: llvm.call @deinitVulkan(%[[Vulkan_Runtime_ptr]]) : (!llvm.ptr<i8>) -> !llvm.void
// CHECK: llvm.func @bindMemRef1DHalf(!llvm.ptr<i8>, !llvm.i32, !llvm.i32, !llvm.ptr<struct<(ptr<i16>, ptr<i16>, i64, array<1 x i64>, array<1 x i64>)>>) // CHECK: llvm.func @bindMemRef1DHalf(!llvm.ptr<i8>, i32, i32, !llvm.ptr<struct<(ptr<i16>, ptr<i16>, i64, array<1 x i64>, array<1 x i64>)>>)
module attributes {gpu.container_module} { module attributes {gpu.container_module} {
llvm.func @malloc(!llvm.i64) -> !llvm.ptr<i8> llvm.func @malloc(i64) -> !llvm.ptr<i8>
llvm.func @foo() { llvm.func @foo() {
%0 = llvm.mlir.constant(12 : index) : !llvm.i64 %0 = llvm.mlir.constant(12 : index) : i64
%1 = llvm.mlir.null : !llvm.ptr<float> %1 = llvm.mlir.null : !llvm.ptr<float>
%2 = llvm.mlir.constant(1 : index) : !llvm.i64 %2 = llvm.mlir.constant(1 : index) : i64
%3 = llvm.getelementptr %1[%2] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %3 = llvm.getelementptr %1[%2] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
%4 = llvm.ptrtoint %3 : !llvm.ptr<float> to !llvm.i64 %4 = llvm.ptrtoint %3 : !llvm.ptr<float> to i64
%5 = llvm.mul %0, %4 : !llvm.i64 %5 = llvm.mul %0, %4 : i64
%6 = llvm.call @malloc(%5) : (!llvm.i64) -> !llvm.ptr<i8> %6 = llvm.call @malloc(%5) : (i64) -> !llvm.ptr<i8>
%7 = llvm.bitcast %6 : !llvm.ptr<i8> to !llvm.ptr<float> %7 = llvm.bitcast %6 : !llvm.ptr<i8> to !llvm.ptr<float>
%8 = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %8 = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%9 = llvm.insertvalue %7, %8[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %9 = llvm.insertvalue %7, %8[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%10 = llvm.insertvalue %7, %9[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %10 = llvm.insertvalue %7, %9[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%11 = llvm.mlir.constant(0 : index) : !llvm.i64 %11 = llvm.mlir.constant(0 : index) : i64
%12 = llvm.insertvalue %11, %10[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %12 = llvm.insertvalue %11, %10[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%13 = llvm.mlir.constant(1 : index) : !llvm.i64 %13 = llvm.mlir.constant(1 : index) : i64
%14 = llvm.insertvalue %0, %12[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %14 = llvm.insertvalue %0, %12[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%15 = llvm.insertvalue %13, %14[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %15 = llvm.insertvalue %13, %14[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%16 = llvm.mlir.constant(1 : index) : !llvm.i64 %16 = llvm.mlir.constant(1 : index) : i64
%17 = llvm.extractvalue %15[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %17 = llvm.extractvalue %15[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%18 = llvm.extractvalue %15[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %18 = llvm.extractvalue %15[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%19 = llvm.extractvalue %15[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %19 = llvm.extractvalue %15[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%20 = llvm.extractvalue %15[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %20 = llvm.extractvalue %15[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%21 = llvm.extractvalue %15[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %21 = llvm.extractvalue %15[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
llvm.call @vulkanLaunch(%16, %16, %16, %17, %18, %19, %20, %21) {spirv_blob = "\03\02#\07\00", spirv_entry_point = "kernel"} llvm.call @vulkanLaunch(%16, %16, %16, %17, %18, %19, %20, %21) {spirv_blob = "\03\02#\07\00", spirv_entry_point = "kernel"}
: (!llvm.i64, !llvm.i64, !llvm.i64, !llvm.ptr<float>, !llvm.ptr<float>, !llvm.i64, !llvm.i64, !llvm.i64) -> () : (i64, i64, i64, !llvm.ptr<float>, !llvm.ptr<float>, i64, i64, i64) -> ()
llvm.return llvm.return
} }
llvm.func @vulkanLaunch(%arg0: !llvm.i64, %arg1: !llvm.i64, %arg2: !llvm.i64, %arg6: !llvm.ptr<float>, %arg7: !llvm.ptr<float>, %arg8: !llvm.i64, %arg9: !llvm.i64, %arg10: !llvm.i64) { llvm.func @vulkanLaunch(%arg0: i64, %arg1: i64, %arg2: i64, %arg6: !llvm.ptr<float>, %arg7: !llvm.ptr<float>, %arg8: i64, %arg9: i64, %arg10: i64) {
%0 = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %0 = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%1 = llvm.insertvalue %arg6, %0[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %1 = llvm.insertvalue %arg6, %0[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%2 = llvm.insertvalue %arg7, %1[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %2 = llvm.insertvalue %arg7, %1[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%3 = llvm.insertvalue %arg8, %2[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %3 = llvm.insertvalue %arg8, %2[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%4 = llvm.insertvalue %arg9, %3[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %4 = llvm.insertvalue %arg9, %3[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%5 = llvm.insertvalue %arg10, %4[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> %5 = llvm.insertvalue %arg10, %4[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%6 = llvm.mlir.constant(1 : index) : !llvm.i64 %6 = llvm.mlir.constant(1 : index) : i64
%7 = llvm.alloca %6 x !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> : (!llvm.i64) -> !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>> %7 = llvm.alloca %6 x !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> : (i64) -> !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>
llvm.store %5, %7 : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>> llvm.store %5, %7 : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>
llvm.call @_mlir_ciface_vulkanLaunch(%arg0, %arg1, %arg2, %7) : (!llvm.i64, !llvm.i64, !llvm.i64, !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>) -> () llvm.call @_mlir_ciface_vulkanLaunch(%arg0, %arg1, %arg2, %7) : (i64, i64, i64, !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>) -> ()
llvm.return llvm.return
} }
llvm.func @_mlir_ciface_vulkanLaunch(!llvm.i64, !llvm.i64, !llvm.i64, !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>) llvm.func @_mlir_ciface_vulkanLaunch(i64, i64, i64, !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>)
} }

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

// RUN: mlir-opt -convert-openmp-to-llvm %s -split-input-file | FileCheck %s // RUN: mlir-opt -convert-openmp-to-llvm %s -split-input-file | FileCheck %s
// CHECK-LABEL: llvm.func @branch_loop // CHECK-LABEL: llvm.func @branch_loop
func @branch_loop() { func @branch_loop() {
%start = constant 0 : index %start = constant 0 : index
%end = constant 0 : index %end = constant 0 : index
// CHECK: omp.parallel // CHECK: omp.parallel
omp.parallel { omp.parallel {
// CHECK-NEXT: llvm.br ^[[BB1:.*]](%{{[0-9]+}}, %{{[0-9]+}} : !llvm.i64, !llvm.i64 // CHECK-NEXT: llvm.br ^[[BB1:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64
br ^bb1(%start, %end : index, index) br ^bb1(%start, %end : index, index)
// CHECK-NEXT: ^[[BB1]](%[[ARG1:[0-9]+]]: !llvm.i64, %[[ARG2:[0-9]+]]: !llvm.i64):{{.*}} // CHECK-NEXT: ^[[BB1]](%[[ARG1:[0-9]+]]: i64, %[[ARG2:[0-9]+]]: i64):{{.*}}
^bb1(%0: index, %1: index): ^bb1(%0: index, %1: index):
// CHECK-NEXT: %[[CMP:[0-9]+]] = llvm.icmp "slt" %[[ARG1]], %[[ARG2]] : !llvm.i64 // CHECK-NEXT: %[[CMP:[0-9]+]] = llvm.icmp "slt" %[[ARG1]], %[[ARG2]] : i64
%2 = cmpi "slt", %0, %1 : index %2 = cmpi "slt", %0, %1 : index
// CHECK-NEXT: llvm.cond_br %[[CMP]], ^[[BB2:.*]](%{{[0-9]+}}, %{{[0-9]+}} : !llvm.i64, !llvm.i64), ^[[BB3:.*]] // CHECK-NEXT: llvm.cond_br %[[CMP]], ^[[BB2:.*]](%{{[0-9]+}}, %{{[0-9]+}} : i64, i64), ^[[BB3:.*]]
cond_br %2, ^bb2(%end, %end : index, index), ^bb3 cond_br %2, ^bb2(%end, %end : index, index), ^bb3
// CHECK-NEXT: ^[[BB2]](%[[ARG3:[0-9]+]]: !llvm.i64, %[[ARG4:[0-9]+]]: !llvm.i64): // CHECK-NEXT: ^[[BB2]](%[[ARG3:[0-9]+]]: i64, %[[ARG4:[0-9]+]]: i64):
^bb2(%3: index, %4: index): ^bb2(%3: index, %4: index):
// CHECK-NEXT: llvm.br ^[[BB1]](%[[ARG3]], %[[ARG4]] : !llvm.i64, !llvm.i64) // CHECK-NEXT: llvm.br ^[[BB1]](%[[ARG3]], %[[ARG4]] : i64, i64)
br ^bb1(%3, %4 : index, index) br ^bb1(%3, %4 : index, index)
// CHECK-NEXT: ^[[BB3]]: // CHECK-NEXT: ^[[BB3]]:
^bb3: ^bb3:
omp.flush omp.flush
omp.barrier omp.barrier
omp.taskwait omp.taskwait
omp.taskyield omp.taskyield
omp.terminator omp.terminator
} }
return return
} }
// CHECK-LABEL: @wsloop // CHECK-LABEL: @wsloop
// CHECK: (%[[ARG0:.*]]: !llvm.i64, %[[ARG1:.*]]: !llvm.i64, %[[ARG2:.*]]: !llvm.i64, %[[ARG3:.*]]: !llvm.i64, %[[ARG4:.*]]: !llvm.i64, %[[ARG5:.*]]: !llvm.i64) // CHECK: (%[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64, %[[ARG2:.*]]: i64, %[[ARG3:.*]]: i64, %[[ARG4:.*]]: i64, %[[ARG5:.*]]: i64)
func @wsloop(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index, %arg5: index) { func @wsloop(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index, %arg5: index) {
// CHECK: omp.parallel // CHECK: omp.parallel
omp.parallel { omp.parallel {
// CHECK: omp.wsloop // CHECK: omp.wsloop
// CHECK: (%[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]], %[[ARG4]], %[[ARG5]]) // CHECK: (%[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]], %[[ARG4]], %[[ARG5]])
"omp.wsloop"(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) ( { "omp.wsloop"(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) ( {
// CHECK: ^{{.*}}(%[[ARG6:.*]]: !llvm.i64, %[[ARG7:.*]]: !llvm.i64): // CHECK: ^{{.*}}(%[[ARG6:.*]]: i64, %[[ARG7:.*]]: i64):
^bb0(%arg6: index, %arg7: index): // no predecessors ^bb0(%arg6: index, %arg7: index): // no predecessors
// CHECK: "test.payload"(%[[ARG6]], %[[ARG7]]) : (!llvm.i64, !llvm.i64) -> () // CHECK: "test.payload"(%[[ARG6]], %[[ARG7]]) : (i64, i64) -> ()
"test.payload"(%arg6, %arg7) : (index, index) -> () "test.payload"(%arg6, %arg7) : (index, index) -> ()
omp.yield omp.yield
}) {operand_segment_sizes = dense<[2, 2, 2, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (index, index, index, index, index, index) -> () }) {operand_segment_sizes = dense<[2, 2, 2, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (index, index, index, index, index, index) -> ()
omp.terminator omp.terminator
} }
return return
} }

mlir/test/Conversion/SPIRVToLLVM/arithmetic-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IAdd // spv.IAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @iadd_scalar // CHECK-LABEL: @iadd_scalar
spv.func @iadd_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @iadd_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.add %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.add %{{.*}}, %{{.*}} : i32
%0 = spv.IAdd %arg0, %arg1 : i32 %0 = spv.IAdd %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @iadd_vector // CHECK-LABEL: @iadd_vector
spv.func @iadd_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" { spv.func @iadd_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" {
// CHECK: llvm.add %{{.*}}, %{{.*}} : !llvm.vec<4 x i64> // CHECK: llvm.add %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
%0 = spv.IAdd %arg0, %arg1 : vector<4xi64> %0 = spv.IAdd %arg0, %arg1 : vector<4xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ISub // spv.ISub
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @isub_scalar // CHECK-LABEL: @isub_scalar
spv.func @isub_scalar(%arg0: i8, %arg1: i8) "None" { spv.func @isub_scalar(%arg0: i8, %arg1: i8) "None" {
// CHECK: llvm.sub %{{.*}}, %{{.*}} : !llvm.i8 // CHECK: llvm.sub %{{.*}}, %{{.*}} : i8
%0 = spv.ISub %arg0, %arg1 : i8 %0 = spv.ISub %arg0, %arg1 : i8
spv.Return spv.Return
} }
// CHECK-LABEL: @isub_vector // CHECK-LABEL: @isub_vector
spv.func @isub_vector(%arg0: vector<2xi16>, %arg1: vector<2xi16>) "None" { spv.func @isub_vector(%arg0: vector<2xi16>, %arg1: vector<2xi16>) "None" {
// CHECK: llvm.sub %{{.*}}, %{{.*}} : !llvm.vec<2 x i16> // CHECK: llvm.sub %{{.*}}, %{{.*}} : !llvm.vec<2 x i16>
%0 = spv.ISub %arg0, %arg1 : vector<2xi16> %0 = spv.ISub %arg0, %arg1 : vector<2xi16>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IMul // spv.IMul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @imul_scalar // CHECK-LABEL: @imul_scalar
spv.func @imul_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @imul_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.mul %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.mul %{{.*}}, %{{.*}} : i32
%0 = spv.IMul %arg0, %arg1 : i32 %0 = spv.IMul %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @imul_vector // CHECK-LABEL: @imul_vector
spv.func @imul_vector(%arg0: vector<3xi32>, %arg1: vector<3xi32>) "None" { spv.func @imul_vector(%arg0: vector<3xi32>, %arg1: vector<3xi32>) "None" {
// CHECK: llvm.mul %{{.*}}, %{{.*}} : !llvm.vec<3 x i32> // CHECK: llvm.mul %{{.*}}, %{{.*}} : !llvm.vec<3 x i32>
%0 = spv.IMul %arg0, %arg1 : vector<3xi32> %0 = spv.IMul %arg0, %arg1 : vector<3xi32>
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UDiv // spv.UDiv
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @udiv_scalar // CHECK-LABEL: @udiv_scalar
spv.func @udiv_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @udiv_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.udiv %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.udiv %{{.*}}, %{{.*}} : i32
%0 = spv.UDiv %arg0, %arg1 : i32 %0 = spv.UDiv %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @udiv_vector // CHECK-LABEL: @udiv_vector
spv.func @udiv_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) "None" { spv.func @udiv_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) "None" {
// CHECK: llvm.udiv %{{.*}}, %{{.*}} : !llvm.vec<3 x i64> // CHECK: llvm.udiv %{{.*}}, %{{.*}} : !llvm.vec<3 x i64>
%0 = spv.UDiv %arg0, %arg1 : vector<3xi64> %0 = spv.UDiv %arg0, %arg1 : vector<3xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UMod // spv.UMod
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @umod_scalar // CHECK-LABEL: @umod_scalar
spv.func @umod_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @umod_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.urem %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.urem %{{.*}}, %{{.*}} : i32
%0 = spv.UMod %arg0, %arg1 : i32 %0 = spv.UMod %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @umod_vector // CHECK-LABEL: @umod_vector
spv.func @umod_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) "None" { spv.func @umod_vector(%arg0: vector<3xi64>, %arg1: vector<3xi64>) "None" {
// CHECK: llvm.urem %{{.*}}, %{{.*}} : !llvm.vec<3 x i64> // CHECK: llvm.urem %{{.*}}, %{{.*}} : !llvm.vec<3 x i64>
%0 = spv.UMod %arg0, %arg1 : vector<3xi64> %0 = spv.UMod %arg0, %arg1 : vector<3xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SDiv // spv.SDiv
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @sdiv_scalar // CHECK-LABEL: @sdiv_scalar
spv.func @sdiv_scalar(%arg0: i16, %arg1: i16) "None" { spv.func @sdiv_scalar(%arg0: i16, %arg1: i16) "None" {
// CHECK: llvm.sdiv %{{.*}}, %{{.*}} : !llvm.i16 // CHECK: llvm.sdiv %{{.*}}, %{{.*}} : i16
%0 = spv.SDiv %arg0, %arg1 : i16 %0 = spv.SDiv %arg0, %arg1 : i16
spv.Return spv.Return
} }
// CHECK-LABEL: @sdiv_vector // CHECK-LABEL: @sdiv_vector
spv.func @sdiv_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @sdiv_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.sdiv %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.sdiv %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.SDiv %arg0, %arg1 : vector<2xi64> %0 = spv.SDiv %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SRem // spv.SRem
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @srem_scalar // CHECK-LABEL: @srem_scalar
spv.func @srem_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @srem_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.srem %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.srem %{{.*}}, %{{.*}} : i32
%0 = spv.SRem %arg0, %arg1 : i32 %0 = spv.SRem %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @srem_vector // CHECK-LABEL: @srem_vector
spv.func @srem_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @srem_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: llvm.srem %{{.*}}, %{{.*}} : !llvm.vec<4 x i32> // CHECK: llvm.srem %{{.*}}, %{{.*}} : !llvm.vec<4 x i32>
%0 = spv.SRem %arg0, %arg1 : vector<4xi32> %0 = spv.SRem %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }

mlir/test/Conversion/SPIRVToLLVM/bitwise-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitCount // spv.BitCount
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitcount_scalar // CHECK-LABEL: @bitcount_scalar
spv.func @bitcount_scalar(%arg0: i16) "None" { spv.func @bitcount_scalar(%arg0: i16) "None" {
// CHECK: "llvm.intr.ctpop"(%{{.*}}) : (!llvm.i16) -> !llvm.i16 // CHECK: "llvm.intr.ctpop"(%{{.*}}) : (i16) -> i16
%0 = spv.BitCount %arg0: i16 %0 = spv.BitCount %arg0: i16
spv.Return spv.Return
} }
// CHECK-LABEL: @bitcount_vector // CHECK-LABEL: @bitcount_vector
spv.func @bitcount_vector(%arg0: vector<3xi32>) "None" { spv.func @bitcount_vector(%arg0: vector<3xi32>) "None" {
// CHECK: "llvm.intr.ctpop"(%{{.*}}) : (!llvm.vec<3 x i32>) -> !llvm.vec<3 x i32> // CHECK: "llvm.intr.ctpop"(%{{.*}}) : (!llvm.vec<3 x i32>) -> !llvm.vec<3 x i32>
%0 = spv.BitCount %arg0: vector<3xi32> %0 = spv.BitCount %arg0: vector<3xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitReverse // spv.BitReverse
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitreverse_scalar // CHECK-LABEL: @bitreverse_scalar
spv.func @bitreverse_scalar(%arg0: i64) "None" { spv.func @bitreverse_scalar(%arg0: i64) "None" {
// CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (!llvm.i64) -> !llvm.i64 // CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (i64) -> i64
%0 = spv.BitReverse %arg0: i64 %0 = spv.BitReverse %arg0: i64
spv.Return spv.Return
} }
// CHECK-LABEL: @bitreverse_vector // CHECK-LABEL: @bitreverse_vector
spv.func @bitreverse_vector(%arg0: vector<4xi32>) "None" { spv.func @bitreverse_vector(%arg0: vector<4xi32>) "None" {
// CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (!llvm.vec<4 x i32>) -> !llvm.vec<4 x i32> // CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (!llvm.vec<4 x i32>) -> !llvm.vec<4 x i32>
%0 = spv.BitReverse %arg0: vector<4xi32> %0 = spv.BitReverse %arg0: vector<4xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitFieldInsert // spv.BitFieldInsert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitfield_insert_scalar_same_bit_width // CHECK-LABEL: @bitfield_insert_scalar_same_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i32, %[[INSERT:.*]]: !llvm.i32, %[[OFFSET:.*]]: !llvm.i32, %[[COUNT:.*]]: !llvm.i32 // CHECK-SAME: %[[BASE:.*]]: i32, %[[INSERT:.*]]: i32, %[[OFFSET:.*]]: i32, %[[COUNT:.*]]: i32
spv.func @bitfield_insert_scalar_same_bit_width(%base: i32, %insert: i32, %offset: i32, %count: i32) "None" { spv.func @bitfield_insert_scalar_same_bit_width(%base: i32, %insert: i32, %offset: i32, %count: i32) "None" {
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i32) : !llvm.i32 // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i32) : i32
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT]] : !llvm.i32 // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT]] : i32
// CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.i32 // CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : i32
// CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[OFFSET]] : !llvm.i32 // CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[OFFSET]] : i32
// CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : !llvm.i32 // CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : i32
// CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : !llvm.i32 // CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : i32
// CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[OFFSET]] : !llvm.i32 // CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[OFFSET]] : i32
// CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : !llvm.i32 // CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : i32
%0 = spv.BitFieldInsert %base, %insert, %offset, %count : i32, i32, i32 %0 = spv.BitFieldInsert %base, %insert, %offset, %count : i32, i32, i32
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_insert_scalar_smaller_bit_width // CHECK-LABEL: @bitfield_insert_scalar_smaller_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i64, %[[INSERT:.*]]: !llvm.i64, %[[OFFSET:.*]]: !llvm.i8, %[[COUNT:.*]]: !llvm.i8 // CHECK-SAME: %[[BASE:.*]]: i64, %[[INSERT:.*]]: i64, %[[OFFSET:.*]]: i8, %[[COUNT:.*]]: i8
spv.func @bitfield_insert_scalar_smaller_bit_width(%base: i64, %insert: i64, %offset: i8, %count: i8) "None" { spv.func @bitfield_insert_scalar_smaller_bit_width(%base: i64, %insert: i64, %offset: i8, %count: i8) "None" {
// CHECK: %[[EXT_OFFSET:.*]] = llvm.zext %[[OFFSET]] : !llvm.i8 to !llvm.i64 // CHECK: %[[EXT_OFFSET:.*]] = llvm.zext %[[OFFSET]] : i8 to i64
// CHECK: %[[EXT_COUNT:.*]] = llvm.zext %[[COUNT]] : !llvm.i8 to !llvm.i64 // CHECK: %[[EXT_COUNT:.*]] = llvm.zext %[[COUNT]] : i8 to i64
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i64) : !llvm.i64 // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i64) : i64
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[EXT_COUNT]] : !llvm.i64 // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[EXT_COUNT]] : i64
// CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.i64 // CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : i64
// CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[EXT_OFFSET]] : !llvm.i64 // CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[EXT_OFFSET]] : i64
// CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : !llvm.i64 // CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : i64
// CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : !llvm.i64 // CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : i64
// CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[EXT_OFFSET]] : !llvm.i64 // CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[EXT_OFFSET]] : i64
// CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : !llvm.i64 // CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : i64
%0 = spv.BitFieldInsert %base, %insert, %offset, %count : i64, i8, i8 %0 = spv.BitFieldInsert %base, %insert, %offset, %count : i64, i8, i8
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_insert_scalar_greater_bit_width // CHECK-LABEL: @bitfield_insert_scalar_greater_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i16, %[[INSERT:.*]]: !llvm.i16, %[[OFFSET:.*]]: !llvm.i32, %[[COUNT:.*]]: !llvm.i64 // CHECK-SAME: %[[BASE:.*]]: i16, %[[INSERT:.*]]: i16, %[[OFFSET:.*]]: i32, %[[COUNT:.*]]: i64
spv.func @bitfield_insert_scalar_greater_bit_width(%base: i16, %insert: i16, %offset: i32, %count: i64) "None" { spv.func @bitfield_insert_scalar_greater_bit_width(%base: i16, %insert: i16, %offset: i32, %count: i64) "None" {
// CHECK: %[[TRUNC_OFFSET:.*]] = llvm.trunc %[[OFFSET]] : !llvm.i32 to !llvm.i16 // CHECK: %[[TRUNC_OFFSET:.*]] = llvm.trunc %[[OFFSET]] : i32 to i16
// CHECK: %[[TRUNC_COUNT:.*]] = llvm.trunc %[[COUNT]] : !llvm.i64 to !llvm.i16 // CHECK: %[[TRUNC_COUNT:.*]] = llvm.trunc %[[COUNT]] : i64 to i16
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i16) : !llvm.i16 // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i16) : i16
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[TRUNC_COUNT]] : !llvm.i16 // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[TRUNC_COUNT]] : i16
// CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.i16 // CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : i16
// CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[TRUNC_OFFSET]] : !llvm.i16 // CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[TRUNC_OFFSET]] : i16
// CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : !llvm.i16 // CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : i16
// CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : !llvm.i16 // CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : i16
// CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[TRUNC_OFFSET]] : !llvm.i16 // CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[TRUNC_OFFSET]] : i16
// CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : !llvm.i16 // CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : i16
%0 = spv.BitFieldInsert %base, %insert, %offset, %count : i16, i32, i64 %0 = spv.BitFieldInsert %base, %insert, %offset, %count : i16, i32, i64
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_insert_vector // CHECK-LABEL: @bitfield_insert_vector
// CHECK-SAME: %[[BASE:.*]]: !llvm.vec<2 x i32>, %[[INSERT:.*]]: !llvm.vec<2 x i32>, %[[OFFSET:.*]]: !llvm.i32, %[[COUNT:.*]]: !llvm.i32 // CHECK-SAME: %[[BASE:.*]]: !llvm.vec<2 x i32>, %[[INSERT:.*]]: !llvm.vec<2 x i32>, %[[OFFSET:.*]]: i32, %[[COUNT:.*]]: i32
spv.func @bitfield_insert_vector(%base: vector<2xi32>, %insert: vector<2xi32>, %offset: i32, %count: i32) "None" { spv.func @bitfield_insert_vector(%base: vector<2xi32>, %insert: vector<2xi32>, %offset: i32, %count: i32) "None" {
// CHECK: %[[OFFSET_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[OFFSET_V1:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V0]][%[[ZERO]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V1:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V0]][%[[ZERO]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[OFFSET_V2:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V1]][%[[ONE]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V2:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V1]][%[[ONE]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[COUNT_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[COUNT_V1:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V0]][%[[ZERO]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V1:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V0]][%[[ZERO]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[COUNT_V2:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V1]][%[[ONE]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V2:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V1]][%[[ONE]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(dense<-1> : vector<2xi32>) : !llvm.vec<2 x i32> // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(dense<-1> : vector<2xi32>) : !llvm.vec<2 x i32>
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT_V2]] : !llvm.vec<2 x i32> // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT_V2]] : !llvm.vec<2 x i32>
// CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.vec<2 x i32> // CHECK: %[[T1:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.vec<2 x i32>
// CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[OFFSET_V2]] : !llvm.vec<2 x i32> // CHECK: %[[T2:.*]] = llvm.shl %[[T1]], %[[OFFSET_V2]] : !llvm.vec<2 x i32>
// CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : !llvm.vec<2 x i32> // CHECK: %[[MASK:.*]] = llvm.xor %[[T2]], %[[MINUS_ONE]] : !llvm.vec<2 x i32>
// CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : !llvm.vec<2 x i32> // CHECK: %[[NEW_BASE:.*]] = llvm.and %[[BASE]], %[[MASK]] : !llvm.vec<2 x i32>
// CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[OFFSET_V2]] : !llvm.vec<2 x i32> // CHECK: %[[SHIFTED_INSERT:.*]] = llvm.shl %[[INSERT]], %[[OFFSET_V2]] : !llvm.vec<2 x i32>
// CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : !llvm.vec<2 x i32> // CHECK: llvm.or %[[NEW_BASE]], %[[SHIFTED_INSERT]] : !llvm.vec<2 x i32>
%0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<2xi32>, i32, i32 %0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<2xi32>, i32, i32
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitFieldSExtract // spv.BitFieldSExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitfield_sextract_scalar_same_bit_width // CHECK-LABEL: @bitfield_sextract_scalar_same_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i64, %[[OFFSET:.*]]: !llvm.i64, %[[COUNT:.*]]: !llvm.i64 // CHECK-SAME: %[[BASE:.*]]: i64, %[[OFFSET:.*]]: i64, %[[COUNT:.*]]: i64
spv.func @bitfield_sextract_scalar_same_bit_width(%base: i64, %offset: i64, %count: i64) "None" { spv.func @bitfield_sextract_scalar_same_bit_width(%base: i64, %offset: i64, %count: i64) "None" {
// CHECK: %[[SIZE:.]] = llvm.mlir.constant(64 : i64) : !llvm.i64 // CHECK: %[[SIZE:.]] = llvm.mlir.constant(64 : i64) : i64
// CHECK: %[[T0:.*]] = llvm.add %[[COUNT]], %[[OFFSET]] : !llvm.i64 // CHECK: %[[T0:.*]] = llvm.add %[[COUNT]], %[[OFFSET]] : i64
// CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : !llvm.i64 // CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : i64
// CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : !llvm.i64 // CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : i64
// CHECK: %[[T2:.*]] = llvm.add %[[OFFSET]], %[[T1]] : !llvm.i64 // CHECK: %[[T2:.*]] = llvm.add %[[OFFSET]], %[[T1]] : i64
// CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : !llvm.i64 // CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : i64
%0 = spv.BitFieldSExtract %base, %offset, %count : i64, i64, i64 %0 = spv.BitFieldSExtract %base, %offset, %count : i64, i64, i64
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_sextract_scalar_smaller_bit_width // CHECK-LABEL: @bitfield_sextract_scalar_smaller_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i32, %[[OFFSET:.*]]: !llvm.i8, %[[COUNT:.*]]: !llvm.i8 // CHECK-SAME: %[[BASE:.*]]: i32, %[[OFFSET:.*]]: i8, %[[COUNT:.*]]: i8
spv.func @bitfield_sextract_scalar_smaller_bit_width(%base: i32, %offset: i8, %count: i8) "None" { spv.func @bitfield_sextract_scalar_smaller_bit_width(%base: i32, %offset: i8, %count: i8) "None" {
// CHECK: %[[EXT_OFFSET:.*]] = llvm.zext %[[OFFSET]] : !llvm.i8 to !llvm.i32 // CHECK: %[[EXT_OFFSET:.*]] = llvm.zext %[[OFFSET]] : i8 to i32
// CHECK: %[[EXT_COUNT:.*]] = llvm.zext %[[COUNT]] : !llvm.i8 to !llvm.i32 // CHECK: %[[EXT_COUNT:.*]] = llvm.zext %[[COUNT]] : i8 to i32
// CHECK: %[[SIZE:.]] = llvm.mlir.constant(32 : i32) : !llvm.i32 // CHECK: %[[SIZE:.]] = llvm.mlir.constant(32 : i32) : i32
// CHECK: %[[T0:.*]] = llvm.add %[[EXT_COUNT]], %[[EXT_OFFSET]] : !llvm.i32 // CHECK: %[[T0:.*]] = llvm.add %[[EXT_COUNT]], %[[EXT_OFFSET]] : i32
// CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : !llvm.i32 // CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : i32
// CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : !llvm.i32 // CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : i32
// CHECK: %[[T2:.*]] = llvm.add %[[EXT_OFFSET]], %[[T1]] : !llvm.i32 // CHECK: %[[T2:.*]] = llvm.add %[[EXT_OFFSET]], %[[T1]] : i32
// CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : !llvm.i32 // CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : i32
%0 = spv.BitFieldSExtract %base, %offset, %count : i32, i8, i8 %0 = spv.BitFieldSExtract %base, %offset, %count : i32, i8, i8
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_sextract_scalar_greater_bit_width // CHECK-LABEL: @bitfield_sextract_scalar_greater_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i32, %[[OFFSET:.*]]: !llvm.i64, %[[COUNT:.*]]: !llvm.i64 // CHECK-SAME: %[[BASE:.*]]: i32, %[[OFFSET:.*]]: i64, %[[COUNT:.*]]: i64
spv.func @bitfield_sextract_scalar_greater_bit_width(%base: i32, %offset: i64, %count: i64) "None" { spv.func @bitfield_sextract_scalar_greater_bit_width(%base: i32, %offset: i64, %count: i64) "None" {
// CHECK: %[[TRUNC_OFFSET:.*]] = llvm.trunc %[[OFFSET]] : !llvm.i64 to !llvm.i32 // CHECK: %[[TRUNC_OFFSET:.*]] = llvm.trunc %[[OFFSET]] : i64 to i32
// CHECK: %[[TRUNC_COUNT:.*]] = llvm.trunc %[[COUNT]] : !llvm.i64 to !llvm.i32 // CHECK: %[[TRUNC_COUNT:.*]] = llvm.trunc %[[COUNT]] : i64 to i32
// CHECK: %[[SIZE:.]] = llvm.mlir.constant(32 : i32) : !llvm.i32 // CHECK: %[[SIZE:.]] = llvm.mlir.constant(32 : i32) : i32
// CHECK: %[[T0:.*]] = llvm.add %[[TRUNC_COUNT]], %[[TRUNC_OFFSET]] : !llvm.i32 // CHECK: %[[T0:.*]] = llvm.add %[[TRUNC_COUNT]], %[[TRUNC_OFFSET]] : i32
// CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : !llvm.i32 // CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : i32
// CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : !llvm.i32 // CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : i32
// CHECK: %[[T2:.*]] = llvm.add %[[TRUNC_OFFSET]], %[[T1]] : !llvm.i32 // CHECK: %[[T2:.*]] = llvm.add %[[TRUNC_OFFSET]], %[[T1]] : i32
// CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : !llvm.i32 // CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : i32
%0 = spv.BitFieldSExtract %base, %offset, %count : i32, i64, i64 %0 = spv.BitFieldSExtract %base, %offset, %count : i32, i64, i64
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_sextract_vector // CHECK-LABEL: @bitfield_sextract_vector
// CHECK-SAME: %[[BASE:.*]]: !llvm.vec<2 x i32>, %[[OFFSET:.*]]: !llvm.i32, %[[COUNT:.*]]: !llvm.i32 // CHECK-SAME: %[[BASE:.*]]: !llvm.vec<2 x i32>, %[[OFFSET:.*]]: i32, %[[COUNT:.*]]: i32
spv.func @bitfield_sextract_vector(%base: vector<2xi32>, %offset: i32, %count: i32) "None" { spv.func @bitfield_sextract_vector(%base: vector<2xi32>, %offset: i32, %count: i32) "None" {
// CHECK: %[[OFFSET_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[OFFSET_V1:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V0]][%[[ZERO]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V1:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V0]][%[[ZERO]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[OFFSET_V2:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V1]][%[[ONE]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V2:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V1]][%[[ONE]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[COUNT_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[COUNT_V1:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V0]][%[[ZERO]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V1:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V0]][%[[ZERO]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[COUNT_V2:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V1]][%[[ONE]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V2:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V1]][%[[ONE]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(dense<32> : vector<2xi32>) : !llvm.vec<2 x i32> // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(dense<32> : vector<2xi32>) : !llvm.vec<2 x i32>
// CHECK: %[[T0:.*]] = llvm.add %[[COUNT_V2]], %[[OFFSET_V2]] : !llvm.vec<2 x i32> // CHECK: %[[T0:.*]] = llvm.add %[[COUNT_V2]], %[[OFFSET_V2]] : !llvm.vec<2 x i32>
// CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : !llvm.vec<2 x i32> // CHECK: %[[T1:.*]] = llvm.sub %[[SIZE]], %[[T0]] : !llvm.vec<2 x i32>
// CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : !llvm.vec<2 x i32> // CHECK: %[[SHIFTED_LEFT:.*]] = llvm.shl %[[BASE]], %[[T1]] : !llvm.vec<2 x i32>
// CHECK: %[[T2:.*]] = llvm.add %[[OFFSET_V2]], %[[T1]] : !llvm.vec<2 x i32> // CHECK: %[[T2:.*]] = llvm.add %[[OFFSET_V2]], %[[T1]] : !llvm.vec<2 x i32>
// CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : !llvm.vec<2 x i32> // CHECK: llvm.ashr %[[SHIFTED_LEFT]], %[[T2]] : !llvm.vec<2 x i32>
%0 = spv.BitFieldSExtract %base, %offset, %count : vector<2xi32>, i32, i32 %0 = spv.BitFieldSExtract %base, %offset, %count : vector<2xi32>, i32, i32
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitFieldUExtract // spv.BitFieldUExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitfield_uextract_scalar_same_bit_width // CHECK-LABEL: @bitfield_uextract_scalar_same_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i32, %[[OFFSET:.*]]: !llvm.i32, %[[COUNT:.*]]: !llvm.i32 // CHECK-SAME: %[[BASE:.*]]: i32, %[[OFFSET:.*]]: i32, %[[COUNT:.*]]: i32
spv.func @bitfield_uextract_scalar_same_bit_width(%base: i32, %offset: i32, %count: i32) "None" { spv.func @bitfield_uextract_scalar_same_bit_width(%base: i32, %offset: i32, %count: i32) "None" {
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i32) : !llvm.i32 // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i32) : i32
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT]] : !llvm.i32 // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT]] : i32
// CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.i32 // CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : i32
// CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[OFFSET]] : !llvm.i32 // CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[OFFSET]] : i32
// CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : !llvm.i32 // CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : i32
%0 = spv.BitFieldUExtract %base, %offset, %count : i32, i32, i32 %0 = spv.BitFieldUExtract %base, %offset, %count : i32, i32, i32
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_uextract_scalar_smaller_bit_width // CHECK-LABEL: @bitfield_uextract_scalar_smaller_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i32, %[[OFFSET:.*]]: !llvm.i16, %[[COUNT:.*]]: !llvm.i8 // CHECK-SAME: %[[BASE:.*]]: i32, %[[OFFSET:.*]]: i16, %[[COUNT:.*]]: i8
spv.func @bitfield_uextract_scalar_smaller_bit_width(%base: i32, %offset: i16, %count: i8) "None" { spv.func @bitfield_uextract_scalar_smaller_bit_width(%base: i32, %offset: i16, %count: i8) "None" {
// CHECK: %[[EXT_OFFSET:.*]] = llvm.zext %[[OFFSET]] : !llvm.i16 to !llvm.i32 // CHECK: %[[EXT_OFFSET:.*]] = llvm.zext %[[OFFSET]] : i16 to i32
// CHECK: %[[EXT_COUNT:.*]] = llvm.zext %[[COUNT]] : !llvm.i8 to !llvm.i32 // CHECK: %[[EXT_COUNT:.*]] = llvm.zext %[[COUNT]] : i8 to i32
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i32) : !llvm.i32 // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i32) : i32
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[EXT_COUNT]] : !llvm.i32 // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[EXT_COUNT]] : i32
// CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.i32 // CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : i32
// CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[EXT_OFFSET]] : !llvm.i32 // CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[EXT_OFFSET]] : i32
// CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : !llvm.i32 // CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : i32
%0 = spv.BitFieldUExtract %base, %offset, %count : i32, i16, i8 %0 = spv.BitFieldUExtract %base, %offset, %count : i32, i16, i8
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_uextract_scalar_greater_bit_width // CHECK-LABEL: @bitfield_uextract_scalar_greater_bit_width
// CHECK-SAME: %[[BASE:.*]]: !llvm.i8, %[[OFFSET:.*]]: !llvm.i16, %[[COUNT:.*]]: !llvm.i8 // CHECK-SAME: %[[BASE:.*]]: i8, %[[OFFSET:.*]]: i16, %[[COUNT:.*]]: i8
spv.func @bitfield_uextract_scalar_greater_bit_width(%base: i8, %offset: i16, %count: i8) "None" { spv.func @bitfield_uextract_scalar_greater_bit_width(%base: i8, %offset: i16, %count: i8) "None" {
// CHECK: %[[TRUNC_OFFSET:.*]] = llvm.trunc %[[OFFSET]] : !llvm.i16 to !llvm.i8 // CHECK: %[[TRUNC_OFFSET:.*]] = llvm.trunc %[[OFFSET]] : i16 to i8
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i8) : !llvm.i8 // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(-1 : i8) : i8
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT]] : !llvm.i8 // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT]] : i8
// CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.i8 // CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : i8
// CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[TRUNC_OFFSET]] : !llvm.i8 // CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[TRUNC_OFFSET]] : i8
// CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : !llvm.i8 // CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : i8
%0 = spv.BitFieldUExtract %base, %offset, %count : i8, i16, i8 %0 = spv.BitFieldUExtract %base, %offset, %count : i8, i16, i8
spv.Return spv.Return
} }
// CHECK-LABEL: @bitfield_uextract_vector // CHECK-LABEL: @bitfield_uextract_vector
// CHECK-SAME: %[[BASE:.*]]: !llvm.vec<2 x i32>, %[[OFFSET:.*]]: !llvm.i32, %[[COUNT:.*]]: !llvm.i32 // CHECK-SAME: %[[BASE:.*]]: !llvm.vec<2 x i32>, %[[OFFSET:.*]]: i32, %[[COUNT:.*]]: i32
spv.func @bitfield_uextract_vector(%base: vector<2xi32>, %offset: i32, %count: i32) "None" { spv.func @bitfield_uextract_vector(%base: vector<2xi32>, %offset: i32, %count: i32) "None" {
// CHECK: %[[OFFSET_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[OFFSET_V1:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V0]][%[[ZERO]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V1:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V0]][%[[ZERO]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[OFFSET_V2:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V1]][%[[ONE]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[OFFSET_V2:.*]] = llvm.insertelement %[[OFFSET]], %[[OFFSET_V1]][%[[ONE]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[COUNT_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V0:.*]] = llvm.mlir.undef : !llvm.vec<2 x i32>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[COUNT_V1:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V0]][%[[ZERO]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V1:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V0]][%[[ZERO]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[COUNT_V2:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V1]][%[[ONE]] : !llvm.i32] : !llvm.vec<2 x i32> // CHECK: %[[COUNT_V2:.*]] = llvm.insertelement %[[COUNT]], %[[COUNT_V1]][%[[ONE]] : i32] : !llvm.vec<2 x i32>
// CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(dense<-1> : vector<2xi32>) : !llvm.vec<2 x i32> // CHECK: %[[MINUS_ONE:.*]] = llvm.mlir.constant(dense<-1> : vector<2xi32>) : !llvm.vec<2 x i32>
// CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT_V2]] : !llvm.vec<2 x i32> // CHECK: %[[T0:.*]] = llvm.shl %[[MINUS_ONE]], %[[COUNT_V2]] : !llvm.vec<2 x i32>
// CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.vec<2 x i32> // CHECK: %[[MASK:.*]] = llvm.xor %[[T0]], %[[MINUS_ONE]] : !llvm.vec<2 x i32>
// CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[OFFSET_V2]] : !llvm.vec<2 x i32> // CHECK: %[[SHIFTED_BASE:.*]] = llvm.lshr %[[BASE]], %[[OFFSET_V2]] : !llvm.vec<2 x i32>
// CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : !llvm.vec<2 x i32> // CHECK: llvm.and %[[SHIFTED_BASE]], %[[MASK]] : !llvm.vec<2 x i32>
%0 = spv.BitFieldUExtract %base, %offset, %count : vector<2xi32>, i32, i32 %0 = spv.BitFieldUExtract %base, %offset, %count : vector<2xi32>, i32, i32
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitwiseAnd // spv.BitwiseAnd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitwise_and_scalar // CHECK-LABEL: @bitwise_and_scalar
spv.func @bitwise_and_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @bitwise_and_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.and %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.and %{{.*}}, %{{.*}} : i32
%0 = spv.BitwiseAnd %arg0, %arg1 : i32 %0 = spv.BitwiseAnd %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @bitwise_and_vector // CHECK-LABEL: @bitwise_and_vector
spv.func @bitwise_and_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" { spv.func @bitwise_and_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" {
// CHECK: llvm.and %{{.*}}, %{{.*}} : !llvm.vec<4 x i64> // CHECK: llvm.and %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
%0 = spv.BitwiseAnd %arg0, %arg1 : vector<4xi64> %0 = spv.BitwiseAnd %arg0, %arg1 : vector<4xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitwiseOr // spv.BitwiseOr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitwise_or_scalar // CHECK-LABEL: @bitwise_or_scalar
spv.func @bitwise_or_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @bitwise_or_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.or %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.or %{{.*}}, %{{.*}} : i64
%0 = spv.BitwiseOr %arg0, %arg1 : i64 %0 = spv.BitwiseOr %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @bitwise_or_vector // CHECK-LABEL: @bitwise_or_vector
spv.func @bitwise_or_vector(%arg0: vector<3xi8>, %arg1: vector<3xi8>) "None" { spv.func @bitwise_or_vector(%arg0: vector<3xi8>, %arg1: vector<3xi8>) "None" {
// CHECK: llvm.or %{{.*}}, %{{.*}} : !llvm.vec<3 x i8> // CHECK: llvm.or %{{.*}}, %{{.*}} : !llvm.vec<3 x i8>
%0 = spv.BitwiseOr %arg0, %arg1 : vector<3xi8> %0 = spv.BitwiseOr %arg0, %arg1 : vector<3xi8>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitwiseXor // spv.BitwiseXor
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitwise_xor_scalar // CHECK-LABEL: @bitwise_xor_scalar
spv.func @bitwise_xor_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @bitwise_xor_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.xor %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.xor %{{.*}}, %{{.*}} : i32
%0 = spv.BitwiseXor %arg0, %arg1 : i32 %0 = spv.BitwiseXor %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @bitwise_xor_vector // CHECK-LABEL: @bitwise_xor_vector
spv.func @bitwise_xor_vector(%arg0: vector<2xi16>, %arg1: vector<2xi16>) "None" { spv.func @bitwise_xor_vector(%arg0: vector<2xi16>, %arg1: vector<2xi16>) "None" {
// CHECK: llvm.xor %{{.*}}, %{{.*}} : !llvm.vec<2 x i16> // CHECK: llvm.xor %{{.*}}, %{{.*}} : !llvm.vec<2 x i16>
%0 = spv.BitwiseXor %arg0, %arg1 : vector<2xi16> %0 = spv.BitwiseXor %arg0, %arg1 : vector<2xi16>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Not // spv.Not
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @not_scalar // CHECK-LABEL: @not_scalar
spv.func @not_scalar(%arg0: i32) "None" { spv.func @not_scalar(%arg0: i32) "None" {
// CHECK: %[[CONST:.*]] = llvm.mlir.constant(-1 : i32) : !llvm.i32 // CHECK: %[[CONST:.*]] = llvm.mlir.constant(-1 : i32) : i32
// CHECK: llvm.xor %{{.*}}, %[[CONST]] : !llvm.i32 // CHECK: llvm.xor %{{.*}}, %[[CONST]] : i32
%0 = spv.Not %arg0 : i32 %0 = spv.Not %arg0 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @not_vector // CHECK-LABEL: @not_vector
spv.func @not_vector(%arg0: vector<2xi16>) "None" { spv.func @not_vector(%arg0: vector<2xi16>) "None" {
// CHECK: %[[CONST:.*]] = llvm.mlir.constant(dense<-1> : vector<2xi16>) : !llvm.vec<2 x i16> // CHECK: %[[CONST:.*]] = llvm.mlir.constant(dense<-1> : vector<2xi16>) : !llvm.vec<2 x i16>
// CHECK: llvm.xor %{{.*}}, %[[CONST]] : !llvm.vec<2 x i16> // CHECK: llvm.xor %{{.*}}, %[[CONST]] : !llvm.vec<2 x i16>
%0 = spv.Not %arg0 : vector<2xi16> %0 = spv.Not %arg0 : vector<2xi16>
spv.Return spv.Return
} }

mlir/test/Conversion/SPIRVToLLVM/cast-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Bitcast // spv.Bitcast
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bitcast_float_to_integer_scalar // CHECK-LABEL: @bitcast_float_to_integer_scalar
spv.func @bitcast_float_to_integer_scalar(%arg0 : f32) "None" { spv.func @bitcast_float_to_integer_scalar(%arg0 : f32) "None" {
// CHECK: llvm.bitcast {{.*}} : !llvm.float to !llvm.i32 // CHECK: llvm.bitcast {{.*}} : !llvm.float to i32
%0 = spv.Bitcast %arg0: f32 to i32 %0 = spv.Bitcast %arg0: f32 to i32
spv.Return spv.Return
} }
// CHECK-LABEL: @bitcast_float_to_integer_vector // CHECK-LABEL: @bitcast_float_to_integer_vector
spv.func @bitcast_float_to_integer_vector(%arg0 : vector<3xf32>) "None" { spv.func @bitcast_float_to_integer_vector(%arg0 : vector<3xf32>) "None" {
// CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm.vec<3 x float> to !llvm.vec<3 x i32> // CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm.vec<3 x float> to !llvm.vec<3 x i32>
%0 = spv.Bitcast %arg0: vector<3xf32> to vector<3xi32> %0 = spv.Bitcast %arg0: vector<3xf32> to vector<3xi32>
spv.Return spv.Return
} }
// CHECK-LABEL: @bitcast_vector_to_scalar // CHECK-LABEL: @bitcast_vector_to_scalar
spv.func @bitcast_vector_to_scalar(%arg0 : vector<2xf32>) "None" { spv.func @bitcast_vector_to_scalar(%arg0 : vector<2xf32>) "None" {
// CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm.vec<2 x float> to !llvm.i64 // CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm.vec<2 x float> to i64
%0 = spv.Bitcast %arg0: vector<2xf32> to i64 %0 = spv.Bitcast %arg0: vector<2xf32> to i64
spv.Return spv.Return
} }
// CHECK-LABEL: @bitcast_scalar_to_vector // CHECK-LABEL: @bitcast_scalar_to_vector
spv.func @bitcast_scalar_to_vector(%arg0 : f64) "None" { spv.func @bitcast_scalar_to_vector(%arg0 : f64) "None" {
// CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm.double to !llvm.vec<2 x i32> // CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm.double to !llvm.vec<2 x i32>
%0 = spv.Bitcast %arg0: f64 to vector<2xi32> %0 = spv.Bitcast %arg0: f64 to vector<2xi32>
Show All 15 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertFToS // spv.ConvertFToS
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @convert_float_to_signed_scalar // CHECK-LABEL: @convert_float_to_signed_scalar
spv.func @convert_float_to_signed_scalar(%arg0: f32) "None" { spv.func @convert_float_to_signed_scalar(%arg0: f32) "None" {
// CHECK: llvm.fptosi %{{.*}} : !llvm.float to !llvm.i32 // CHECK: llvm.fptosi %{{.*}} : !llvm.float to i32
%0 = spv.ConvertFToS %arg0: f32 to i32 %0 = spv.ConvertFToS %arg0: f32 to i32
spv.Return spv.Return
} }
// CHECK-LABEL: @convert_float_to_signed_vector // CHECK-LABEL: @convert_float_to_signed_vector
spv.func @convert_float_to_signed_vector(%arg0: vector<2xf32>) "None" { spv.func @convert_float_to_signed_vector(%arg0: vector<2xf32>) "None" {
// CHECK: llvm.fptosi %{{.*}} : !llvm.vec<2 x float> to !llvm.vec<2 x i32> // CHECK: llvm.fptosi %{{.*}} : !llvm.vec<2 x float> to !llvm.vec<2 x i32>
%0 = spv.ConvertFToS %arg0: vector<2xf32> to vector<2xi32> %0 = spv.ConvertFToS %arg0: vector<2xf32> to vector<2xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertFToU // spv.ConvertFToU
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @convert_float_to_unsigned_scalar // CHECK-LABEL: @convert_float_to_unsigned_scalar
spv.func @convert_float_to_unsigned_scalar(%arg0: f32) "None" { spv.func @convert_float_to_unsigned_scalar(%arg0: f32) "None" {
// CHECK: llvm.fptoui %{{.*}} : !llvm.float to !llvm.i32 // CHECK: llvm.fptoui %{{.*}} : !llvm.float to i32
%0 = spv.ConvertFToU %arg0: f32 to i32 %0 = spv.ConvertFToU %arg0: f32 to i32
spv.Return spv.Return
} }
// CHECK-LABEL: @convert_float_to_unsigned_vector // CHECK-LABEL: @convert_float_to_unsigned_vector
spv.func @convert_float_to_unsigned_vector(%arg0: vector<2xf32>) "None" { spv.func @convert_float_to_unsigned_vector(%arg0: vector<2xf32>) "None" {
// CHECK: llvm.fptoui %{{.*}} : !llvm.vec<2 x float> to !llvm.vec<2 x i32> // CHECK: llvm.fptoui %{{.*}} : !llvm.vec<2 x float> to !llvm.vec<2 x i32>
%0 = spv.ConvertFToU %arg0: vector<2xf32> to vector<2xi32> %0 = spv.ConvertFToU %arg0: vector<2xf32> to vector<2xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertSToF // spv.ConvertSToF
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @convert_signed_to_float_scalar // CHECK-LABEL: @convert_signed_to_float_scalar
spv.func @convert_signed_to_float_scalar(%arg0: i32) "None" { spv.func @convert_signed_to_float_scalar(%arg0: i32) "None" {
// CHECK: llvm.sitofp %{{.*}} : !llvm.i32 to !llvm.float // CHECK: llvm.sitofp %{{.*}} : i32 to !llvm.float
%0 = spv.ConvertSToF %arg0: i32 to f32 %0 = spv.ConvertSToF %arg0: i32 to f32
spv.Return spv.Return
} }
// CHECK-LABEL: @convert_signed_to_float_vector // CHECK-LABEL: @convert_signed_to_float_vector
spv.func @convert_signed_to_float_vector(%arg0: vector<3xi32>) "None" { spv.func @convert_signed_to_float_vector(%arg0: vector<3xi32>) "None" {
// CHECK: llvm.sitofp %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x float> // CHECK: llvm.sitofp %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x float>
%0 = spv.ConvertSToF %arg0: vector<3xi32> to vector<3xf32> %0 = spv.ConvertSToF %arg0: vector<3xi32> to vector<3xf32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertUToF // spv.ConvertUToF
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @convert_unsigned_to_float_scalar // CHECK-LABEL: @convert_unsigned_to_float_scalar
spv.func @convert_unsigned_to_float_scalar(%arg0: i32) "None" { spv.func @convert_unsigned_to_float_scalar(%arg0: i32) "None" {
// CHECK: llvm.uitofp %{{.*}} : !llvm.i32 to !llvm.float // CHECK: llvm.uitofp %{{.*}} : i32 to !llvm.float
%0 = spv.ConvertUToF %arg0: i32 to f32 %0 = spv.ConvertUToF %arg0: i32 to f32
spv.Return spv.Return
} }
// CHECK-LABEL: @convert_unsigned_to_float_vector // CHECK-LABEL: @convert_unsigned_to_float_vector
spv.func @convert_unsigned_to_float_vector(%arg0: vector<3xi32>) "None" { spv.func @convert_unsigned_to_float_vector(%arg0: vector<3xi32>) "None" {
// CHECK: llvm.uitofp %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x float> // CHECK: llvm.uitofp %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x float>
%0 = spv.ConvertUToF %arg0: vector<3xi32> to vector<3xf32> %0 = spv.ConvertUToF %arg0: vector<3xi32> to vector<3xf32>
Show All 25 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SConvert // spv.SConvert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @sconvert_scalar // CHECK-LABEL: @sconvert_scalar
spv.func @sconvert_scalar(%arg0: i32, %arg1: i64) "None" { spv.func @sconvert_scalar(%arg0: i32, %arg1: i64) "None" {
// CHECK: llvm.sext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: llvm.sext %{{.*}} : i32 to i64
%0 = spv.SConvert %arg0: i32 to i64 %0 = spv.SConvert %arg0: i32 to i64
// CHECK: llvm.trunc %{{.*}} : !llvm.i64 to !llvm.i32 // CHECK: llvm.trunc %{{.*}} : i64 to i32
%1 = spv.SConvert %arg1: i64 to i32 %1 = spv.SConvert %arg1: i64 to i32
spv.Return spv.Return
} }
// CHECK-LABEL: @sconvert_vector // CHECK-LABEL: @sconvert_vector
spv.func @sconvert_vector(%arg0: vector<3xi32>, %arg1: vector<3xi64>) "None" { spv.func @sconvert_vector(%arg0: vector<3xi32>, %arg1: vector<3xi64>) "None" {
// CHECK: llvm.sext %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x i64> // CHECK: llvm.sext %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x i64>
%0 = spv.SConvert %arg0: vector<3xi32> to vector<3xi64> %0 = spv.SConvert %arg0: vector<3xi32> to vector<3xi64>
// CHECK: llvm.trunc %{{.*}} : !llvm.vec<3 x i64> to !llvm.vec<3 x i32> // CHECK: llvm.trunc %{{.*}} : !llvm.vec<3 x i64> to !llvm.vec<3 x i32>
%1 = spv.SConvert %arg1: vector<3xi64> to vector<3xi32> %1 = spv.SConvert %arg1: vector<3xi64> to vector<3xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UConvert // spv.UConvert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @uconvert_scalar // CHECK-LABEL: @uconvert_scalar
spv.func @uconvert_scalar(%arg0: i32, %arg1: i64) "None" { spv.func @uconvert_scalar(%arg0: i32, %arg1: i64) "None" {
// CHECK: llvm.zext %{{.*}} : !llvm.i32 to !llvm.i64 // CHECK: llvm.zext %{{.*}} : i32 to i64
%0 = spv.UConvert %arg0: i32 to i64 %0 = spv.UConvert %arg0: i32 to i64
// CHECK: llvm.trunc %{{.*}} : !llvm.i64 to !llvm.i32 // CHECK: llvm.trunc %{{.*}} : i64 to i32
%1 = spv.UConvert %arg1: i64 to i32 %1 = spv.UConvert %arg1: i64 to i32
spv.Return spv.Return
} }
// CHECK-LABEL: @uconvert_vector // CHECK-LABEL: @uconvert_vector
spv.func @uconvert_vector(%arg0: vector<3xi32>, %arg1: vector<3xi64>) "None" { spv.func @uconvert_vector(%arg0: vector<3xi32>, %arg1: vector<3xi64>) "None" {
// CHECK: llvm.zext %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x i64> // CHECK: llvm.zext %{{.*}} : !llvm.vec<3 x i32> to !llvm.vec<3 x i64>
%0 = spv.UConvert %arg0: vector<3xi32> to vector<3xi64> %0 = spv.UConvert %arg0: vector<3xi32> to vector<3xi64>
// CHECK: llvm.trunc %{{.*}} : !llvm.vec<3 x i64> to !llvm.vec<3 x i32> // CHECK: llvm.trunc %{{.*}} : !llvm.vec<3 x i64> to !llvm.vec<3 x i32>
%1 = spv.UConvert %arg1: vector<3xi64> to vector<3xi32> %1 = spv.UConvert %arg1: vector<3xi64> to vector<3xi32>
spv.Return spv.Return
} }

mlir/test/Conversion/SPIRVToLLVM/comparison-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IEqual // spv.IEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @i_equal_scalar // CHECK-LABEL: @i_equal_scalar
spv.func @i_equal_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @i_equal_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : i32
%0 = spv.IEqual %arg0, %arg1 : i32 %0 = spv.IEqual %arg0, %arg1 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @i_equal_vector // CHECK-LABEL: @i_equal_vector
spv.func @i_equal_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" { spv.func @i_equal_vector(%arg0: vector<4xi64>, %arg1: vector<4xi64>) "None" {
// CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : !llvm.vec<4 x i64> // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
%0 = spv.IEqual %arg0, %arg1 : vector<4xi64> %0 = spv.IEqual %arg0, %arg1 : vector<4xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.INotEqual // spv.INotEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @i_not_equal_scalar // CHECK-LABEL: @i_not_equal_scalar
spv.func @i_not_equal_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @i_not_equal_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : i64
%0 = spv.INotEqual %arg0, %arg1 : i64 %0 = spv.INotEqual %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @i_not_equal_vector // CHECK-LABEL: @i_not_equal_vector
spv.func @i_not_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @i_not_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.INotEqual %arg0, %arg1 : vector<2xi64> %0 = spv.INotEqual %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SGreaterThanEqual // spv.SGreaterThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @s_greater_than_equal_scalar // CHECK-LABEL: @s_greater_than_equal_scalar
spv.func @s_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @s_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : i64
%0 = spv.SGreaterThanEqual %arg0, %arg1 : i64 %0 = spv.SGreaterThanEqual %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @s_greater_than_equal_vector // CHECK-LABEL: @s_greater_than_equal_vector
spv.func @s_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @s_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "sge" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<2xi64> %0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SGreaterThan // spv.SGreaterThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @s_greater_than_scalar // CHECK-LABEL: @s_greater_than_scalar
spv.func @s_greater_than_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @s_greater_than_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : i64
%0 = spv.SGreaterThan %arg0, %arg1 : i64 %0 = spv.SGreaterThan %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @s_greater_than_vector // CHECK-LABEL: @s_greater_than_vector
spv.func @s_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @s_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.SGreaterThan %arg0, %arg1 : vector<2xi64> %0 = spv.SGreaterThan %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SLessThanEqual // spv.SLessThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @s_less_than_equal_scalar // CHECK-LABEL: @s_less_than_equal_scalar
spv.func @s_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @s_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : i64
%0 = spv.SLessThanEqual %arg0, %arg1 : i64 %0 = spv.SLessThanEqual %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @s_less_than_equal_vector // CHECK-LABEL: @s_less_than_equal_vector
spv.func @s_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @s_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "sle" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.SLessThanEqual %arg0, %arg1 : vector<2xi64> %0 = spv.SLessThanEqual %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SLessThan // spv.SLessThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @s_less_than_scalar // CHECK-LABEL: @s_less_than_scalar
spv.func @s_less_than_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @s_less_than_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : i64
%0 = spv.SLessThan %arg0, %arg1 : i64 %0 = spv.SLessThan %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @s_less_than_vector // CHECK-LABEL: @s_less_than_vector
spv.func @s_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @s_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.SLessThan %arg0, %arg1 : vector<2xi64> %0 = spv.SLessThan %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UGreaterThanEqual // spv.UGreaterThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @u_greater_than_equal_scalar // CHECK-LABEL: @u_greater_than_equal_scalar
spv.func @u_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @u_greater_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : i64
%0 = spv.UGreaterThanEqual %arg0, %arg1 : i64 %0 = spv.UGreaterThanEqual %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @u_greater_than_equal_vector // CHECK-LABEL: @u_greater_than_equal_vector
spv.func @u_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @u_greater_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "uge" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<2xi64> %0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UGreaterThan // spv.UGreaterThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @u_greater_than_scalar // CHECK-LABEL: @u_greater_than_scalar
spv.func @u_greater_than_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @u_greater_than_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : i64
%0 = spv.UGreaterThan %arg0, %arg1 : i64 %0 = spv.UGreaterThan %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @u_greater_than_vector // CHECK-LABEL: @u_greater_than_vector
spv.func @u_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @u_greater_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "ugt" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.UGreaterThan %arg0, %arg1 : vector<2xi64> %0 = spv.UGreaterThan %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ULessThanEqual // spv.ULessThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @u_less_than_equal_scalar // CHECK-LABEL: @u_less_than_equal_scalar
spv.func @u_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @u_less_than_equal_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : i64
%0 = spv.ULessThanEqual %arg0, %arg1 : i64 %0 = spv.ULessThanEqual %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @u_less_than_equal_vector // CHECK-LABEL: @u_less_than_equal_vector
spv.func @u_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @u_less_than_equal_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "ule" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.ULessThanEqual %arg0, %arg1 : vector<2xi64> %0 = spv.ULessThanEqual %arg0, %arg1 : vector<2xi64>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ULessThan // spv.ULessThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @u_less_than_scalar // CHECK-LABEL: @u_less_than_scalar
spv.func @u_less_than_scalar(%arg0: i64, %arg1: i64) "None" { spv.func @u_less_than_scalar(%arg0: i64, %arg1: i64) "None" {
// CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : i64
%0 = spv.ULessThan %arg0, %arg1 : i64 %0 = spv.ULessThan %arg0, %arg1 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @u_less_than_vector // CHECK-LABEL: @u_less_than_vector
spv.func @u_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" { spv.func @u_less_than_vector(%arg0: vector<2xi64>, %arg1: vector<2xi64>) "None" {
// CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64> // CHECK: llvm.icmp "ult" %{{.*}}, %{{.*}} : !llvm.vec<2 x i64>
%0 = spv.ULessThan %arg0, %arg1 : vector<2xi64> %0 = spv.ULessThan %arg0, %arg1 : vector<2xi64>
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

mlir/test/Conversion/SPIRVToLLVM/constant-op-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.constant // spv.constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @bool_constant_scalar // CHECK-LABEL: @bool_constant_scalar
spv.func @bool_constant_scalar() "None" { spv.func @bool_constant_scalar() "None" {
// CHECK: llvm.mlir.constant(true) : !llvm.i1 // CHECK: llvm.mlir.constant(true) : i1
%0 = spv.constant true %0 = spv.constant true
// CHECK: llvm.mlir.constant(false) : !llvm.i1 // CHECK: llvm.mlir.constant(false) : i1
%1 = spv.constant false %1 = spv.constant false
spv.Return spv.Return
} }
// CHECK-LABEL: @bool_constant_vector // CHECK-LABEL: @bool_constant_vector
spv.func @bool_constant_vector() "None" { spv.func @bool_constant_vector() "None" {
// CHECK: llvm.mlir.constant(dense<[true, false]> : vector<2xi1>) : !llvm.vec<2 x i1> // CHECK: llvm.mlir.constant(dense<[true, false]> : vector<2xi1>) : !llvm.vec<2 x i1>
%0 = spv.constant dense<[true, false]> : vector<2xi1> %0 = spv.constant dense<[true, false]> : vector<2xi1>
// CHECK: llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1> // CHECK: llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1>
%1 = spv.constant dense<false> : vector<3xi1> %1 = spv.constant dense<false> : vector<3xi1>
spv.Return spv.Return
} }
// CHECK-LABEL: @integer_constant_scalar // CHECK-LABEL: @integer_constant_scalar
spv.func @integer_constant_scalar() "None" { spv.func @integer_constant_scalar() "None" {
// CHECK: llvm.mlir.constant(0 : i8) : !llvm.i8 // CHECK: llvm.mlir.constant(0 : i8) : i8
%0 = spv.constant 0 : i8 %0 = spv.constant 0 : i8
// CHECK: llvm.mlir.constant(-5 : i64) : !llvm.i64 // CHECK: llvm.mlir.constant(-5 : i64) : i64
%1 = spv.constant -5 : si64 %1 = spv.constant -5 : si64
// CHECK: llvm.mlir.constant(10 : i16) : !llvm.i16 // CHECK: llvm.mlir.constant(10 : i16) : i16
%2 = spv.constant 10 : ui16 %2 = spv.constant 10 : ui16
spv.Return spv.Return
} }
// CHECK-LABEL: @integer_constant_vector // CHECK-LABEL: @integer_constant_vector
spv.func @integer_constant_vector() "None" { spv.func @integer_constant_vector() "None" {
// CHECK: llvm.mlir.constant(dense<[2, 3]> : vector<2xi32>) : !llvm.vec<2 x i32> // CHECK: llvm.mlir.constant(dense<[2, 3]> : vector<2xi32>) : !llvm.vec<2 x i32>
%0 = spv.constant dense<[2, 3]> : vector<2xi32> %0 = spv.constant dense<[2, 3]> : vector<2xi32>
Show All 22 Lines

mlir/test/Conversion/SPIRVToLLVM/control-flow-ops-to-llvm.mlir

Show All 10 Linesspv.module Logical GLSL450 {
// CHECK: ^bb1 // CHECK: ^bb1
^label: ^label:
spv.Return spv.Return
} }
spv.func @branch_with_arguments() -> () "None" { spv.func @branch_with_arguments() -> () "None" {
%0 = spv.constant 0 : i32 %0 = spv.constant 0 : i32
%1 = spv.constant true %1 = spv.constant true
// CHECK: llvm.br ^bb1(%{{.*}}, %{{.*}} : !llvm.i32, !llvm.i1) // CHECK: llvm.br ^bb1(%{{.*}}, %{{.*}} : i32, i1)
spv.Branch ^label(%0, %1: i32, i1) spv.Branch ^label(%0, %1: i32, i1)
// CHECK: ^bb1(%{{.*}}: !llvm.i32, %{{.*}}: !llvm.i1) // CHECK: ^bb1(%{{.*}}: i32, %{{.*}}: i1)
^label(%arg0: i32, %arg1: i1): ^label(%arg0: i32, %arg1: i1):
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BranchConditional // spv.BranchConditional
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @cond_branch_without_arguments() -> () "None" { spv.func @cond_branch_without_arguments() -> () "None" {
// CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : !llvm.i1 // CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : i1
%cond = spv.constant true %cond = spv.constant true
// CHECK: lvm.cond_br %[[COND]], ^bb1, ^bb2 // CHECK: lvm.cond_br %[[COND]], ^bb1, ^bb2
spv.BranchConditional %cond, ^true, ^false spv.BranchConditional %cond, ^true, ^false
// CHECK: ^bb1: // CHECK: ^bb1:
^true: ^true:
spv.Return spv.Return
// CHECK: ^bb2: // CHECK: ^bb2:
^false: ^false:
spv.Return spv.Return
} }
spv.func @cond_branch_with_arguments_nested() -> () "None" { spv.func @cond_branch_with_arguments_nested() -> () "None" {
// CHECK: %[[COND1:.*]] = llvm.mlir.constant(true) : !llvm.i1 // CHECK: %[[COND1:.*]] = llvm.mlir.constant(true) : i1
%cond = spv.constant true %cond = spv.constant true
%0 = spv.constant 0 : i32 %0 = spv.constant 0 : i32
// CHECK: %[[COND2:.*]] = llvm.mlir.constant(false) : !llvm.i1 // CHECK: %[[COND2:.*]] = llvm.mlir.constant(false) : i1
%false = spv.constant false %false = spv.constant false
// CHECK: llvm.cond_br %[[COND1]], ^bb1(%{{.*}}, %[[COND2]] : !llvm.i32, !llvm.i1), ^bb2 // CHECK: llvm.cond_br %[[COND1]], ^bb1(%{{.*}}, %[[COND2]] : i32, i1), ^bb2
spv.BranchConditional %cond, ^outer_true(%0, %false: i32, i1), ^outer_false spv.BranchConditional %cond, ^outer_true(%0, %false: i32, i1), ^outer_false
// CHECK: ^bb1(%{{.*}}: !llvm.i32, %[[COND:.*]]: !llvm.i1): // CHECK: ^bb1(%{{.*}}: i32, %[[COND:.*]]: i1):
^outer_true(%arg0: i32, %arg1: i1): ^outer_true(%arg0: i32, %arg1: i1):
// CHECK: llvm.cond_br %[[COND]], ^bb3, ^bb4(%{{.*}}, %{{.*}} : !llvm.i32, !llvm.i32) // CHECK: llvm.cond_br %[[COND]], ^bb3, ^bb4(%{{.*}}, %{{.*}} : i32, i32)
spv.BranchConditional %arg1, ^inner_true, ^inner_false(%arg0, %arg0: i32, i32) spv.BranchConditional %arg1, ^inner_true, ^inner_false(%arg0, %arg0: i32, i32)
// CHECK: ^bb2: // CHECK: ^bb2:
^outer_false: ^outer_false:
spv.Return spv.Return
// CHECK: ^bb3: // CHECK: ^bb3:
^inner_true: ^inner_true:
spv.Return spv.Return
// CHECK: ^bb4(%{{.*}}: !llvm.i32, %{{.*}}: !llvm.i32): // CHECK: ^bb4(%{{.*}}: i32, %{{.*}}: i32):
^inner_false(%arg3: i32, %arg4: i32): ^inner_false(%arg3: i32, %arg4: i32):
spv.Return spv.Return
} }
spv.func @cond_branch_with_weights(%cond: i1) -> () "None" { spv.func @cond_branch_with_weights(%cond: i1) -> () "None" {
// CHECK: llvm.cond_br %{{.*}} weights(dense<[1, 2]> : vector<2xi32>), ^bb1, ^bb2 // CHECK: llvm.cond_br %{{.*}} weights(dense<[1, 2]> : vector<2xi32>), ^bb1, ^bb2
spv.BranchConditional %cond [1, 2], ^true, ^false spv.BranchConditional %cond [1, 2], ^true, ^false
// CHECK: ^bb1: // CHECK: ^bb1:
Show All 11 Lines
// spv.loop // spv.loop
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// CHECK-LABEL: @infinite_loop // CHECK-LABEL: @infinite_loop
spv.func @infinite_loop(%count : i32) -> () "None" { spv.func @infinite_loop(%count : i32) -> () "None" {
// CHECK: llvm.br ^[[BB1:.*]] // CHECK: llvm.br ^[[BB1:.*]]
// CHECK: ^[[BB1]]: // CHECK: ^[[BB1]]:
// CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : !llvm.i1 // CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : i1
// CHECK: llvm.cond_br %[[COND]], ^[[BB2:.*]], ^[[BB4:.*]] // CHECK: llvm.cond_br %[[COND]], ^[[BB2:.*]], ^[[BB4:.*]]
// CHECK: ^[[BB2]]: // CHECK: ^[[BB2]]:
// CHECK: llvm.br ^[[BB3:.*]] // CHECK: llvm.br ^[[BB3:.*]]
// CHECK: ^[[BB3]]: // CHECK: ^[[BB3]]:
// CHECK: llvm.br ^[[BB1:.*]] // CHECK: llvm.br ^[[BB1:.*]]
// CHECK: ^[[BB4]]: // CHECK: ^[[BB4]]:
// CHECK: llvm.br ^[[BB5:.*]] // CHECK: llvm.br ^[[BB5:.*]]
// CHECK: ^[[BB5]]: // CHECK: ^[[BB5]]:
Show All 37 Lines spv.selection {
spv.BranchConditional %cond, ^merge, ^merge spv.BranchConditional %cond, ^merge, ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
spv.func @selection_with_true_block_only() -> () "None" { spv.func @selection_with_true_block_only() -> () "None" {
// CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : !llvm.i1 // CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : i1
%cond = spv.constant true %cond = spv.constant true
// CHECK: llvm.cond_br %[[COND]], ^bb1, ^bb2 // CHECK: llvm.cond_br %[[COND]], ^bb1, ^bb2
spv.selection { spv.selection {
spv.BranchConditional %cond, ^true, ^merge spv.BranchConditional %cond, ^true, ^merge
// CHECK: ^bb1: // CHECK: ^bb1:
^true: ^true:
// CHECK: llvm.br ^bb2 // CHECK: llvm.br ^bb2
spv.Branch ^merge spv.Branch ^merge
// CHECK: ^bb2: // CHECK: ^bb2:
^merge: ^merge:
// CHECK: llvm.br ^bb3 // CHECK: llvm.br ^bb3
spv.mlir.merge spv.mlir.merge
} }
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
spv.Return spv.Return
} }
spv.func @selection_with_both_true_and_false_block() -> () "None" { spv.func @selection_with_both_true_and_false_block() -> () "None" {
// CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : !llvm.i1 // CHECK: %[[COND:.*]] = llvm.mlir.constant(true) : i1
%cond = spv.constant true %cond = spv.constant true
// CHECK: llvm.cond_br %[[COND]], ^bb1, ^bb2 // CHECK: llvm.cond_br %[[COND]], ^bb1, ^bb2
spv.selection { spv.selection {
spv.BranchConditional %cond, ^true, ^false spv.BranchConditional %cond, ^true, ^false
// CHECK: ^bb1: // CHECK: ^bb1:
^true: ^true:
// CHECK: llvm.br ^bb3 // CHECK: llvm.br ^bb3
spv.Branch ^merge spv.Branch ^merge
// CHECK: ^bb2: // CHECK: ^bb2:
^false: ^false:
// CHECK: llvm.br ^bb3 // CHECK: llvm.br ^bb3
spv.Branch ^merge spv.Branch ^merge
// CHECK: ^bb3: // CHECK: ^bb3:
^merge: ^merge:
// CHECK: llvm.br ^bb4 // CHECK: llvm.br ^bb4
spv.mlir.merge spv.mlir.merge
} }
// CHECK: ^bb4: // CHECK: ^bb4:
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
spv.Return spv.Return
} }
spv.func @selection_with_early_return(%arg0: i1) -> i32 "None" { spv.func @selection_with_early_return(%arg0: i1) -> i32 "None" {
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
%0 = spv.constant 0 : i32 %0 = spv.constant 0 : i32
// CHECK: llvm.cond_br %{{.*}}, ^bb1(%[[ZERO]] : !llvm.i32), ^bb2 // CHECK: llvm.cond_br %{{.*}}, ^bb1(%[[ZERO]] : i32), ^bb2
spv.selection { spv.selection {
spv.BranchConditional %arg0, ^true(%0 : i32), ^merge spv.BranchConditional %arg0, ^true(%0 : i32), ^merge
// CHECK: ^bb1(%[[ARG:.*]]: !llvm.i32): // CHECK: ^bb1(%[[ARG:.*]]: i32):
^true(%arg1: i32): ^true(%arg1: i32):
// CHECK: llvm.return %[[ARG]] : !llvm.i32 // CHECK: llvm.return %[[ARG]] : i32
spv.ReturnValue %arg1 : i32 spv.ReturnValue %arg1 : i32
// CHECK: ^bb2: // CHECK: ^bb2:
^merge: ^merge:
// CHECK: llvm.br ^bb3 // CHECK: llvm.br ^bb3
spv.mlir.merge spv.mlir.merge
} }
// CHECK: ^bb3: // CHECK: ^bb3:
%one = spv.constant 1 : i32 %one = spv.constant 1 : i32
spv.ReturnValue %one : i32 spv.ReturnValue %one : i32
} }
} }

mlir/test/Conversion/SPIRVToLLVM/func-ops-to-llvm.mlir

Show All 10 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ReturnValue // spv.ReturnValue
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @return_value // CHECK-LABEL: @return_value
spv.func @return_value(%arg: i32) -> i32 "None" { spv.func @return_value(%arg: i32) -> i32 "None" {
// CHECK: llvm.return %{{.*}} : !llvm.i32 // CHECK: llvm.return %{{.*}} : i32
spv.ReturnValue %arg : i32 spv.ReturnValue %arg : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.func // spv.func
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: llvm.func @none() // CHECK-LABEL: llvm.func @none()
Show All 16 Linesspv.func @pure() "Pure" {
spv.Return spv.Return
} }
// CHECK-LABEL: llvm.func @const() attributes {passthrough = ["readnone"]} // CHECK-LABEL: llvm.func @const() attributes {passthrough = ["readnone"]}
spv.func @const() "Const" { spv.func @const() "Const" {
spv.Return spv.Return
} }
// CHECK-LABEL: llvm.func @scalar_types(%arg0: !llvm.i32, %arg1: !llvm.i1, %arg2: !llvm.double, %arg3: !llvm.float) // CHECK-LABEL: llvm.func @scalar_types(%arg0: i32, %arg1: i1, %arg2: !llvm.double, %arg3: !llvm.float)
spv.func @scalar_types(%arg0: i32, %arg1: i1, %arg2: f64, %arg3: f32) "None" { spv.func @scalar_types(%arg0: i32, %arg1: i1, %arg2: f64, %arg3: f32) "None" {
spv.Return spv.Return
} }
// CHECK-LABEL: llvm.func @vector_types(%arg0: !llvm.vec<2 x i64>, %arg1: !llvm.vec<2 x i64>) -> !llvm.vec<2 x i64> // CHECK-LABEL: llvm.func @vector_types(%arg0: !llvm.vec<2 x i64>, %arg1: !llvm.vec<2 x i64>) -> !llvm.vec<2 x i64>
spv.func @vector_types(%arg0: vector<2xi64>, %arg1: vector<2xi64>) -> vector<2xi64> "None" { spv.func @vector_types(%arg0: vector<2xi64>, %arg1: vector<2xi64>) -> vector<2xi64> "None" {
%0 = spv.IAdd %arg0, %arg1 : vector<2xi64> %0 = spv.IAdd %arg0, %arg1 : vector<2xi64>
spv.ReturnValue %0 : vector<2xi64> spv.ReturnValue %0 : vector<2xi64>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FunctionCall // spv.FunctionCall
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: llvm.func @function_calls // CHECK-LABEL: llvm.func @function_calls
// CHECK-SAME: %[[ARG0:.*]]: !llvm.i32, %[[ARG1:.*]]: !llvm.i1, %[[ARG2:.*]]: !llvm.double, %[[ARG3:.*]]: !llvm.vec<2 x i64>, %[[ARG4:.*]]: !llvm.vec<2 x float> // CHECK-SAME: %[[ARG0:.*]]: i32, %[[ARG1:.*]]: i1, %[[ARG2:.*]]: !llvm.double, %[[ARG3:.*]]: !llvm.vec<2 x i64>, %[[ARG4:.*]]: !llvm.vec<2 x float>
spv.func @function_calls(%arg0: i32, %arg1: i1, %arg2: f64, %arg3: vector<2xi64>, %arg4: vector<2xf32>) "None" { spv.func @function_calls(%arg0: i32, %arg1: i1, %arg2: f64, %arg3: vector<2xi64>, %arg4: vector<2xf32>) "None" {
// CHECK: llvm.call @void_1() : () -> () // CHECK: llvm.call @void_1() : () -> ()
// CHECK: llvm.call @void_2(%[[ARG3]]) : (!llvm.vec<2 x i64>) -> () // CHECK: llvm.call @void_2(%[[ARG3]]) : (!llvm.vec<2 x i64>) -> ()
// CHECK: llvm.call @value_scalar(%[[ARG0]], %[[ARG1]], %[[ARG2]]) : (!llvm.i32, !llvm.i1, !llvm.double) -> !llvm.i32 // CHECK: llvm.call @value_scalar(%[[ARG0]], %[[ARG1]], %[[ARG2]]) : (i32, i1, !llvm.double) -> i32
// CHECK: llvm.call @value_vector(%[[ARG3]], %[[ARG4]]) : (!llvm.vec<2 x i64>, !llvm.vec<2 x float>) -> !llvm.vec<2 x float> // CHECK: llvm.call @value_vector(%[[ARG3]], %[[ARG4]]) : (!llvm.vec<2 x i64>, !llvm.vec<2 x float>) -> !llvm.vec<2 x float>
spv.FunctionCall @void_1() : () -> () spv.FunctionCall @void_1() : () -> ()
spv.FunctionCall @void_2(%arg3) : (vector<2xi64>) -> () spv.FunctionCall @void_2(%arg3) : (vector<2xi64>) -> ()
%0 = spv.FunctionCall @value_scalar(%arg0, %arg1, %arg2) : (i32, i1, f64) -> i32 %0 = spv.FunctionCall @value_scalar(%arg0, %arg1, %arg2) : (i32, i1, f64) -> i32
%1 = spv.FunctionCall @value_vector(%arg3, %arg4) : (vector<2xi64>, vector<2xf32>) -> vector<2xf32> %1 = spv.FunctionCall @value_vector(%arg3, %arg4) : (vector<2xi64>, vector<2xf32>) -> vector<2xf32>
spv.Return spv.Return
} }
Show All 15 Lines

mlir/test/Conversion/SPIRVToLLVM/glsl-ops-to-llvm.mlir

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.SMax // spv.GLSL.SMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @smax // CHECK-LABEL: @smax
spv.func @smax(%arg0: i16, %arg1: vector<3xi32>) "None" { spv.func @smax(%arg0: i16, %arg1: vector<3xi32>) "None" {
// CHECK: "llvm.intr.smax"(%{{.*}}, %{{.*}}) : (!llvm.i16, !llvm.i16) -> !llvm.i16 // CHECK: "llvm.intr.smax"(%{{.*}}, %{{.*}}) : (i16, i16) -> i16
%0 = spv.GLSL.SMax %arg0, %arg0 : i16 %0 = spv.GLSL.SMax %arg0, %arg0 : i16
// CHECK: "llvm.intr.smax"(%{{.*}}, %{{.*}}) : (!llvm.vec<3 x i32>, !llvm.vec<3 x i32>) -> !llvm.vec<3 x i32> // CHECK: "llvm.intr.smax"(%{{.*}}, %{{.*}}) : (!llvm.vec<3 x i32>, !llvm.vec<3 x i32>) -> !llvm.vec<3 x i32>
%1 = spv.GLSL.SMax %arg1, %arg1 : vector<3xi32> %1 = spv.GLSL.SMax %arg1, %arg1 : vector<3xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.SMin // spv.GLSL.SMin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @smin // CHECK-LABEL: @smin
spv.func @smin(%arg0: i16, %arg1: vector<3xi32>) "None" { spv.func @smin(%arg0: i16, %arg1: vector<3xi32>) "None" {
// CHECK: "llvm.intr.smin"(%{{.*}}, %{{.*}}) : (!llvm.i16, !llvm.i16) -> !llvm.i16 // CHECK: "llvm.intr.smin"(%{{.*}}, %{{.*}}) : (i16, i16) -> i16
%0 = spv.GLSL.SMin %arg0, %arg0 : i16 %0 = spv.GLSL.SMin %arg0, %arg0 : i16
// CHECK: "llvm.intr.smin"(%{{.*}}, %{{.*}}) : (!llvm.vec<3 x i32>, !llvm.vec<3 x i32>) -> !llvm.vec<3 x i32> // CHECK: "llvm.intr.smin"(%{{.*}}, %{{.*}}) : (!llvm.vec<3 x i32>, !llvm.vec<3 x i32>) -> !llvm.vec<3 x i32>
%1 = spv.GLSL.SMin %arg1, %arg1 : vector<3xi32> %1 = spv.GLSL.SMin %arg1, %arg1 : vector<3xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Sqrt // spv.GLSL.Sqrt
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

mlir/test/Conversion/SPIRVToLLVM/logical-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalEqual // spv.LogicalEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @logical_equal_scalar // CHECK-LABEL: @logical_equal_scalar
spv.func @logical_equal_scalar(%arg0: i1, %arg1: i1) "None" { spv.func @logical_equal_scalar(%arg0: i1, %arg1: i1) "None" {
// CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : !llvm.i1 // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : i1
%0 = spv.LogicalEqual %arg0, %arg0 : i1 %0 = spv.LogicalEqual %arg0, %arg0 : i1
spv.Return spv.Return
} }
// CHECK-LABEL: @logical_equal_vector // CHECK-LABEL: @logical_equal_vector
spv.func @logical_equal_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" { spv.func @logical_equal_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" {
// CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : !llvm.vec<4 x i1> // CHECK: llvm.icmp "eq" %{{.*}}, %{{.*}} : !llvm.vec<4 x i1>
%0 = spv.LogicalEqual %arg0, %arg0 : vector<4xi1> %0 = spv.LogicalEqual %arg0, %arg0 : vector<4xi1>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalNotEqual // spv.LogicalNotEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @logical_not_equal_scalar // CHECK-LABEL: @logical_not_equal_scalar
spv.func @logical_not_equal_scalar(%arg0: i1, %arg1: i1) "None" { spv.func @logical_not_equal_scalar(%arg0: i1, %arg1: i1) "None" {
// CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : !llvm.i1 // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : i1
%0 = spv.LogicalNotEqual %arg0, %arg0 : i1 %0 = spv.LogicalNotEqual %arg0, %arg0 : i1
spv.Return spv.Return
} }
// CHECK-LABEL: @logical_not_equal_vector // CHECK-LABEL: @logical_not_equal_vector
spv.func @logical_not_equal_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" { spv.func @logical_not_equal_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" {
// CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : !llvm.vec<4 x i1> // CHECK: llvm.icmp "ne" %{{.*}}, %{{.*}} : !llvm.vec<4 x i1>
%0 = spv.LogicalNotEqual %arg0, %arg0 : vector<4xi1> %0 = spv.LogicalNotEqual %arg0, %arg0 : vector<4xi1>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalNot // spv.LogicalNot
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @logical_not_scalar // CHECK-LABEL: @logical_not_scalar
spv.func @logical_not_scalar(%arg0: i1) "None" { spv.func @logical_not_scalar(%arg0: i1) "None" {
// CHECK: %[[CONST:.*]] = llvm.mlir.constant(true) : !llvm.i1 // CHECK: %[[CONST:.*]] = llvm.mlir.constant(true) : i1
// CHECK: llvm.xor %{{.*}}, %[[CONST]] : !llvm.i1 // CHECK: llvm.xor %{{.*}}, %[[CONST]] : i1
%0 = spv.LogicalNot %arg0 : i1 %0 = spv.LogicalNot %arg0 : i1
spv.Return spv.Return
} }
// CHECK-LABEL: @logical_not_vector // CHECK-LABEL: @logical_not_vector
spv.func @logical_not_vector(%arg0: vector<4xi1>) "None" { spv.func @logical_not_vector(%arg0: vector<4xi1>) "None" {
// CHECK: %[[CONST:.*]] = llvm.mlir.constant(dense<true> : vector<4xi1>) : !llvm.vec<4 x i1> // CHECK: %[[CONST:.*]] = llvm.mlir.constant(dense<true> : vector<4xi1>) : !llvm.vec<4 x i1>
// CHECK: llvm.xor %{{.*}}, %[[CONST]] : !llvm.vec<4 x i1> // CHECK: llvm.xor %{{.*}}, %[[CONST]] : !llvm.vec<4 x i1>
%0 = spv.LogicalNot %arg0 : vector<4xi1> %0 = spv.LogicalNot %arg0 : vector<4xi1>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalAnd // spv.LogicalAnd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @logical_and_scalar // CHECK-LABEL: @logical_and_scalar
spv.func @logical_and_scalar(%arg0: i1, %arg1: i1) "None" { spv.func @logical_and_scalar(%arg0: i1, %arg1: i1) "None" {
// CHECK: llvm.and %{{.*}}, %{{.*}} : !llvm.i1 // CHECK: llvm.and %{{.*}}, %{{.*}} : i1
%0 = spv.LogicalAnd %arg0, %arg0 : i1 %0 = spv.LogicalAnd %arg0, %arg0 : i1
spv.Return spv.Return
} }
// CHECK-LABEL: @logical_and_vector // CHECK-LABEL: @logical_and_vector
spv.func @logical_and_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" { spv.func @logical_and_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" {
// CHECK: llvm.and %{{.*}}, %{{.*}} : !llvm.vec<4 x i1> // CHECK: llvm.and %{{.*}}, %{{.*}} : !llvm.vec<4 x i1>
%0 = spv.LogicalAnd %arg0, %arg0 : vector<4xi1> %0 = spv.LogicalAnd %arg0, %arg0 : vector<4xi1>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalOr // spv.LogicalOr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @logical_or_scalar // CHECK-LABEL: @logical_or_scalar
spv.func @logical_or_scalar(%arg0: i1, %arg1: i1) "None" { spv.func @logical_or_scalar(%arg0: i1, %arg1: i1) "None" {
// CHECK: llvm.or %{{.*}}, %{{.*}} : !llvm.i1 // CHECK: llvm.or %{{.*}}, %{{.*}} : i1
%0 = spv.LogicalOr %arg0, %arg0 : i1 %0 = spv.LogicalOr %arg0, %arg0 : i1
spv.Return spv.Return
} }
// CHECK-LABEL: @logical_or_vector // CHECK-LABEL: @logical_or_vector
spv.func @logical_or_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" { spv.func @logical_or_vector(%arg0: vector<4xi1>, %arg1: vector<4xi1>) "None" {
// CHECK: llvm.or %{{.*}}, %{{.*}} : !llvm.vec<4 x i1> // CHECK: llvm.or %{{.*}}, %{{.*}} : !llvm.vec<4 x i1>
%0 = spv.LogicalOr %arg0, %arg0 : vector<4xi1> %0 = spv.LogicalOr %arg0, %arg0 : vector<4xi1>
spv.Return spv.Return
} }

mlir/test/Conversion/SPIRVToLLVM/lower-host-to-llvm-calls.mlir

Show All 9 Linesmodule attributes {gpu.container_module, spv.target_env = #spv.target_env<#spv.vce<v1.0, [Shader], [SPV_KHR_variable_pointers]>, {max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_size = dense<[128, 128, 64]> : vector<3xi32>}>} {
// CHECK: spv.func @__spv__foo_bar // CHECK: spv.func @__spv__foo_bar
// CHECK: spv.EntryPoint "GLCompute" @__spv__foo_bar // CHECK: spv.EntryPoint "GLCompute" @__spv__foo_bar
// CHECK: spv.ExecutionMode @__spv__foo_bar "LocalSize", 1, 1, 1 // CHECK: spv.ExecutionMode @__spv__foo_bar "LocalSize", 1, 1, 1
// CHECK-LABEL: @main // CHECK-LABEL: @main
// CHECK: %[[SRC:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[SRC:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<i32>, ptr<i32>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: %[[DEST:.*]] = llvm.mlir.addressof @__spv__foo_bar_arg_0_descriptor_set0_binding0 : !llvm.ptr<struct<(array<6 x i32>)>> // CHECK-NEXT: %[[DEST:.*]] = llvm.mlir.addressof @__spv__foo_bar_arg_0_descriptor_set0_binding0 : !llvm.ptr<struct<(array<6 x i32>)>>
// CHECK-NEXT: llvm.mlir.constant(false) : !llvm.i1 // CHECK-NEXT: llvm.mlir.constant(false) : i1
// CHECK-NEXT: "llvm.intr.memcpy"(%[[DEST]], %[[SRC]], %[[SIZE:.*]], %{{.*}}) : (!llvm.ptr<struct<(array<6 x i32>)>>, !llvm.ptr<i32>, !llvm.i64, !llvm.i1) -> () // CHECK-NEXT: "llvm.intr.memcpy"(%[[DEST]], %[[SRC]], %[[SIZE:.*]], %{{.*}}) : (!llvm.ptr<struct<(array<6 x i32>)>>, !llvm.ptr<i32>, i64, i1) -> ()
// CHECK-NEXT: llvm.call @__spv__foo_bar() : () -> () // CHECK-NEXT: llvm.call @__spv__foo_bar() : () -> ()
// CHECK-NEXT: llvm.mlir.constant(false) : !llvm.i1 // CHECK-NEXT: llvm.mlir.constant(false) : i1
// CHECK-NEXT: "llvm.intr.memcpy"(%[[SRC]], %[[DEST]], %[[SIZE]], %{{.*}}) : (!llvm.ptr<i32>, !llvm.ptr<struct<(array<6 x i32>)>>, !llvm.i64, !llvm.i1) -> () // CHECK-NEXT: "llvm.intr.memcpy"(%[[SRC]], %[[DEST]], %[[SIZE]], %{{.*}}) : (!llvm.ptr<i32>, !llvm.ptr<struct<(array<6 x i32>)>>, i64, i1) -> ()
spv.module @__spv__foo Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_variable_pointers]> { spv.module @__spv__foo Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_variable_pointers]> {
spv.globalVariable @bar_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4> [0])>, StorageBuffer> spv.globalVariable @bar_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4> [0])>, StorageBuffer>
spv.func @bar() "None" attributes {workgroup_attributions = 0 : i64} { spv.func @bar() "None" attributes {workgroup_attributions = 0 : i64} {
%0 = spv.mlir.addressof @bar_arg_0 : !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4> [0])>, StorageBuffer> %0 = spv.mlir.addressof @bar_arg_0 : !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4> [0])>, StorageBuffer>
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @bar spv.EntryPoint "GLCompute" @bar
Show All 17 Lines

mlir/test/Conversion/SPIRVToLLVM/memory-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AccessChain // spv.AccessChain
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @access_chain // CHECK-LABEL: @access_chain
spv.func @access_chain() "None" { spv.func @access_chain() "None" {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
%0 = spv.constant 1: i32 %0 = spv.constant 1: i32
%1 = spv.Variable : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function> %1 = spv.Variable : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: llvm.getelementptr %{{.*}}[%[[ZERO]], %[[ONE]], %[[ONE]]] : (!llvm.ptr<struct<packed (float, array<4 x float>)>>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.ptr<float> // CHECK: llvm.getelementptr %{{.*}}[%[[ZERO]], %[[ONE]], %[[ONE]]] : (!llvm.ptr<struct<packed (float, array<4 x float>)>>, i32, i32, i32) -> !llvm.ptr<float>
%2 = spv.AccessChain %1[%0, %0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>, i32, i32 %2 = spv.AccessChain %1[%0, %0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>, i32, i32
spv.Return spv.Return
} }
// CHECK-LABEL: @access_chain_array // CHECK-LABEL: @access_chain_array
spv.func @access_chain_array(%arg0 : i32) "None" { spv.func @access_chain_array(%arg0 : i32) "None" {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: llvm.getelementptr %{{.*}}[%[[ZERO]], %{{.*}}] : (!llvm.ptr<array<4 x array<4 x float>>>, !llvm.i32, !llvm.i32) -> !llvm.ptr<array<4 x float>> // CHECK: llvm.getelementptr %{{.*}}[%[[ZERO]], %{{.*}}] : (!llvm.ptr<array<4 x array<4 x float>>>, i32, i32) -> !llvm.ptr<array<4 x float>>
%1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32 %1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32
%2 = spv.Load "Function" %1 ["Volatile"] : !spv.array<4xf32> %2 = spv.Load "Function" %1 ["Volatile"] : !spv.array<4xf32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.globalVariable and spv.mlir.addressof // spv.globalVariable and spv.mlir.addressof
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 10 Linesspv.module Logical GLSL450 {
spv.globalVariable @struct : !spv.ptr<!spv.struct<(f32, !spv.array<10xf32>)>, Private> spv.globalVariable @struct : !spv.ptr<!spv.struct<(f32, !spv.array<10xf32>)>, Private>
spv.func @func() "None" { spv.func @func() "None" {
%0 = spv.mlir.addressof @struct : !spv.ptr<!spv.struct<(f32, !spv.array<10xf32>)>, Private> %0 = spv.mlir.addressof @struct : !spv.ptr<!spv.struct<(f32, !spv.array<10xf32>)>, Private>
spv.Return spv.Return
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// CHECK: llvm.mlir.global external @bar_descriptor_set0_binding0() : !llvm.i32 // CHECK: llvm.mlir.global external @bar_descriptor_set0_binding0() : i32
// CHECK-LABEL: @foo // CHECK-LABEL: @foo
// CHECK: llvm.mlir.addressof @bar_descriptor_set0_binding0 : !llvm.ptr<i32> // CHECK: llvm.mlir.addressof @bar_descriptor_set0_binding0 : !llvm.ptr<i32>
spv.globalVariable @bar bind(0, 0) : !spv.ptr<i32, StorageBuffer> spv.globalVariable @bar bind(0, 0) : !spv.ptr<i32, StorageBuffer>
spv.func @foo() "None" { spv.func @foo() "None" {
%0 = spv.mlir.addressof @bar : !spv.ptr<i32, StorageBuffer> %0 = spv.mlir.addressof @bar : !spv.ptr<i32, StorageBuffer>
spv.Return spv.Return
} }
} }
spv.module @name Logical GLSL450 { spv.module @name Logical GLSL450 {
// CHECK: llvm.mlir.global external @name_bar_descriptor_set0_binding0() : !llvm.i32 // CHECK: llvm.mlir.global external @name_bar_descriptor_set0_binding0() : i32
// CHECK-LABEL: @foo // CHECK-LABEL: @foo
// CHECK: llvm.mlir.addressof @name_bar_descriptor_set0_binding0 : !llvm.ptr<i32> // CHECK: llvm.mlir.addressof @name_bar_descriptor_set0_binding0 : !llvm.ptr<i32>
spv.globalVariable @bar bind(0, 0) : !spv.ptr<i32, StorageBuffer> spv.globalVariable @bar bind(0, 0) : !spv.ptr<i32, StorageBuffer>
spv.func @foo() "None" { spv.func @foo() "None" {
%0 = spv.mlir.addressof @bar : !spv.ptr<i32, StorageBuffer> %0 = spv.mlir.addressof @bar : !spv.ptr<i32, StorageBuffer>
spv.Return spv.Return
} }
} }
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Variable // spv.Variable
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @variable_scalar // CHECK-LABEL: @variable_scalar
spv.func @variable_scalar() "None" { spv.func @variable_scalar() "None" {
// CHECK: %[[SIZE1:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[SIZE1:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca %[[SIZE1]] x !llvm.float : (!llvm.i32) -> !llvm.ptr<float> // CHECK: llvm.alloca %[[SIZE1]] x !llvm.float : (i32) -> !llvm.ptr<float>
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: %[[SIZE2:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[SIZE2:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca %[[SIZE2]] x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8> // CHECK: llvm.alloca %[[SIZE2]] x i8 : (i32) -> !llvm.ptr<i8>
%1 = spv.Variable : !spv.ptr<i8, Function> %1 = spv.Variable : !spv.ptr<i8, Function>
spv.Return spv.Return
} }
// CHECK-LABEL: @variable_scalar_with_initialization // CHECK-LABEL: @variable_scalar_with_initialization
spv.func @variable_scalar_with_initialization() "None" { spv.func @variable_scalar_with_initialization() "None" {
// CHECK: %[[VALUE:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[VALUE:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x !llvm.i64 : (!llvm.i32) -> !llvm.ptr<i64> // CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x i64 : (i32) -> !llvm.ptr<i64>
// CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<i64> // CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<i64>
%c = spv.constant 0 : i64 %c = spv.constant 0 : i64
%0 = spv.Variable init(%c) : !spv.ptr<i64, Function> %0 = spv.Variable init(%c) : !spv.ptr<i64, Function>
spv.Return spv.Return
} }
// CHECK-LABEL: @variable_vector // CHECK-LABEL: @variable_vector
spv.func @variable_vector() "None" { spv.func @variable_vector() "None" {
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca %[[SIZE]] x !llvm.vec<3 x float> : (!llvm.i32) -> !llvm.ptr<vec<3 x float>> // CHECK: llvm.alloca %[[SIZE]] x !llvm.vec<3 x float> : (i32) -> !llvm.ptr<vec<3 x float>>
%0 = spv.Variable : !spv.ptr<vector<3xf32>, Function> %0 = spv.Variable : !spv.ptr<vector<3xf32>, Function>
spv.Return spv.Return
} }
// CHECK-LABEL: @variable_vector_with_initialization // CHECK-LABEL: @variable_vector_with_initialization
spv.func @variable_vector_with_initialization() "None" { spv.func @variable_vector_with_initialization() "None" {
// CHECK: %[[VALUE:.*]] = llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1> // CHECK: %[[VALUE:.*]] = llvm.mlir.constant(dense<false> : vector<3xi1>) : !llvm.vec<3 x i1>
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x !llvm.vec<3 x i1> : (!llvm.i32) -> !llvm.ptr<vec<3 x i1>> // CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x !llvm.vec<3 x i1> : (i32) -> !llvm.ptr<vec<3 x i1>>
// CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<vec<3 x i1>> // CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<vec<3 x i1>>
%c = spv.constant dense<false> : vector<3xi1> %c = spv.constant dense<false> : vector<3xi1>
%0 = spv.Variable init(%c) : !spv.ptr<vector<3xi1>, Function> %0 = spv.Variable init(%c) : !spv.ptr<vector<3xi1>, Function>
spv.Return spv.Return
} }
// CHECK-LABEL: @variable_array // CHECK-LABEL: @variable_array
spv.func @variable_array() "None" { spv.func @variable_array() "None" {
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca %[[SIZE]] x !llvm.array<10 x i32> : (!llvm.i32) -> !llvm.ptr<array<10 x i32>> // CHECK: llvm.alloca %[[SIZE]] x !llvm.array<10 x i32> : (i32) -> !llvm.ptr<array<10 x i32>>
%0 = spv.Variable : !spv.ptr<!spv.array<10 x i32>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<10 x i32>, Function>
spv.Return spv.Return
} }

mlir/test/Conversion/SPIRVToLLVM/misc-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeExtract // spv.CompositeExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @composite_extract_array // CHECK-LABEL: @composite_extract_array
spv.func @composite_extract_array(%arg: !spv.array<4x!spv.array<4xf32>>) "None" { spv.func @composite_extract_array(%arg: !spv.array<4x!spv.array<4xf32>>) "None" {
// CHECK: llvm.extractvalue %{{.*}}[1 : i32, 3 : i32] : !llvm.array<4 x array<4 x float>> // CHECK: llvm.extractvalue %{{.*}}[1 : i32, 3 : i32] : !llvm.array<4 x array<4 x float>>
%0 = spv.CompositeExtract %arg[1 : i32, 3 : i32] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg[1 : i32, 3 : i32] : !spv.array<4x!spv.array<4xf32>>
spv.Return spv.Return
} }
// CHECK-LABEL: @composite_extract_vector // CHECK-LABEL: @composite_extract_vector
spv.func @composite_extract_vector(%arg: vector<3xf32>) "None" { spv.func @composite_extract_vector(%arg: vector<3xf32>) "None" {
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: llvm.extractelement %{{.*}}[%[[ZERO]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: llvm.extractelement %{{.*}}[%[[ZERO]] : i32] : !llvm.vec<3 x float>
%0 = spv.CompositeExtract %arg[0 : i32] : vector<3xf32> %0 = spv.CompositeExtract %arg[0 : i32] : vector<3xf32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeInsert // spv.CompositeInsert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @composite_insert_struct // CHECK-LABEL: @composite_insert_struct
spv.func @composite_insert_struct(%arg0: i32, %arg1: !spv.struct<(f32, !spv.array<4xi32>)>) "None" { spv.func @composite_insert_struct(%arg0: i32, %arg1: !spv.struct<(f32, !spv.array<4xi32>)>) "None" {
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1 : i32, 3 : i32] : !llvm.struct<packed (float, array<4 x i32>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1 : i32, 3 : i32] : !llvm.struct<packed (float, array<4 x i32>)>
%0 = spv.CompositeInsert %arg0, %arg1[1 : i32, 3 : i32] : i32 into !spv.struct<(f32, !spv.array<4xi32>)> %0 = spv.CompositeInsert %arg0, %arg1[1 : i32, 3 : i32] : i32 into !spv.struct<(f32, !spv.array<4xi32>)>
spv.Return spv.Return
} }
// CHECK-LABEL: @composite_insert_vector // CHECK-LABEL: @composite_insert_vector
spv.func @composite_insert_vector(%arg0: vector<3xf32>, %arg1: f32) "None" { spv.func @composite_insert_vector(%arg0: vector<3xf32>, %arg1: f32) "None" {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.insertelement %{{.*}}, %{{.*}}[%[[ONE]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: llvm.insertelement %{{.*}}, %{{.*}}[%[[ONE]] : i32] : !llvm.vec<3 x float>
%0 = spv.CompositeInsert %arg1, %arg0[1 : i32] : f32 into vector<3xf32> %0 = spv.CompositeInsert %arg1, %arg0[1 : i32] : f32 into vector<3xf32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Select // spv.Select
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @select_scalar // CHECK-LABEL: @select_scalar
spv.func @select_scalar(%arg0: i1, %arg1: vector<3xi32>, %arg2: f32) "None" { spv.func @select_scalar(%arg0: i1, %arg1: vector<3xi32>, %arg2: f32) "None" {
// CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.vec<3 x i32> // CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : i1, !llvm.vec<3 x i32>
%0 = spv.Select %arg0, %arg1, %arg1 : i1, vector<3xi32> %0 = spv.Select %arg0, %arg1, %arg1 : i1, vector<3xi32>
// CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.float // CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : i1, !llvm.float
%1 = spv.Select %arg0, %arg2, %arg2 : i1, f32 %1 = spv.Select %arg0, %arg2, %arg2 : i1, f32
spv.Return spv.Return
} }
// CHECK-LABEL: @select_vector // CHECK-LABEL: @select_vector
spv.func @select_vector(%arg0: vector<2xi1>, %arg1: vector<2xi32>) "None" { spv.func @select_vector(%arg0: vector<2xi1>, %arg1: vector<2xi32>) "None" {
// CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.vec<2 x i1>, !llvm.vec<2 x i32> // CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.vec<2 x i1>, !llvm.vec<2 x i32>
%0 = spv.Select %arg0, %arg1, %arg1 : vector<2xi1>, vector<2xi32> %0 = spv.Select %arg0, %arg1, %arg1 : vector<2xi1>, vector<2xi32>
spv.Return spv.Return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.EntryPoint and spv.ExecutionMode // spv.EntryPoint and spv.ExecutionMode
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: module { // CHECK: module {
// CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> { // CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32)> {
// CHECK-NEXT: %[[UNDEF:.*]] = llvm.mlir.undef : !llvm.struct<(i32)> // CHECK-NEXT: %[[UNDEF:.*]] = llvm.mlir.undef : !llvm.struct<(i32)>
// CHECK-NEXT: %[[VAL:.*]] = llvm.mlir.constant(31 : i32) : !llvm.i32 // CHECK-NEXT: %[[VAL:.*]] = llvm.mlir.constant(31 : i32) : i32
// CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[VAL]], %[[UNDEF]][0 : i32] : !llvm.struct<(i32)> // CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[VAL]], %[[UNDEF]][0 : i32] : !llvm.struct<(i32)>
// CHECK-NEXT: llvm.return %[[RET]] : !llvm.struct<(i32)> // CHECK-NEXT: llvm.return %[[RET]] : !llvm.struct<(i32)>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: llvm.func @empty // CHECK-NEXT: llvm.func @empty
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
spv.module Logical OpenCL { spv.module Logical OpenCL {
spv.func @empty() "None" { spv.func @empty() "None" {
spv.Return spv.Return
} }
spv.EntryPoint "Kernel" @empty spv.EntryPoint "Kernel" @empty
spv.ExecutionMode @empty "ContractionOff" spv.ExecutionMode @empty "ContractionOff"
} }
// CHECK: module { // CHECK: module {
// CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32, array<3 x i32>)> { // CHECK-NEXT: llvm.mlir.global external constant @{{.*}}() : !llvm.struct<(i32, array<3 x i32>)> {
// CHECK-NEXT: %[[UNDEF:.*]] = llvm.mlir.undef : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[UNDEF:.*]] = llvm.mlir.undef : !llvm.struct<(i32, array<3 x i32>)>
// CHECK-NEXT: %[[EM:.*]] = llvm.mlir.constant(18 : i32) : !llvm.i32 // CHECK-NEXT: %[[EM:.*]] = llvm.mlir.constant(18 : i32) : i32
// CHECK-NEXT: %[[T0:.*]] = llvm.insertvalue %[[EM]], %[[UNDEF]][0 : i32] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[T0:.*]] = llvm.insertvalue %[[EM]], %[[UNDEF]][0 : i32] : !llvm.struct<(i32, array<3 x i32>)>
// CHECK-NEXT: %[[C0:.*]] = llvm.mlir.constant(32 : i32) : !llvm.i32 // CHECK-NEXT: %[[C0:.*]] = llvm.mlir.constant(32 : i32) : i32
// CHECK-NEXT: %[[T1:.*]] = llvm.insertvalue %[[C0]], %[[T0]][1 : i32, 0 : i32] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[T1:.*]] = llvm.insertvalue %[[C0]], %[[T0]][1 : i32, 0 : i32] : !llvm.struct<(i32, array<3 x i32>)>
// CHECK-NEXT: %[[C1:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK-NEXT: %[[C1:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK-NEXT: %[[T2:.*]] = llvm.insertvalue %[[C1]], %[[T1]][1 : i32, 1 : i32] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[T2:.*]] = llvm.insertvalue %[[C1]], %[[T1]][1 : i32, 1 : i32] : !llvm.struct<(i32, array<3 x i32>)>
// CHECK-NEXT: %[[C2:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK-NEXT: %[[C2:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[C2]], %[[T2]][1 : i32, 2 : i32] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: %[[RET:.*]] = llvm.insertvalue %[[C2]], %[[T2]][1 : i32, 2 : i32] : !llvm.struct<(i32, array<3 x i32>)>
// CHECK-NEXT: llvm.return %[[RET]] : !llvm.struct<(i32, array<3 x i32>)> // CHECK-NEXT: llvm.return %[[RET]] : !llvm.struct<(i32, array<3 x i32>)>
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: llvm.func @bar // CHECK-NEXT: llvm.func @bar
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
spv.module Logical OpenCL { spv.module Logical OpenCL {
Show All 24 Lines

mlir/test/Conversion/SPIRVToLLVM/shift-ops-to-llvm.mlir

// RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ShiftRightArithmetic // spv.ShiftRightArithmetic
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @shift_right_arithmetic_scalar // CHECK-LABEL: @shift_right_arithmetic_scalar
spv.func @shift_right_arithmetic_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) "None" { spv.func @shift_right_arithmetic_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) "None" {
// CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.ashr %{{.*}}, %{{.*}} : i32
%0 = spv.ShiftRightArithmetic %arg0, %arg0 : i32, i32 %0 = spv.ShiftRightArithmetic %arg0, %arg0 : i32, i32
// CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.ashr %{{.*}}, %{{.*}} : i32
%1 = spv.ShiftRightArithmetic %arg0, %arg1 : i32, si32 %1 = spv.ShiftRightArithmetic %arg0, %arg1 : i32, si32
// CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32 // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : i16 to i32
// CHECK: llvm.ashr %{{.*}}, %[[SEXT]] : !llvm.i32 // CHECK: llvm.ashr %{{.*}}, %[[SEXT]] : i32
%2 = spv.ShiftRightArithmetic %arg0, %arg2 : i32, i16 %2 = spv.ShiftRightArithmetic %arg0, %arg2 : i32, i16
// CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32 // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : i16 to i32
// CHECK: llvm.ashr %{{.*}}, %[[ZEXT]] : !llvm.i32 // CHECK: llvm.ashr %{{.*}}, %[[ZEXT]] : i32
%3 = spv.ShiftRightArithmetic %arg0, %arg3 : i32, ui16 %3 = spv.ShiftRightArithmetic %arg0, %arg3 : i32, ui16
spv.Return spv.Return
} }
// CHECK-LABEL: @shift_right_arithmetic_vector // CHECK-LABEL: @shift_right_arithmetic_vector
spv.func @shift_right_arithmetic_vector(%arg0: vector<4xi64>, %arg1: vector<4xui64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) "None" { spv.func @shift_right_arithmetic_vector(%arg0: vector<4xi64>, %arg1: vector<4xui64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) "None" {
// CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64> // CHECK: llvm.ashr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
%0 = spv.ShiftRightArithmetic %arg0, %arg0 : vector<4xi64>, vector<4xi64> %0 = spv.ShiftRightArithmetic %arg0, %arg0 : vector<4xi64>, vector<4xi64>
Show All 12 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ShiftRightLogical // spv.ShiftRightLogical
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @shift_right_logical_scalar // CHECK-LABEL: @shift_right_logical_scalar
spv.func @shift_right_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : si16, %arg3 : ui16) "None" { spv.func @shift_right_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : si16, %arg3 : ui16) "None" {
// CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.lshr %{{.*}}, %{{.*}} : i32
%0 = spv.ShiftRightLogical %arg0, %arg0 : i32, i32 %0 = spv.ShiftRightLogical %arg0, %arg0 : i32, i32
// CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.lshr %{{.*}}, %{{.*}} : i32
%1 = spv.ShiftRightLogical %arg0, %arg1 : i32, si32 %1 = spv.ShiftRightLogical %arg0, %arg1 : i32, si32
// CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32 // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : i16 to i32
// CHECK: llvm.lshr %{{.*}}, %[[SEXT]] : !llvm.i32 // CHECK: llvm.lshr %{{.*}}, %[[SEXT]] : i32
%2 = spv.ShiftRightLogical %arg0, %arg2 : i32, si16 %2 = spv.ShiftRightLogical %arg0, %arg2 : i32, si16
// CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32 // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : i16 to i32
// CHECK: llvm.lshr %{{.*}}, %[[ZEXT]] : !llvm.i32 // CHECK: llvm.lshr %{{.*}}, %[[ZEXT]] : i32
%3 = spv.ShiftRightLogical %arg0, %arg3 : i32, ui16 %3 = spv.ShiftRightLogical %arg0, %arg3 : i32, ui16
spv.Return spv.Return
} }
// CHECK-LABEL: @shift_right_logical_vector // CHECK-LABEL: @shift_right_logical_vector
spv.func @shift_right_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) "None" { spv.func @shift_right_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) "None" {
// CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64> // CHECK: llvm.lshr %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
%0 = spv.ShiftRightLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64> %0 = spv.ShiftRightLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64>
Show All 12 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ShiftLeftLogical // spv.ShiftLeftLogical
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @shift_left_logical_scalar // CHECK-LABEL: @shift_left_logical_scalar
spv.func @shift_left_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) "None" { spv.func @shift_left_logical_scalar(%arg0: i32, %arg1: si32, %arg2 : i16, %arg3 : ui16) "None" {
// CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.shl %{{.*}}, %{{.*}} : i32
%0 = spv.ShiftLeftLogical %arg0, %arg0 : i32, i32 %0 = spv.ShiftLeftLogical %arg0, %arg0 : i32, i32
// CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: llvm.shl %{{.*}}, %{{.*}} : i32
%1 = spv.ShiftLeftLogical %arg0, %arg1 : i32, si32 %1 = spv.ShiftLeftLogical %arg0, %arg1 : i32, si32
// CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : !llvm.i16 to !llvm.i32 // CHECK: %[[SEXT:.*]] = llvm.sext %{{.*}} : i16 to i32
// CHECK: llvm.shl %{{.*}}, %[[SEXT]] : !llvm.i32 // CHECK: llvm.shl %{{.*}}, %[[SEXT]] : i32
%2 = spv.ShiftLeftLogical %arg0, %arg2 : i32, i16 %2 = spv.ShiftLeftLogical %arg0, %arg2 : i32, i16
// CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : !llvm.i16 to !llvm.i32 // CHECK: %[[ZEXT:.*]] = llvm.zext %{{.*}} : i16 to i32
// CHECK: llvm.shl %{{.*}}, %[[ZEXT]] : !llvm.i32 // CHECK: llvm.shl %{{.*}}, %[[ZEXT]] : i32
%3 = spv.ShiftLeftLogical %arg0, %arg3 : i32, ui16 %3 = spv.ShiftLeftLogical %arg0, %arg3 : i32, ui16
spv.Return spv.Return
} }
// CHECK-LABEL: @shift_left_logical_vector // CHECK-LABEL: @shift_left_logical_vector
spv.func @shift_left_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) "None" { spv.func @shift_left_logical_vector(%arg0: vector<4xi64>, %arg1: vector<4xsi64>, %arg2: vector<4xi32>, %arg3: vector<4xui32>) "None" {
// CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.vec<4 x i64> // CHECK: llvm.shl %{{.*}}, %{{.*}} : !llvm.vec<4 x i64>
%0 = spv.ShiftLeftLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64> %0 = spv.ShiftLeftLogical %arg0, %arg0 : vector<4xi64>, vector<4xi64>
Show All 13 Lines

mlir/test/Conversion/StandardToLLVM/calling-convention.mlir

// RUN: mlir-opt -convert-std-to-llvm='emit-c-wrappers=1' %s | FileCheck %s // RUN: mlir-opt -convert-std-to-llvm='emit-c-wrappers=1' %s | FileCheck %s
// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE // RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s --check-prefix=EMIT_C_ATTRIBUTE
// This tests the default memref calling convention and the emission of C // This tests the default memref calling convention and the emission of C
// wrappers. We don't need to separate runs because the wrapper-emission // wrappers. We don't need to separate runs because the wrapper-emission
// version subsumes the calling convention and only adds new functions, that we // version subsumes the calling convention and only adds new functions, that we
// can also file-check in the same run. // can also file-check in the same run.
// An external function is transformed into the glue around calling an interface function. // An external function is transformed into the glue around calling an interface function.
// CHECK-LABEL: @external // CHECK-LABEL: @external
// CHECK: %[[ALLOC0:.*]]: !llvm.ptr<float>, %[[ALIGN0:.*]]: !llvm.ptr<float>, %[[OFFSET0:.*]]: !llvm.i64, %[[SIZE00:.*]]: !llvm.i64, %[[SIZE01:.*]]: !llvm.i64, %[[STRIDE00:.*]]: !llvm.i64, %[[STRIDE01:.*]]: !llvm.i64, // CHECK: %[[ALLOC0:.*]]: !llvm.ptr<float>, %[[ALIGN0:.*]]: !llvm.ptr<float>, %[[OFFSET0:.*]]: i64, %[[SIZE00:.*]]: i64, %[[SIZE01:.*]]: i64, %[[STRIDE00:.*]]: i64, %[[STRIDE01:.*]]: i64,
// CHECK: %[[ALLOC1:.*]]: !llvm.ptr<float>, %[[ALIGN1:.*]]: !llvm.ptr<float>, %[[OFFSET1:.*]]: !llvm.i64) // CHECK: %[[ALLOC1:.*]]: !llvm.ptr<float>, %[[ALIGN1:.*]]: !llvm.ptr<float>, %[[OFFSET1:.*]]: i64)
func private @external(%arg0: memref<?x?xf32>, %arg1: memref<f32>) func private @external(%arg0: memref<?x?xf32>, %arg1: memref<f32>)
// Populate the descriptor for arg0. // Populate the descriptor for arg0.
// CHECK: %[[DESC00:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC00:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC01:.*]] = llvm.insertvalue %arg0, %[[DESC00]][0] // CHECK: %[[DESC01:.*]] = llvm.insertvalue %arg0, %[[DESC00]][0]
// CHECK: %[[DESC02:.*]] = llvm.insertvalue %arg1, %[[DESC01]][1] // CHECK: %[[DESC02:.*]] = llvm.insertvalue %arg1, %[[DESC01]][1]
// CHECK: %[[DESC03:.*]] = llvm.insertvalue %arg2, %[[DESC02]][2] // CHECK: %[[DESC03:.*]] = llvm.insertvalue %arg2, %[[DESC02]][2]
// CHECK: %[[DESC04:.*]] = llvm.insertvalue %arg3, %[[DESC03]][3, 0] // CHECK: %[[DESC04:.*]] = llvm.insertvalue %arg3, %[[DESC03]][3, 0]
// CHECK: %[[DESC05:.*]] = llvm.insertvalue %arg5, %[[DESC04]][4, 0] // CHECK: %[[DESC05:.*]] = llvm.insertvalue %arg5, %[[DESC04]][4, 0]
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesfunc @caller() {
// CHECK: %[[STRIDE01:.*]] = llvm.extractvalue %[[DESC0]][4, 1] // CHECK: %[[STRIDE01:.*]] = llvm.extractvalue %[[DESC0]][4, 1]
// Extract individual values from the descriptor for the second memref. // Extract individual values from the descriptor for the second memref.
// CHECK: %[[ALLOC1:.*]] = llvm.extractvalue %[[DESC1:.*]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: %[[ALLOC1:.*]] = llvm.extractvalue %[[DESC1:.*]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: %[[ALIGN1:.*]] = llvm.extractvalue %[[DESC1]][1] // CHECK: %[[ALIGN1:.*]] = llvm.extractvalue %[[DESC1]][1]
// CHECK: %[[OFFSET1:.*]] = llvm.extractvalue %[[DESC1]][2] // CHECK: %[[OFFSET1:.*]] = llvm.extractvalue %[[DESC1]][2]
// Forward the values to the call. // Forward the values to the call.
// CHECK: llvm.call @external(%[[ALLOC0]], %[[ALIGN0]], %[[OFFSET0]], %[[SIZE00]], %[[SIZE01]], %[[STRIDE00]], %[[STRIDE01]], %[[ALLOC1]], %[[ALIGN1]], %[[OFFSET1]]) : (!llvm.ptr<float>, !llvm.ptr<float>, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.ptr<float>, !llvm.ptr<float>, !llvm.i64) -> () // CHECK: llvm.call @external(%[[ALLOC0]], %[[ALIGN0]], %[[OFFSET0]], %[[SIZE00]], %[[SIZE01]], %[[STRIDE00]], %[[STRIDE01]], %[[ALLOC1]], %[[ALIGN1]], %[[OFFSET1]]) : (!llvm.ptr<float>, !llvm.ptr<float>, i64, i64, i64, i64, i64, !llvm.ptr<float>, !llvm.ptr<float>, i64) -> ()
call @external(%0#0, %0#1) : (memref<?x?xf32>, memref<f32>) -> () call @external(%0#0, %0#1) : (memref<?x?xf32>, memref<f32>) -> ()
return return
} }
// CHECK-LABEL: @callee // CHECK-LABEL: @callee
// EMIT_C_ATTRIBUTE-LABEL: @callee // EMIT_C_ATTRIBUTE-LABEL: @callee
func @callee(%arg0: memref<?xf32>, %arg1: index) { func @callee(%arg0: memref<?xf32>, %arg1: index) {
%0 = load %arg0[%arg1] : memref<?xf32> %0 = load %arg0[%arg1] : memref<?xf32>
Show All 9 Lines// CHECK: %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>>
// Extract individual components of the descriptor. // Extract individual components of the descriptor.
// CHECK: %[[ALLOC:.*]] = llvm.extractvalue %[[DESC]][0] // CHECK: %[[ALLOC:.*]] = llvm.extractvalue %[[DESC]][0]
// CHECK: %[[ALIGN:.*]] = llvm.extractvalue %[[DESC]][1] // CHECK: %[[ALIGN:.*]] = llvm.extractvalue %[[DESC]][1]
// CHECK: %[[OFFSET:.*]] = llvm.extractvalue %[[DESC]][2] // CHECK: %[[OFFSET:.*]] = llvm.extractvalue %[[DESC]][2]
// CHECK: %[[SIZE:.*]] = llvm.extractvalue %[[DESC]][3, 0] // CHECK: %[[SIZE:.*]] = llvm.extractvalue %[[DESC]][3, 0]
// CHECK: %[[STRIDE:.*]] = llvm.extractvalue %[[DESC]][4, 0] // CHECK: %[[STRIDE:.*]] = llvm.extractvalue %[[DESC]][4, 0]
// Forward the descriptor components to the call. // Forward the descriptor components to the call.
// CHECK: llvm.call @callee(%[[ALLOC]], %[[ALIGN]], %[[OFFSET]], %[[SIZE]], %[[STRIDE]], %{{.*}}) : (!llvm.ptr<float>, !llvm.ptr<float>, !llvm.i64, !llvm.i64, !llvm.i64, !llvm.i64) -> () // CHECK: llvm.call @callee(%[[ALLOC]], %[[ALIGN]], %[[OFFSET]], %[[SIZE]], %[[STRIDE]], %{{.*}}) : (!llvm.ptr<float>, !llvm.ptr<float>, i64, i64, i64, i64) -> ()
// EMIT_C_ATTRIBUTE-NOT: @mlir_ciface_callee // EMIT_C_ATTRIBUTE-NOT: @mlir_ciface_callee
// CHECK-LABEL: @other_callee // CHECK-LABEL: @other_callee
// EMIT_C_ATTRIBUTE-LABEL: @other_callee // EMIT_C_ATTRIBUTE-LABEL: @other_callee
func @other_callee(%arg0: memref<?xf32>, %arg1: index) attributes { llvm.emit_c_interface } { func @other_callee(%arg0: memref<?xf32>, %arg1: index) attributes { llvm.emit_c_interface } {
%0 = load %arg0[%arg1] : memref<?xf32> %0 = load %arg0[%arg1] : memref<?xf32>
return return
Show All 22 Linesfunc @return_var_memref_caller(%arg0: memref<4x3xf32>) {
// CHECK: %[[DOUBLE_PTR_SIZE:.*]] = llvm.mul %[[TWO]], %[[PTR_SIZE]] // CHECK: %[[DOUBLE_PTR_SIZE:.*]] = llvm.mul %[[TWO]], %[[PTR_SIZE]]
// CHECK: %[[RANK:.*]] = llvm.extractvalue %[[CALL_RES]][0] : !llvm.struct<(i64, ptr<i8>)> // CHECK: %[[RANK:.*]] = llvm.extractvalue %[[CALL_RES]][0] : !llvm.struct<(i64, ptr<i8>)>
// CHECK: %[[DOUBLE_RANK:.*]] = llvm.mul %[[TWO]], %[[RANK]] // CHECK: %[[DOUBLE_RANK:.*]] = llvm.mul %[[TWO]], %[[RANK]]
// CHECK: %[[DOUBLE_RANK_INC:.*]] = llvm.add %[[DOUBLE_RANK]], %[[ONE]] // CHECK: %[[DOUBLE_RANK_INC:.*]] = llvm.add %[[DOUBLE_RANK]], %[[ONE]]
// CHECK: %[[TABLES_SIZE:.*]] = llvm.mul %[[DOUBLE_RANK_INC]], %[[IDX_SIZE]] // CHECK: %[[TABLES_SIZE:.*]] = llvm.mul %[[DOUBLE_RANK_INC]], %[[IDX_SIZE]]
// CHECK: %[[ALLOC_SIZE:.*]] = llvm.add %[[DOUBLE_PTR_SIZE]], %[[TABLES_SIZE]] // CHECK: %[[ALLOC_SIZE:.*]] = llvm.add %[[DOUBLE_PTR_SIZE]], %[[TABLES_SIZE]]
// CHECK: %[[FALSE:.*]] = llvm.mlir.constant(false) // CHECK: %[[FALSE:.*]] = llvm.mlir.constant(false)
// CHECK: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOC_SIZE]] x !llvm.i8 // CHECK: %[[ALLOCA:.*]] = llvm.alloca %[[ALLOC_SIZE]] x i8
// CHECK: %[[SOURCE:.*]] = llvm.extractvalue %[[CALL_RES]][1] // CHECK: %[[SOURCE:.*]] = llvm.extractvalue %[[CALL_RES]][1]
// CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[SOURCE]], %[[ALLOC_SIZE]], %[[FALSE]]) // CHECK: "llvm.intr.memcpy"(%[[ALLOCA]], %[[SOURCE]], %[[ALLOC_SIZE]], %[[FALSE]])
// CHECK: llvm.call @free(%[[SOURCE]]) // CHECK: llvm.call @free(%[[SOURCE]])
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)> // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK: %[[RANK:.*]] = llvm.extractvalue %[[CALL_RES]][0] : !llvm.struct<(i64, ptr<i8>)> // CHECK: %[[RANK:.*]] = llvm.extractvalue %[[CALL_RES]][0] : !llvm.struct<(i64, ptr<i8>)>
// CHECK: %[[DESC_1:.*]] = llvm.insertvalue %[[RANK]], %[[DESC]][0] // CHECK: %[[DESC_1:.*]] = llvm.insertvalue %[[RANK]], %[[DESC]][0]
// CHECK: llvm.insertvalue %[[ALLOCA]], %[[DESC_1]][1] // CHECK: llvm.insertvalue %[[ALLOCA]], %[[DESC_1]][1]
return return
Show All 38 Linesfunc @return_two_var_memref_caller(%arg0: memref<4x3xf32>) {
// Only check that we create two different descriptors using different // Only check that we create two different descriptors using different
// memory, and deallocate both sources. The size computation is same as for // memory, and deallocate both sources. The size computation is same as for
// the single result. // the single result.
// CHECK: %[[CALL_RES:.*]] = llvm.call @return_two_var_memref // CHECK: %[[CALL_RES:.*]] = llvm.call @return_two_var_memref
// CHECK: %[[RES_1:.*]] = llvm.extractvalue %[[CALL_RES]][0] // CHECK: %[[RES_1:.*]] = llvm.extractvalue %[[CALL_RES]][0]
// CHECK: %[[RES_2:.*]] = llvm.extractvalue %[[CALL_RES]][1] // CHECK: %[[RES_2:.*]] = llvm.extractvalue %[[CALL_RES]][1]
%0:2 = call @return_two_var_memref(%arg0) : (memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>) %0:2 = call @return_two_var_memref(%arg0) : (memref<4x3xf32>) -> (memref<*xf32>, memref<*xf32>)
// CHECK: %[[ALLOCA_1:.*]] = llvm.alloca %{{.*}} x !llvm.i8 // CHECK: %[[ALLOCA_1:.*]] = llvm.alloca %{{.*}} x i8
// CHECK: %[[SOURCE_1:.*]] = llvm.extractvalue %[[RES_1:.*]][1] : ![[DESC_TYPE:.*]] // CHECK: %[[SOURCE_1:.*]] = llvm.extractvalue %[[RES_1:.*]][1] : ![[DESC_TYPE:.*]]
// CHECK: "llvm.intr.memcpy"(%[[ALLOCA_1]], %[[SOURCE_1]], %{{.*}}, %[[FALSE:.*]]) // CHECK: "llvm.intr.memcpy"(%[[ALLOCA_1]], %[[SOURCE_1]], %{{.*}}, %[[FALSE:.*]])
// CHECK: llvm.call @free(%[[SOURCE_1]]) // CHECK: llvm.call @free(%[[SOURCE_1]])
// CHECK: %[[DESC_1:.*]] = llvm.mlir.undef : ![[DESC_TYPE]] // CHECK: %[[DESC_1:.*]] = llvm.mlir.undef : ![[DESC_TYPE]]
// CHECK: %[[DESC_11:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_1]][0] // CHECK: %[[DESC_11:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_1]][0]
// CHECK: llvm.insertvalue %[[ALLOCA_1]], %[[DESC_11]][1] // CHECK: llvm.insertvalue %[[ALLOCA_1]], %[[DESC_11]][1]
// CHECK: %[[ALLOCA_2:.*]] = llvm.alloca %{{.*}} x !llvm.i8 // CHECK: %[[ALLOCA_2:.*]] = llvm.alloca %{{.*}} x i8
// CHECK: %[[SOURCE_2:.*]] = llvm.extractvalue %[[RES_2:.*]][1] // CHECK: %[[SOURCE_2:.*]] = llvm.extractvalue %[[RES_2:.*]][1]
// CHECK: "llvm.intr.memcpy"(%[[ALLOCA_2]], %[[SOURCE_2]], %{{.*}}, %[[FALSE]]) // CHECK: "llvm.intr.memcpy"(%[[ALLOCA_2]], %[[SOURCE_2]], %{{.*}}, %[[FALSE]])
// CHECK: llvm.call @free(%[[SOURCE_2]]) // CHECK: llvm.call @free(%[[SOURCE_2]])
// CHECK: %[[DESC_2:.*]] = llvm.mlir.undef : ![[DESC_TYPE]] // CHECK: %[[DESC_2:.*]] = llvm.mlir.undef : ![[DESC_TYPE]]
// CHECK: %[[DESC_21:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_2]][0] // CHECK: %[[DESC_21:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_2]][0]
// CHECK: llvm.insertvalue %[[ALLOCA_2]], %[[DESC_21]][1] // CHECK: llvm.insertvalue %[[ALLOCA_2]], %[[DESC_21]][1]
return return
} }
Show All 36 Lines

mlir/test/Conversion/StandardToLLVM/convert-argattrs.mlir

// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s
// CHECK-LABEL: func @check_attributes // CHECK-LABEL: func @check_attributes
// When expanding the memref to multiple arguments, argument attributes are replicated. // When expanding the memref to multiple arguments, argument attributes are replicated.
// CHECK-COUNT-7: {dialect.a = true, dialect.b = 4 : i64} // CHECK-COUNT-7: {dialect.a = true, dialect.b = 4 : i64}
func @check_attributes(%static: memref<10x20xf32> {dialect.a = true, dialect.b = 4 : i64 }) { func @check_attributes(%static: memref<10x20xf32> {dialect.a = true, dialect.b = 4 : i64 }) {
%c0 = constant 0 : index %c0 = constant 0 : index
%0 = load %static[%c0, %c0]: memref<10x20xf32> %0 = load %static[%c0, %c0]: memref<10x20xf32>
return return
} }
// CHECK-LABEL: func @check_multiple // CHECK-LABEL: func @check_multiple
// Make sure arguments attributes are attached to the right argument. We match // Make sure arguments attributes are attached to the right argument. We match
// commas in the argument list for this purpose. // commas in the argument list for this purpose.
// CHECK: %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: !llvm{{.*}} {first.arg = true}, // CHECK: %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: !llvm{{.*}} {first.arg = true}, %{{.*}}: i{{.*}} {first.arg = true},
// CHECK-SAME: %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}) // CHECK-SAME: %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: !llvm{{.*}} {second.arg = 42 : i32}, %{{.*}}: i{{.*}} {second.arg = 42 : i32})
func @check_multiple(%first: memref<f32> {first.arg = true}, %second: memref<f32> {second.arg = 42 : i32}) { func @check_multiple(%first: memref<f32> {first.arg = true}, %second: memref<f32> {second.arg = 42 : i32}) {
return return
} }

mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir

// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s
// RUN: mlir-opt -convert-std-to-llvm='use-aligned-alloc=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC // RUN: mlir-opt -convert-std-to-llvm='use-aligned-alloc=1' %s | FileCheck %s --check-prefix=ALIGNED-ALLOC
// CHECK-LABEL: func @check_strided_memref_arguments( // CHECK-LABEL: func @check_strided_memref_arguments(
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
func @check_strided_memref_arguments(%static: memref<10x20xf32, affine_map<(i,j)->(20 * i + j + 1)>>, func @check_strided_memref_arguments(%static: memref<10x20xf32, affine_map<(i,j)->(20 * i + j + 1)>>,
%dynamic : memref<?x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>, %dynamic : memref<?x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>,
%mixed : memref<10x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>) { %mixed : memref<10x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>) {
return return
} }
// CHECK-LABEL: func @check_arguments // CHECK-LABEL: func @check_arguments
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
func @check_arguments(%static: memref<10x20xf32>, %dynamic : memref<?x?xf32>, %mixed : memref<10x?xf32>) { func @check_arguments(%static: memref<10x20xf32>, %dynamic : memref<?x?xf32>, %mixed : memref<10x?xf32>) {
return return
} }
// CHECK-LABEL: func @mixed_alloc( // CHECK-LABEL: func @mixed_alloc(
// CHECK: %[[M:.*]]: !llvm.i64, %[[N:.*]]: !llvm.i64) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> { // CHECK: %[[M:.*]]: i64, %[[N:.*]]: i64) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> {
func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> { func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> {
// CHECK: %[[c42:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK: %[[c42:.*]] = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[st0:.*]] = llvm.mul %[[N]], %[[c42]] : !llvm.i64 // CHECK-NEXT: %[[st0:.*]] = llvm.mul %[[N]], %[[c42]] : i64
// CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[st0]], %[[M]] : !llvm.i64 // CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[st0]], %[[M]] : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (!llvm.i64) -> !llvm.ptr<i8> // CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
// CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[c42]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[c42]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
%0 = alloc(%arg0, %arg1) : memref<?x42x?xf32> %0 = alloc(%arg0, %arg1) : memref<?x42x?xf32>
// CHECK-NEXT: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK-NEXT: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
return %0 : memref<?x42x?xf32> return %0 : memref<?x42x?xf32>
} }
// CHECK-LABEL: func @mixed_dealloc // CHECK-LABEL: func @mixed_dealloc
func @mixed_dealloc(%arg0: memref<?x42x?xf32>) { func @mixed_dealloc(%arg0: memref<?x42x?xf32>) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<float> to !llvm.ptr<i8> // CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<float> to !llvm.ptr<i8>
// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> () // CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
dealloc %arg0 : memref<?x42x?xf32> dealloc %arg0 : memref<?x42x?xf32>
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
return return
} }
// CHECK-LABEL: func @dynamic_alloc( // CHECK-LABEL: func @dynamic_alloc(
// CHECK: %[[M:.*]]: !llvm.i64, %[[N:.*]]: !llvm.i64) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> { // CHECK: %[[M:.*]]: i64, %[[N:.*]]: i64) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> {
func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> { func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
// CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[N]], %[[M]] : !llvm.i64 // CHECK-NEXT: %[[sz:.*]] = llvm.mul %[[N]], %[[M]] : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (!llvm.i64) -> !llvm.ptr<i8> // CHECK-NEXT: llvm.call @malloc(%[[sz_bytes]]) : (i64) -> !llvm.ptr<i8>
// CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK-NEXT: llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
%0 = alloc(%arg0, %arg1) : memref<?x?xf32> %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
// CHECK-NEXT: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
return %0 : memref<?x?xf32> return %0 : memref<?x?xf32>
} }
// ----- // -----
// CHECK-LABEL: func @dynamic_alloca // CHECK-LABEL: func @dynamic_alloca
// CHECK: %[[M:.*]]: !llvm.i64, %[[N:.*]]: !llvm.i64) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> { // CHECK: %[[M:.*]]: i64, %[[N:.*]]: i64) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> {
func @dynamic_alloca(%arg0: index, %arg1: index) -> memref<?x?xf32> { func @dynamic_alloca(%arg0: index, %arg1: index) -> memref<?x?xf32> {
// CHECK-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[num_elems:.*]] = llvm.mul %[[N]], %[[M]] : !llvm.i64 // CHECK-NEXT: %[[num_elems:.*]] = llvm.mul %[[N]], %[[M]] : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[sz_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: %[[allocated:.*]] = llvm.alloca %[[sz_bytes]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[allocated:.*]] = llvm.alloca %[[sz_bytes]] x !llvm.float : (i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[allocated]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[allocated]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[allocated]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[allocated]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[off:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[off]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[M]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[st1]], %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[st1]], %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
%0 = alloca(%arg0, %arg1) : memref<?x?xf32> %0 = alloca(%arg0, %arg1) : memref<?x?xf32>
// Test with explicitly specified alignment. llvm.alloca takes care of the // Test with explicitly specified alignment. llvm.alloca takes care of the
// alignment. The same pointer is thus used for allocation and aligned // alignment. The same pointer is thus used for allocation and aligned
// accesses. // accesses.
// CHECK: %[[alloca_aligned:.*]] = llvm.alloca %{{.*}} x !llvm.float {alignment = 32 : i64} : (!llvm.i64) -> !llvm.ptr<float> // CHECK: %[[alloca_aligned:.*]] = llvm.alloca %{{.*}} x !llvm.float {alignment = 32 : i64} : (i64) -> !llvm.ptr<float>
// CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
alloca(%arg0, %arg1) {alignment = 32} : memref<?x?xf32> alloca(%arg0, %arg1) {alignment = 32} : memref<?x?xf32>
return %0 : memref<?x?xf32> return %0 : memref<?x?xf32>
} }
// CHECK-LABEL: func @dynamic_dealloc // CHECK-LABEL: func @dynamic_dealloc
func @dynamic_dealloc(%arg0: memref<?x?xf32>) { func @dynamic_dealloc(%arg0: memref<?x?xf32>) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<float> to !llvm.ptr<i8> // CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<float> to !llvm.ptr<i8>
// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> () // CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
dealloc %arg0 : memref<?x?xf32> dealloc %arg0 : memref<?x?xf32>
return return
} }
// CHECK-LABEL: func @stdlib_aligned_alloc({{.*}}) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> { // CHECK-LABEL: func @stdlib_aligned_alloc({{.*}}) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> {
// ALIGNED-ALLOC-LABEL: func @stdlib_aligned_alloc({{.*}}) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> { // ALIGNED-ALLOC-LABEL: func @stdlib_aligned_alloc({{.*}}) -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> {
func @stdlib_aligned_alloc(%N : index) -> memref<32x18xf32> { func @stdlib_aligned_alloc(%N : index) -> memref<32x18xf32> {
// ALIGNED-ALLOC-NEXT: %[[sz1:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // ALIGNED-ALLOC-NEXT: %[[sz1:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: %[[sz2:.*]] = llvm.mlir.constant(18 : index) : !llvm.i64 // ALIGNED-ALLOC-NEXT: %[[sz2:.*]] = llvm.mlir.constant(18 : index) : i64
// ALIGNED-ALLOC-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // ALIGNED-ALLOC-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
// ALIGNED-ALLOC-NEXT: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : !llvm.i64 // ALIGNED-ALLOC-NEXT: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
// ALIGNED-ALLOC-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // ALIGNED-ALLOC-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// ALIGNED-ALLOC-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // ALIGNED-ALLOC-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// ALIGNED-ALLOC-NEXT: %[[bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // ALIGNED-ALLOC-NEXT: %[[bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// ALIGNED-ALLOC-NEXT: %[[alignment:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // ALIGNED-ALLOC-NEXT: %[[alignment:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: %[[allocated:.*]] = llvm.call @aligned_alloc(%[[alignment]], %[[bytes]]) : (!llvm.i64, !llvm.i64) -> !llvm.ptr<i8> // ALIGNED-ALLOC-NEXT: %[[allocated:.*]] = llvm.call @aligned_alloc(%[[alignment]], %[[bytes]]) : (i64, i64) -> !llvm.ptr<i8>
// ALIGNED-ALLOC-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<float> // ALIGNED-ALLOC-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<float>
%0 = alloc() {alignment = 32} : memref<32x18xf32> %0 = alloc() {alignment = 32} : memref<32x18xf32>
// Do another alloc just to test that we have a unique declaration for // Do another alloc just to test that we have a unique declaration for
// aligned_alloc. // aligned_alloc.
// ALIGNED-ALLOC: llvm.call @aligned_alloc // ALIGNED-ALLOC: llvm.call @aligned_alloc
%1 = alloc() {alignment = 64} : memref<4096xf32> %1 = alloc() {alignment = 64} : memref<4096xf32>
// Alignment is to element type boundaries (minimum 16 bytes). // Alignment is to element type boundaries (minimum 16 bytes).
// ALIGNED-ALLOC: %[[c32:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // ALIGNED-ALLOC: %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c32]] // ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c32]]
%2 = alloc() : memref<4096xvector<8xf32>> %2 = alloc() : memref<4096xvector<8xf32>>
// The minimum alignment is 16 bytes unless explicitly specified. // The minimum alignment is 16 bytes unless explicitly specified.
// ALIGNED-ALLOC: %[[c16:.*]] = llvm.mlir.constant(16 : index) : !llvm.i64 // ALIGNED-ALLOC: %[[c16:.*]] = llvm.mlir.constant(16 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c16]], // ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c16]],
%3 = alloc() : memref<4096xvector<2xf32>> %3 = alloc() : memref<4096xvector<2xf32>>
// ALIGNED-ALLOC: %[[c8:.*]] = llvm.mlir.constant(8 : index) : !llvm.i64 // ALIGNED-ALLOC: %[[c8:.*]] = llvm.mlir.constant(8 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c8]], // ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c8]],
%4 = alloc() {alignment = 8} : memref<1024xvector<4xf32>> %4 = alloc() {alignment = 8} : memref<1024xvector<4xf32>>
// Bump the memref allocation size if its size is not a multiple of alignment. // Bump the memref allocation size if its size is not a multiple of alignment.
// ALIGNED-ALLOC: %[[c32:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // ALIGNED-ALLOC: %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64 // ALIGNED-ALLOC-NEXT: llvm.mlir.constant(1 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.sub // ALIGNED-ALLOC-NEXT: llvm.sub
// ALIGNED-ALLOC-NEXT: llvm.add // ALIGNED-ALLOC-NEXT: llvm.add
// ALIGNED-ALLOC-NEXT: llvm.urem // ALIGNED-ALLOC-NEXT: llvm.urem
// ALIGNED-ALLOC-NEXT: %[[SIZE_ALIGNED:.*]] = llvm.sub // ALIGNED-ALLOC-NEXT: %[[SIZE_ALIGNED:.*]] = llvm.sub
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c32]], %[[SIZE_ALIGNED]]) // ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c32]], %[[SIZE_ALIGNED]])
%5 = alloc() {alignment = 32} : memref<100xf32> %5 = alloc() {alignment = 32} : memref<100xf32>
// Bump alignment to the next power of two if it isn't. // Bump alignment to the next power of two if it isn't.
// ALIGNED-ALLOC: %[[c128:.*]] = llvm.mlir.constant(128 : index) : !llvm.i64 // ALIGNED-ALLOC: %[[c128:.*]] = llvm.mlir.constant(128 : index) : i64
// ALIGNED-ALLOC: llvm.call @aligned_alloc(%[[c128]] // ALIGNED-ALLOC: llvm.call @aligned_alloc(%[[c128]]
%6 = alloc(%N) : memref<?xvector<18xf32>> %6 = alloc(%N) : memref<?xvector<18xf32>>
return %0 : memref<32x18xf32> return %0 : memref<32x18xf32>
} }
// CHECK-LABEL: func @mixed_load( // CHECK-LABEL: func @mixed_load(
// CHECK-COUNT-2: !llvm.ptr<float>, // CHECK-COUNT-2: !llvm.ptr<float>,
// CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i64 // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64
// CHECK: %[[I:.*]]: !llvm.i64, // CHECK: %[[I:.*]]: i64,
// CHECK: %[[J:.*]]: !llvm.i64) // CHECK: %[[J:.*]]: i64)
func @mixed_load(%mixed : memref<42x?xf32>, %i : index, %j : index) { func @mixed_load(%mixed : memref<42x?xf32>, %i : index, %j : index) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.load %[[addr]] : !llvm.ptr<float> // CHECK-NEXT: llvm.load %[[addr]] : !llvm.ptr<float>
%0 = load %mixed[%i, %j] : memref<42x?xf32> %0 = load %mixed[%i, %j] : memref<42x?xf32>
return return
} }
// CHECK-LABEL: func @dynamic_load( // CHECK-LABEL: func @dynamic_load(
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: i64
func @dynamic_load(%dynamic : memref<?x?xf32>, %i : index, %j : index) { func @dynamic_load(%dynamic : memref<?x?xf32>, %i : index, %j : index) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.load %[[addr]] : !llvm.ptr<float> // CHECK-NEXT: llvm.load %[[addr]] : !llvm.ptr<float>
%0 = load %dynamic[%i, %j] : memref<?x?xf32> %0 = load %dynamic[%i, %j] : memref<?x?xf32>
return return
} }
// CHECK-LABEL: func @prefetch // CHECK-LABEL: func @prefetch
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: i64
func @prefetch(%A : memref<?x?xf32>, %i : index, %j : index) { func @prefetch(%A : memref<?x?xf32>, %i : index, %j : index) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: [[C1:%.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK-NEXT: [[C1:%.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK-NEXT: [[C3:%.*]] = llvm.mlir.constant(3 : i32) : !llvm.i32 // CHECK-NEXT: [[C3:%.*]] = llvm.mlir.constant(3 : i32) : i32
// CHECK-NEXT: [[C1_1:%.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK-NEXT: [[C1_1:%.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK-NEXT: "llvm.intr.prefetch"(%[[addr]], [[C1]], [[C3]], [[C1_1]]) : (!llvm.ptr<float>, !llvm.i32, !llvm.i32, !llvm.i32) -> () // CHECK-NEXT: "llvm.intr.prefetch"(%[[addr]], [[C1]], [[C3]], [[C1_1]]) : (!llvm.ptr<float>, i32, i32, i32) -> ()
prefetch %A[%i, %j], write, locality<3>, data : memref<?x?xf32> prefetch %A[%i, %j], write, locality<3>, data : memref<?x?xf32>
// CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: [[C0_1:%.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: [[C0_1:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: [[C1_2:%.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: [[C1_2:%.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: "llvm.intr.prefetch"(%{{.*}}, [[C0]], [[C0_1]], [[C1_2]]) : (!llvm.ptr<float>, !llvm.i32, !llvm.i32, !llvm.i32) -> () // CHECK: "llvm.intr.prefetch"(%{{.*}}, [[C0]], [[C0_1]], [[C1_2]]) : (!llvm.ptr<float>, i32, i32, i32) -> ()
prefetch %A[%i, %j], read, locality<0>, data : memref<?x?xf32> prefetch %A[%i, %j], read, locality<0>, data : memref<?x?xf32>
// CHECK: [[C0_2:%.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: [[C0_2:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : i32) : !llvm.i32 // CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : i32) : i32
// CHECK: [[C0_3:%.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: [[C0_3:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: "llvm.intr.prefetch"(%{{.*}}, [[C0_2]], [[C2]], [[C0_3]]) : (!llvm.ptr<float>, !llvm.i32, !llvm.i32, !llvm.i32) -> () // CHECK: "llvm.intr.prefetch"(%{{.*}}, [[C0_2]], [[C2]], [[C0_3]]) : (!llvm.ptr<float>, i32, i32, i32) -> ()
prefetch %A[%i, %j], read, locality<2>, instr : memref<?x?xf32> prefetch %A[%i, %j], read, locality<2>, instr : memref<?x?xf32>
return return
} }
// CHECK-LABEL: func @dynamic_store // CHECK-LABEL: func @dynamic_store
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: i64
func @dynamic_store(%dynamic : memref<?x?xf32>, %i : index, %j : index, %val : f32) { func @dynamic_store(%dynamic : memref<?x?xf32>, %i : index, %j : index, %val : f32) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float> // CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float>
store %val, %dynamic[%i, %j] : memref<?x?xf32> store %val, %dynamic[%i, %j] : memref<?x?xf32>
return return
} }
// CHECK-LABEL: func @mixed_store // CHECK-LABEL: func @mixed_store
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: i64
func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32) { func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %[[ld:.*]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-NEXT: %[[st0:.*]] = llvm.extractvalue %[[ld]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float> // CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float>
store %val, %mixed[%i, %j] : memref<42x?xf32> store %val, %mixed[%i, %j] : memref<42x?xf32>
return return
} }
// CHECK-LABEL: func @memref_cast_static_to_dynamic // CHECK-LABEL: func @memref_cast_static_to_dynamic
func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) { func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) {
// CHECK-NOT: llvm.bitcast // CHECK-NOT: llvm.bitcast
Show All 40 Lines
func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) { func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) {
// CHECK-NOT: llvm.bitcast // CHECK-NOT: llvm.bitcast
%0 = memref_cast %mixed : memref<42x?xf32> to memref<?x1xf32> %0 = memref_cast %mixed : memref<42x?xf32> to memref<?x1xf32>
return return
} }
// CHECK-LABEL: func @memref_cast_ranked_to_unranked // CHECK-LABEL: func @memref_cast_ranked_to_unranked
func @memref_cast_ranked_to_unranked(%arg : memref<42x2x?xf32>) { func @memref_cast_ranked_to_unranked(%arg : memref<42x2x?xf32>) {
// CHECK-DAG: %[[c:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-DAG: %[[c:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-DAG: %[[p:.*]] = llvm.alloca %[[c]] x !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> : (!llvm.i64) -> !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>> // CHECK-DAG: %[[p:.*]] = llvm.alloca %[[c]] x !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> : (i64) -> !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>>
// CHECK-DAG: llvm.store %{{.*}}, %[[p]] : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>> // CHECK-DAG: llvm.store %{{.*}}, %[[p]] : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>>
// CHECK-DAG: %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>> to !llvm.ptr<i8> // CHECK-DAG: %[[p2:.*]] = llvm.bitcast %[[p]] : !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>> to !llvm.ptr<i8>
// CHECK-DAG: %[[r:.*]] = llvm.mlir.constant(3 : i64) : !llvm.i64 // CHECK-DAG: %[[r:.*]] = llvm.mlir.constant(3 : i64) : i64
// CHECK : llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)> // CHECK : llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i64, ptr<i8>)> // CHECK-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i64, ptr<i8>)>
// CHECK-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)> // CHECK-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
%0 = memref_cast %arg : memref<42x2x?xf32> to memref<*xf32> %0 = memref_cast %arg : memref<42x2x?xf32> to memref<*xf32>
return return
} }
// CHECK-LABEL: func @memref_cast_unranked_to_ranked // CHECK-LABEL: func @memref_cast_unranked_to_ranked
func @memref_cast_unranked_to_ranked(%arg : memref<*xf32>) { func @memref_cast_unranked_to_ranked(%arg : memref<*xf32>) {
// CHECK: %[[p:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)> // CHECK: %[[p:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
// CHECK-NEXT: llvm.bitcast %[[p]] : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>> // CHECK-NEXT: llvm.bitcast %[[p]] : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>>
%0 = memref_cast %arg : memref<*xf32> to memref<?x?x10x2xf32> %0 = memref_cast %arg : memref<*xf32> to memref<?x?x10x2xf32>
return return
} }
// CHECK-LABEL: func @mixed_memref_dim // CHECK-LABEL: func @mixed_memref_dim
func @mixed_memref_dim(%mixed : memref<42x?x?x13x?xf32>) { func @mixed_memref_dim(%mixed : memref<42x?x?x13x?xf32>) {
// CHECK: llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(42 : index) : i64
%c0 = constant 0 : index %c0 = constant 0 : index
%0 = dim %mixed, %c0 : memref<42x?x?x13x?xf32> %0 = dim %mixed, %c0 : memref<42x?x?x13x?xf32>
// CHECK: llvm.extractvalue %[[ld:.*]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.extractvalue %[[ld:.*]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
%c1 = constant 1 : index %c1 = constant 1 : index
%1 = dim %mixed, %c1 : memref<42x?x?x13x?xf32> %1 = dim %mixed, %c1 : memref<42x?x?x13x?xf32>
// CHECK: llvm.extractvalue %[[ld]][3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.extractvalue %[[ld]][3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
%c2 = constant 2 : index %c2 = constant 2 : index
%2 = dim %mixed, %c2 : memref<42x?x?x13x?xf32> %2 = dim %mixed, %c2 : memref<42x?x?x13x?xf32>
// CHECK: llvm.mlir.constant(13 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(13 : index) : i64
%c3 = constant 3 : index %c3 = constant 3 : index
%3 = dim %mixed, %c3 : memref<42x?x?x13x?xf32> %3 = dim %mixed, %c3 : memref<42x?x?x13x?xf32>
// CHECK: llvm.extractvalue %[[ld]][3, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.extractvalue %[[ld]][3, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
%c4 = constant 4 : index %c4 = constant 4 : index
%4 = dim %mixed, %c4 : memref<42x?x?x13x?xf32> %4 = dim %mixed, %c4 : memref<42x?x?x13x?xf32>
return return
} }
// CHECK-LABEL: @memref_dim_with_dyn_index // CHECK-LABEL: @memref_dim_with_dyn_index
// CHECK-SAME: %[[ALLOC_PTR:.*]]: !llvm.ptr<float>, %[[ALIGN_PTR:.*]]: !llvm.ptr<float>, %[[OFFSET:.*]]: !llvm.i64, %[[SIZE0:.*]]: !llvm.i64, %[[SIZE1:.*]]: !llvm.i64, %[[STRIDE0:.*]]: !llvm.i64, %[[STRIDE1:.*]]: !llvm.i64, %[[IDX:.*]]: !llvm.i64) -> !llvm.i64 // CHECK-SAME: %[[ALLOC_PTR:.*]]: !llvm.ptr<float>, %[[ALIGN_PTR:.*]]: !llvm.ptr<float>, %[[OFFSET:.*]]: i64, %[[SIZE0:.*]]: i64, %[[SIZE1:.*]]: i64, %[[STRIDE0:.*]]: i64, %[[STRIDE1:.*]]: i64, %[[IDX:.*]]: i64) -> i64
func @memref_dim_with_dyn_index(%arg : memref<3x?xf32>, %idx : index) -> index { func @memref_dim_with_dyn_index(%arg : memref<3x?xf32>, %idx : index) -> index {
// CHECK-NEXT: %[[DESCR0:.*]] = llvm.mlir.undef : [[DESCR_TY:!llvm.struct<\(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>\)>]] // CHECK-NEXT: %[[DESCR0:.*]] = llvm.mlir.undef : [[DESCR_TY:!llvm.struct<\(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>\)>]]
// CHECK-NEXT: %[[DESCR1:.*]] = llvm.insertvalue %[[ALLOC_PTR]], %[[DESCR0]][0] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR1:.*]] = llvm.insertvalue %[[ALLOC_PTR]], %[[DESCR0]][0] : [[DESCR_TY]]
// CHECK-NEXT: %[[DESCR2:.*]] = llvm.insertvalue %[[ALIGN_PTR]], %[[DESCR1]][1] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR2:.*]] = llvm.insertvalue %[[ALIGN_PTR]], %[[DESCR1]][1] : [[DESCR_TY]]
// CHECK-NEXT: %[[DESCR3:.*]] = llvm.insertvalue %[[OFFSET]], %[[DESCR2]][2] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR3:.*]] = llvm.insertvalue %[[OFFSET]], %[[DESCR2]][2] : [[DESCR_TY]]
// CHECK-NEXT: %[[DESCR4:.*]] = llvm.insertvalue %[[SIZE0]], %[[DESCR3]][3, 0] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR4:.*]] = llvm.insertvalue %[[SIZE0]], %[[DESCR3]][3, 0] : [[DESCR_TY]]
// CHECK-NEXT: %[[DESCR5:.*]] = llvm.insertvalue %[[STRIDE0]], %[[DESCR4]][4, 0] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR5:.*]] = llvm.insertvalue %[[STRIDE0]], %[[DESCR4]][4, 0] : [[DESCR_TY]]
// CHECK-NEXT: %[[DESCR6:.*]] = llvm.insertvalue %[[SIZE1]], %[[DESCR5]][3, 1] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR6:.*]] = llvm.insertvalue %[[SIZE1]], %[[DESCR5]][3, 1] : [[DESCR_TY]]
// CHECK-NEXT: %[[DESCR7:.*]] = llvm.insertvalue %[[STRIDE1]], %[[DESCR6]][4, 1] : [[DESCR_TY]] // CHECK-NEXT: %[[DESCR7:.*]] = llvm.insertvalue %[[STRIDE1]], %[[DESCR6]][4, 1] : [[DESCR_TY]]
// CHECK-DAG: %[[C0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-DAG: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-DAG: %[[C1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-DAG: %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-DAG: %[[SIZES:.*]] = llvm.extractvalue %[[DESCR7]][3] : [[DESCR_TY]] // CHECK-DAG: %[[SIZES:.*]] = llvm.extractvalue %[[DESCR7]][3] : [[DESCR_TY]]
// CHECK-DAG: %[[SIZES_PTR:.*]] = llvm.alloca %[[C1]] x !llvm.array<2 x i64> : (!llvm.i64) -> !llvm.ptr<array<2 x i64>> // CHECK-DAG: %[[SIZES_PTR:.*]] = llvm.alloca %[[C1]] x !llvm.array<2 x i64> : (i64) -> !llvm.ptr<array<2 x i64>>
// CHECK-DAG: llvm.store %[[SIZES]], %[[SIZES_PTR]] : !llvm.ptr<array<2 x i64>> // CHECK-DAG: llvm.store %[[SIZES]], %[[SIZES_PTR]] : !llvm.ptr<array<2 x i64>>
// CHECK-DAG: %[[RESULT_PTR:.*]] = llvm.getelementptr %[[SIZES_PTR]][%[[C0]], %[[IDX]]] : (!llvm.ptr<array<2 x i64>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i64> // CHECK-DAG: %[[RESULT_PTR:.*]] = llvm.getelementptr %[[SIZES_PTR]][%[[C0]], %[[IDX]]] : (!llvm.ptr<array<2 x i64>>, i64, i64) -> !llvm.ptr<i64>
// CHECK-DAG: %[[RESULT:.*]] = llvm.load %[[RESULT_PTR]] : !llvm.ptr<i64> // CHECK-DAG: %[[RESULT:.*]] = llvm.load %[[RESULT_PTR]] : !llvm.ptr<i64>
// CHECK-DAG: llvm.return %[[RESULT]] : !llvm.i64 // CHECK-DAG: llvm.return %[[RESULT]] : i64
%result = dim %arg, %idx : memref<3x?xf32> %result = dim %arg, %idx : memref<3x?xf32>
return %result : index return %result : index
} }
// CHECK-LABEL: @memref_reinterpret_cast_ranked_to_static_shape // CHECK-LABEL: @memref_reinterpret_cast_ranked_to_static_shape
func @memref_reinterpret_cast_ranked_to_static_shape(%input : memref<2x3xf32>) { func @memref_reinterpret_cast_ranked_to_static_shape(%input : memref<2x3xf32>) {
%output = memref_reinterpret_cast %input to %output = memref_reinterpret_cast %input to
offset: [0], sizes: [6, 1], strides: [1, 1] offset: [0], sizes: [6, 1], strides: [1, 1]
: memref<2x3xf32> to memref<6x1xf32> : memref<2x3xf32> to memref<6x1xf32>
return return
} }
// CHECK: [[INPUT:%.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : [[TY:!.*]] // CHECK: [[INPUT:%.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : [[TY:!.*]]
// CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY]] // CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY]]
// CHECK: [[BASE_PTR:%.*]] = llvm.extractvalue [[INPUT]][0] : [[TY]] // CHECK: [[BASE_PTR:%.*]] = llvm.extractvalue [[INPUT]][0] : [[TY]]
// CHECK: [[ALIGNED_PTR:%.*]] = llvm.extractvalue [[INPUT]][1] : [[TY]] // CHECK: [[ALIGNED_PTR:%.*]] = llvm.extractvalue [[INPUT]][1] : [[TY]]
// CHECK: [[OUT_1:%.*]] = llvm.insertvalue [[BASE_PTR]], [[OUT_0]][0] : [[TY]] // CHECK: [[OUT_1:%.*]] = llvm.insertvalue [[BASE_PTR]], [[OUT_0]][0] : [[TY]]
// CHECK: [[OUT_2:%.*]] = llvm.insertvalue [[ALIGNED_PTR]], [[OUT_1]][1] : [[TY]] // CHECK: [[OUT_2:%.*]] = llvm.insertvalue [[ALIGNED_PTR]], [[OUT_1]][1] : [[TY]]
// CHECK: [[OFFSET:%.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: [[OFFSET:%.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: [[OUT_3:%.*]] = llvm.insertvalue [[OFFSET]], [[OUT_2]][2] : [[TY]] // CHECK: [[OUT_3:%.*]] = llvm.insertvalue [[OFFSET]], [[OUT_2]][2] : [[TY]]
// CHECK: [[SIZE_0:%.*]] = llvm.mlir.constant(6 : index) : !llvm.i64 // CHECK: [[SIZE_0:%.*]] = llvm.mlir.constant(6 : index) : i64
// CHECK: [[OUT_4:%.*]] = llvm.insertvalue [[SIZE_0]], [[OUT_3]][3, 0] : [[TY]] // CHECK: [[OUT_4:%.*]] = llvm.insertvalue [[SIZE_0]], [[OUT_3]][3, 0] : [[TY]]
// CHECK: [[SIZE_1:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[SIZE_1:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[OUT_5:%.*]] = llvm.insertvalue [[SIZE_1]], [[OUT_4]][4, 0] : [[TY]] // CHECK: [[OUT_5:%.*]] = llvm.insertvalue [[SIZE_1]], [[OUT_4]][4, 0] : [[TY]]
// CHECK: [[STRIDE_0:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[STRIDE_0:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[OUT_6:%.*]] = llvm.insertvalue [[STRIDE_0]], [[OUT_5]][3, 1] : [[TY]] // CHECK: [[OUT_6:%.*]] = llvm.insertvalue [[STRIDE_0]], [[OUT_5]][3, 1] : [[TY]]
// CHECK: [[STRIDE_1:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[STRIDE_1:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[OUT_7:%.*]] = llvm.insertvalue [[STRIDE_1]], [[OUT_6]][4, 1] : [[TY]] // CHECK: [[OUT_7:%.*]] = llvm.insertvalue [[STRIDE_1]], [[OUT_6]][4, 1] : [[TY]]
// CHECK-LABEL: @memref_reinterpret_cast_unranked_to_dynamic_shape // CHECK-LABEL: @memref_reinterpret_cast_unranked_to_dynamic_shape
func @memref_reinterpret_cast_unranked_to_dynamic_shape(%offset: index, func @memref_reinterpret_cast_unranked_to_dynamic_shape(%offset: index,
%size_0 : index, %size_0 : index,
%size_1 : index, %size_1 : index,
%stride_0 : index, %stride_0 : index,
%stride_1 : index, %stride_1 : index,
%input : memref<*xf32>) { %input : memref<*xf32>) {
%output = memref_reinterpret_cast %input to %output = memref_reinterpret_cast %input to
offset: [%offset], sizes: [%size_0, %size_1], offset: [%offset], sizes: [%size_0, %size_1],
strides: [%stride_0, %stride_1] strides: [%stride_0, %stride_1]
: memref<*xf32> to memref<?x?xf32, offset: ?, strides: [?, ?]> : memref<*xf32> to memref<?x?xf32, offset: ?, strides: [?, ?]>
return return
} }
// CHECK-SAME: ([[OFFSET:%[a-z,0-9]+]]: !llvm.i64, // CHECK-SAME: ([[OFFSET:%[a-z,0-9]+]]: i64,
// CHECK-SAME: [[SIZE_0:%[a-z,0-9]+]]: !llvm.i64, [[SIZE_1:%[a-z,0-9]+]]: !llvm.i64, // CHECK-SAME: [[SIZE_0:%[a-z,0-9]+]]: i64, [[SIZE_1:%[a-z,0-9]+]]: i64,
// CHECK-SAME: [[STRIDE_0:%[a-z,0-9]+]]: !llvm.i64, [[STRIDE_1:%[a-z,0-9]+]]: !llvm.i64, // CHECK-SAME: [[STRIDE_0:%[a-z,0-9]+]]: i64, [[STRIDE_1:%[a-z,0-9]+]]: i64,
// CHECK: [[INPUT:%.*]] = llvm.insertvalue {{.*}}[1] : !llvm.struct<(i64, ptr<i8>)> // CHECK: [[INPUT:%.*]] = llvm.insertvalue {{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
// CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY:!.*]] // CHECK: [[OUT_0:%.*]] = llvm.mlir.undef : [[TY:!.*]]
// CHECK: [[DESCRIPTOR:%.*]] = llvm.extractvalue [[INPUT]][1] : !llvm.struct<(i64, ptr<i8>)> // CHECK: [[DESCRIPTOR:%.*]] = llvm.extractvalue [[INPUT]][1] : !llvm.struct<(i64, ptr<i8>)>
// CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>> // CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>>
// CHECK: [[BASE_PTR:%.*]] = llvm.load [[BASE_PTR_PTR]] : !llvm.ptr<ptr<float>> // CHECK: [[BASE_PTR:%.*]] = llvm.load [[BASE_PTR_PTR]] : !llvm.ptr<ptr<float>>
// CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>> // CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[DESCRIPTOR]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>>
// CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}[[C1]]] // CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}[[C1]]]
// CHECK-SAME: : (!llvm.ptr<ptr<float>>, !llvm.i64) -> !llvm.ptr<ptr<float>> // CHECK-SAME: : (!llvm.ptr<ptr<float>>, i64) -> !llvm.ptr<ptr<float>>
// CHECK: [[ALIGNED_PTR:%.*]] = llvm.load [[ALIGNED_PTR_PTR]] : !llvm.ptr<ptr<float>> // CHECK: [[ALIGNED_PTR:%.*]] = llvm.load [[ALIGNED_PTR_PTR]] : !llvm.ptr<ptr<float>>
// CHECK: [[OUT_1:%.*]] = llvm.insertvalue [[BASE_PTR]], [[OUT_0]][0] : [[TY]] // CHECK: [[OUT_1:%.*]] = llvm.insertvalue [[BASE_PTR]], [[OUT_0]][0] : [[TY]]
// CHECK: [[OUT_2:%.*]] = llvm.insertvalue [[ALIGNED_PTR]], [[OUT_1]][1] : [[TY]] // CHECK: [[OUT_2:%.*]] = llvm.insertvalue [[ALIGNED_PTR]], [[OUT_1]][1] : [[TY]]
// CHECK: [[OUT_3:%.*]] = llvm.insertvalue [[OFFSET]], [[OUT_2]][2] : [[TY]] // CHECK: [[OUT_3:%.*]] = llvm.insertvalue [[OFFSET]], [[OUT_2]][2] : [[TY]]
// CHECK: [[OUT_4:%.*]] = llvm.insertvalue [[SIZE_0]], [[OUT_3]][3, 0] : [[TY]] // CHECK: [[OUT_4:%.*]] = llvm.insertvalue [[SIZE_0]], [[OUT_3]][3, 0] : [[TY]]
// CHECK: [[OUT_5:%.*]] = llvm.insertvalue [[STRIDE_0]], [[OUT_4]][4, 0] : [[TY]] // CHECK: [[OUT_5:%.*]] = llvm.insertvalue [[STRIDE_0]], [[OUT_4]][4, 0] : [[TY]]
// CHECK: [[OUT_6:%.*]] = llvm.insertvalue [[SIZE_1]], [[OUT_5]][3, 1] : [[TY]] // CHECK: [[OUT_6:%.*]] = llvm.insertvalue [[SIZE_1]], [[OUT_5]][3, 1] : [[TY]]
// CHECK: [[OUT_7:%.*]] = llvm.insertvalue [[STRIDE_1]], [[OUT_6]][4, 1] : [[TY]] // CHECK: [[OUT_7:%.*]] = llvm.insertvalue [[STRIDE_1]], [[OUT_6]][4, 1] : [[TY]]
// CHECK-LABEL: @memref_reshape // CHECK-LABEL: @memref_reshape
func @memref_reshape(%input : memref<2x3xf32>, %shape : memref<?xindex>) { func @memref_reshape(%input : memref<2x3xf32>, %shape : memref<?xindex>) {
%output = memref_reshape %input(%shape) %output = memref_reshape %input(%shape)
: (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32> : (memref<2x3xf32>, memref<?xindex>) -> memref<*xf32>
return return
} }
// CHECK: [[INPUT:%.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : [[INPUT_TY:!.*]] // CHECK: [[INPUT:%.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : [[INPUT_TY:!.*]]
// CHECK: [[SHAPE:%.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : [[SHAPE_TY:!.*]] // CHECK: [[SHAPE:%.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : [[SHAPE_TY:!.*]]
// CHECK: [[RANK:%.*]] = llvm.extractvalue [[SHAPE]][3, 0] : [[SHAPE_TY]] // CHECK: [[RANK:%.*]] = llvm.extractvalue [[SHAPE]][3, 0] : [[SHAPE_TY]]
// CHECK: [[UNRANKED_OUT_O:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)> // CHECK: [[UNRANKED_OUT_O:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK: [[UNRANKED_OUT_1:%.*]] = llvm.insertvalue [[RANK]], [[UNRANKED_OUT_O]][0] : !llvm.struct<(i64, ptr<i8>)> // CHECK: [[UNRANKED_OUT_1:%.*]] = llvm.insertvalue [[RANK]], [[UNRANKED_OUT_O]][0] : !llvm.struct<(i64, ptr<i8>)>
// Compute size in bytes to allocate result ranked descriptor // Compute size in bytes to allocate result ranked descriptor
// CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: [[PTR_SIZE:%.*]] = llvm.mlir.constant(8 : index) : !llvm.i64 // CHECK: [[PTR_SIZE:%.*]] = llvm.mlir.constant(8 : index) : i64
// CHECK: [[INDEX_SIZE:%.*]] = llvm.mlir.constant(8 : index) : !llvm.i64 // CHECK: [[INDEX_SIZE:%.*]] = llvm.mlir.constant(8 : index) : i64
// CHECK: [[DOUBLE_PTR_SIZE:%.*]] = llvm.mul [[C2]], [[PTR_SIZE]] : !llvm.i64 // CHECK: [[DOUBLE_PTR_SIZE:%.*]] = llvm.mul [[C2]], [[PTR_SIZE]] : i64
// CHECK: [[DESC_ALLOC_SIZE:%.*]] = llvm.add [[DOUBLE_PTR_SIZE]], %{{.*}} // CHECK: [[DESC_ALLOC_SIZE:%.*]] = llvm.add [[DOUBLE_PTR_SIZE]], %{{.*}}
// CHECK: [[UNDERLYING_DESC:%.*]] = llvm.alloca [[DESC_ALLOC_SIZE]] x !llvm.i8 // CHECK: [[UNDERLYING_DESC:%.*]] = llvm.alloca [[DESC_ALLOC_SIZE]] x i8
// CHECK: llvm.insertvalue [[UNDERLYING_DESC]], [[UNRANKED_OUT_1]][1] // CHECK: llvm.insertvalue [[UNDERLYING_DESC]], [[UNRANKED_OUT_1]][1]
// Set allocated, aligned pointers and offset. // Set allocated, aligned pointers and offset.
// CHECK: [[ALLOC_PTR:%.*]] = llvm.extractvalue [[INPUT]][0] : [[INPUT_TY]] // CHECK: [[ALLOC_PTR:%.*]] = llvm.extractvalue [[INPUT]][0] : [[INPUT_TY]]
// CHECK: [[ALIGN_PTR:%.*]] = llvm.extractvalue [[INPUT]][1] : [[INPUT_TY]] // CHECK: [[ALIGN_PTR:%.*]] = llvm.extractvalue [[INPUT]][1] : [[INPUT_TY]]
// CHECK: [[OFFSET:%.*]] = llvm.extractvalue [[INPUT]][2] : [[INPUT_TY]] // CHECK: [[OFFSET:%.*]] = llvm.extractvalue [[INPUT]][2] : [[INPUT_TY]]
// CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] // CHECK: [[BASE_PTR_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]]
// CHECK-SAME: !llvm.ptr<i8> to !llvm.ptr<ptr<float>> // CHECK-SAME: !llvm.ptr<i8> to !llvm.ptr<ptr<float>>
// CHECK: llvm.store [[ALLOC_PTR]], [[BASE_PTR_PTR]] : !llvm.ptr<ptr<float>> // CHECK: llvm.store [[ALLOC_PTR]], [[BASE_PTR_PTR]] : !llvm.ptr<ptr<float>>
// CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>> // CHECK: [[BASE_PTR_PTR_:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>>
// CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[C1:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}[[C1]]] // CHECK: [[ALIGNED_PTR_PTR:%.*]] = llvm.getelementptr [[BASE_PTR_PTR_]]{{\[}}[[C1]]]
// CHECK: llvm.store [[ALIGN_PTR]], [[ALIGNED_PTR_PTR]] : !llvm.ptr<ptr<float>> // CHECK: llvm.store [[ALIGN_PTR]], [[ALIGNED_PTR_PTR]] : !llvm.ptr<ptr<float>>
// CHECK: [[BASE_PTR_PTR__:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>> // CHECK: [[BASE_PTR_PTR__:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] : !llvm.ptr<i8> to !llvm.ptr<ptr<float>>
// CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: [[OFFSET_PTR_:%.*]] = llvm.getelementptr [[BASE_PTR_PTR__]]{{\[}}[[C2]]] // CHECK: [[OFFSET_PTR_:%.*]] = llvm.getelementptr [[BASE_PTR_PTR__]]{{\[}}[[C2]]]
// CHECK: [[OFFSET_PTR:%.*]] = llvm.bitcast [[OFFSET_PTR_]] // CHECK: [[OFFSET_PTR:%.*]] = llvm.bitcast [[OFFSET_PTR_]]
// CHECK: llvm.store [[OFFSET]], [[OFFSET_PTR]] : !llvm.ptr<i64> // CHECK: llvm.store [[OFFSET]], [[OFFSET_PTR]] : !llvm.ptr<i64>
// Iterate over shape operand in reverse order and set sizes and strides. // Iterate over shape operand in reverse order and set sizes and strides.
// CHECK: [[STRUCT_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]] // CHECK: [[STRUCT_PTR:%.*]] = llvm.bitcast [[UNDERLYING_DESC]]
// CHECK-SAME: !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, i64)>> // CHECK-SAME: !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<float>, ptr<float>, i64, i64)>>
// CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: [[C3_I32:%.*]] = llvm.mlir.constant(3 : i32) : !llvm.i32 // CHECK: [[C3_I32:%.*]] = llvm.mlir.constant(3 : i32) : i32
// CHECK: [[SIZES_PTR:%.*]] = llvm.getelementptr [[STRUCT_PTR]]{{\[}}[[C0]], [[C3_I32]]] // CHECK: [[SIZES_PTR:%.*]] = llvm.getelementptr [[STRUCT_PTR]]{{\[}}[[C0]], [[C3_I32]]]
// CHECK: [[STRIDES_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[RANK]]] // CHECK: [[STRIDES_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[RANK]]]
// CHECK: [[SHAPE_IN_PTR:%.*]] = llvm.extractvalue [[SHAPE]][1] : [[SHAPE_TY]] // CHECK: [[SHAPE_IN_PTR:%.*]] = llvm.extractvalue [[SHAPE]][1] : [[SHAPE_TY]]
// CHECK: [[C1_:%.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: [[C1_:%.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: [[RANK_MIN_1:%.*]] = llvm.sub [[RANK]], [[C1_]] : !llvm.i64 // CHECK: [[RANK_MIN_1:%.*]] = llvm.sub [[RANK]], [[C1_]] : i64
// CHECK: llvm.br ^bb1([[RANK_MIN_1]], [[C1_]] : !llvm.i64, !llvm.i64) // CHECK: llvm.br ^bb1([[RANK_MIN_1]], [[C1_]] : i64, i64)
// CHECK: ^bb1([[DIM:%.*]]: !llvm.i64, [[CUR_STRIDE:%.*]]: !llvm.i64): // CHECK: ^bb1([[DIM:%.*]]: i64, [[CUR_STRIDE:%.*]]: i64):
// CHECK: [[C0_:%.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: [[C0_:%.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: [[COND:%.*]] = llvm.icmp "sge" [[DIM]], [[C0_]] : !llvm.i64 // CHECK: [[COND:%.*]] = llvm.icmp "sge" [[DIM]], [[C0_]] : i64
// CHECK: llvm.cond_br [[COND]], ^bb2, ^bb3 // CHECK: llvm.cond_br [[COND]], ^bb2, ^bb3
// CHECK: ^bb2: // CHECK: ^bb2:
// CHECK: [[SIZE_PTR:%.*]] = llvm.getelementptr [[SHAPE_IN_PTR]]{{\[}}[[DIM]]] // CHECK: [[SIZE_PTR:%.*]] = llvm.getelementptr [[SHAPE_IN_PTR]]{{\[}}[[DIM]]]
// CHECK: [[SIZE:%.*]] = llvm.load [[SIZE_PTR]] : !llvm.ptr<i64> // CHECK: [[SIZE:%.*]] = llvm.load [[SIZE_PTR]] : !llvm.ptr<i64>
// CHECK: [[TARGET_SIZE_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[DIM]]] // CHECK: [[TARGET_SIZE_PTR:%.*]] = llvm.getelementptr [[SIZES_PTR]]{{\[}}[[DIM]]]
// CHECK: llvm.store [[SIZE]], [[TARGET_SIZE_PTR]] : !llvm.ptr<i64> // CHECK: llvm.store [[SIZE]], [[TARGET_SIZE_PTR]] : !llvm.ptr<i64>
// CHECK: [[TARGET_STRIDE_PTR:%.*]] = llvm.getelementptr [[STRIDES_PTR]]{{\[}}[[DIM]]] // CHECK: [[TARGET_STRIDE_PTR:%.*]] = llvm.getelementptr [[STRIDES_PTR]]{{\[}}[[DIM]]]
// CHECK: llvm.store [[CUR_STRIDE]], [[TARGET_STRIDE_PTR]] : !llvm.ptr<i64> // CHECK: llvm.store [[CUR_STRIDE]], [[TARGET_STRIDE_PTR]] : !llvm.ptr<i64>
// CHECK: [[UPDATE_STRIDE:%.*]] = llvm.mul [[CUR_STRIDE]], [[SIZE]] : !llvm.i64 // CHECK: [[UPDATE_STRIDE:%.*]] = llvm.mul [[CUR_STRIDE]], [[SIZE]] : i64
// CHECK: [[STRIDE_COND:%.*]] = llvm.sub [[DIM]], [[C1_]] : !llvm.i64 // CHECK: [[STRIDE_COND:%.*]] = llvm.sub [[DIM]], [[C1_]] : i64
// CHECK: llvm.br ^bb1([[STRIDE_COND]], [[UPDATE_STRIDE]] : !llvm.i64, !llvm.i64) // CHECK: llvm.br ^bb1([[STRIDE_COND]], [[UPDATE_STRIDE]] : i64, i64)
// CHECK: ^bb3: // CHECK: ^bb3:
// CHECK: llvm.return // CHECK: llvm.return

mlir/test/Conversion/StandardToLLVM/convert-funcs.mlir

Show All 13 Lines
//CHECK: llvm.func @fifth_order_left(!llvm.ptr<func<void (ptr<func<void (ptr<func<void (ptr<func<void ()>>)>>)>>)>>) //CHECK: llvm.func @fifth_order_left(!llvm.ptr<func<void (ptr<func<void (ptr<func<void (ptr<func<void ()>>)>>)>>)>>)
func private @fifth_order_left(%arg0: (((() -> ()) -> ()) -> ()) -> ()) func private @fifth_order_left(%arg0: (((() -> ()) -> ()) -> ()) -> ())
//CHECK: llvm.func @fifth_order_right(!llvm.ptr<func<ptr<func<ptr<func<ptr<func<void ()>> ()>> ()>> ()>>) //CHECK: llvm.func @fifth_order_right(!llvm.ptr<func<ptr<func<ptr<func<ptr<func<void ()>> ()>> ()>> ()>>)
func private @fifth_order_right(%arg0: () -> (() -> (() -> (() -> ())))) func private @fifth_order_right(%arg0: () -> (() -> (() -> (() -> ()))))
// Check that memrefs are converted to argument packs if appear as function arguments. // Check that memrefs are converted to argument packs if appear as function arguments.
// CHECK: llvm.func @memref_call_conv(!llvm.ptr<float>, !llvm.ptr<float>, !llvm.i64, !llvm.i64, !llvm.i64) // CHECK: llvm.func @memref_call_conv(!llvm.ptr<float>, !llvm.ptr<float>, i64, i64, i64)
func private @memref_call_conv(%arg0: memref<?xf32>) func private @memref_call_conv(%arg0: memref<?xf32>)
// Same in nested functions. // Same in nested functions.
// CHECK: llvm.func @memref_call_conv_nested(!llvm.ptr<func<void (ptr<float>, ptr<float>, i64, i64, i64)>>) // CHECK: llvm.func @memref_call_conv_nested(!llvm.ptr<func<void (ptr<float>, ptr<float>, i64, i64, i64)>>)
func private @memref_call_conv_nested(%arg0: (memref<?xf32>) -> ()) func private @memref_call_conv_nested(%arg0: (memref<?xf32>) -> ())
//CHECK-LABEL: llvm.func @pass_through(%arg0: !llvm.ptr<func<void ()>>) -> !llvm.ptr<func<void ()>> { //CHECK-LABEL: llvm.func @pass_through(%arg0: !llvm.ptr<func<void ()>>) -> !llvm.ptr<func<void ()>> {
func @pass_through(%arg0: () -> ()) -> (() -> ()) { func @pass_through(%arg0: () -> ()) -> (() -> ()) {
// CHECK-NEXT: llvm.br ^bb1(%arg0 : !llvm.ptr<func<void ()>>) // CHECK-NEXT: llvm.br ^bb1(%arg0 : !llvm.ptr<func<void ()>>)
br ^bb1(%arg0 : () -> ()) br ^bb1(%arg0 : () -> ())
//CHECK-NEXT: ^bb1(%0: !llvm.ptr<func<void ()>>): //CHECK-NEXT: ^bb1(%0: !llvm.ptr<func<void ()>>):
^bb1(%bbarg: () -> ()): ^bb1(%bbarg: () -> ()):
// CHECK-NEXT: llvm.return %0 : !llvm.ptr<func<void ()>> // CHECK-NEXT: llvm.return %0 : !llvm.ptr<func<void ()>>
return %bbarg : () -> () return %bbarg : () -> ()
} }
// CHECK-LABEL: llvm.func @body(!llvm.i32) // CHECK-LABEL: llvm.func @body(i32)
func private @body(i32) func private @body(i32)
// CHECK-LABEL: llvm.func @indirect_const_call // CHECK-LABEL: llvm.func @indirect_const_call
// CHECK-SAME: (%[[ARG0:.*]]: !llvm.i32) { // CHECK-SAME: (%[[ARG0:.*]]: i32) {
func @indirect_const_call(%arg0: i32) { func @indirect_const_call(%arg0: i32) {
// CHECK-NEXT: %[[ADDR:.*]] = llvm.mlir.addressof @body : !llvm.ptr<func<void (i32)>> // CHECK-NEXT: %[[ADDR:.*]] = llvm.mlir.addressof @body : !llvm.ptr<func<void (i32)>>
%0 = constant @body : (i32) -> () %0 = constant @body : (i32) -> ()
// CHECK-NEXT: llvm.call %[[ADDR]](%[[ARG0:.*]]) : (!llvm.i32) -> () // CHECK-NEXT: llvm.call %[[ADDR]](%[[ARG0:.*]]) : (i32) -> ()
call_indirect %0(%arg0) : (i32) -> () call_indirect %0(%arg0) : (i32) -> ()
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
return return
} }
// CHECK-LABEL: llvm.func @indirect_call(%arg0: !llvm.ptr<func<i32 (float)>>, %arg1: !llvm.float) -> !llvm.i32 { // CHECK-LABEL: llvm.func @indirect_call(%arg0: !llvm.ptr<func<i32 (float)>>, %arg1: !llvm.float) -> i32 {
func @indirect_call(%arg0: (f32) -> i32, %arg1: f32) -> i32 { func @indirect_call(%arg0: (f32) -> i32, %arg1: f32) -> i32 {
// CHECK-NEXT: %0 = llvm.call %arg0(%arg1) : (!llvm.float) -> !llvm.i32 // CHECK-NEXT: %0 = llvm.call %arg0(%arg1) : (!llvm.float) -> i32
%0 = call_indirect %arg0(%arg1) : (f32) -> i32 %0 = call_indirect %arg0(%arg1) : (f32) -> i32
// CHECK-NEXT: llvm.return %0 : !llvm.i32 // CHECK-NEXT: llvm.return %0 : i32
return %0 : i32 return %0 : i32
} }

mlir/test/Conversion/StandardToLLVM/convert-static-memref-ops.mlir

// RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s // RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s
// RUN: mlir-opt -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -split-input-file %s | FileCheck %s --check-prefix=BAREPTR // RUN: mlir-opt -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -split-input-file %s | FileCheck %s --check-prefix=BAREPTR
// BAREPTR-LABEL: func @check_noalias // BAREPTR-LABEL: func @check_noalias
// BAREPTR-SAME: %{{.*}}: !llvm.ptr<float> {llvm.noalias = true}, %{{.*}}: !llvm.ptr<float> {llvm.noalias = true} // BAREPTR-SAME: %{{.*}}: !llvm.ptr<float> {llvm.noalias = true}, %{{.*}}: !llvm.ptr<float> {llvm.noalias = true}
func @check_noalias(%static : memref<2xf32> {llvm.noalias = true}, %other : memref<2xf32> {llvm.noalias = true}) { func @check_noalias(%static : memref<2xf32> {llvm.noalias = true}, %other : memref<2xf32> {llvm.noalias = true}) {
return return
} }
// ----- // -----
// CHECK-LABEL: func @check_static_return // CHECK-LABEL: func @check_static_return
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
// CHECK-SAME: -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-SAME: -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-LABEL: func @check_static_return // BAREPTR-LABEL: func @check_static_return
// BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr<float>) -> !llvm.ptr<float> { // BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr<float>) -> !llvm.ptr<float> {
func @check_static_return(%static : memref<32x18xf32>) -> memref<32x18xf32> { func @check_static_return(%static : memref<32x18xf32>) -> memref<32x18xf32> {
// CHECK: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR: %[[udf:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR: %[[udf:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[base0:.*]] = llvm.insertvalue %[[arg]], %[[udf]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[base0:.*]] = llvm.insertvalue %[[arg]], %[[udf]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[aligned:.*]] = llvm.insertvalue %[[arg]], %[[base0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[aligned:.*]] = llvm.insertvalue %[[arg]], %[[base0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val0:.*]] = llvm.mlir.constant(0 : index) : i64
// BAREPTR-NEXT: %[[ins0:.*]] = llvm.insertvalue %[[val0]], %[[aligned]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins0:.*]] = llvm.insertvalue %[[val0]], %[[aligned]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val1:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val1:.*]] = llvm.mlir.constant(32 : index) : i64
// BAREPTR-NEXT: %[[ins1:.*]] = llvm.insertvalue %[[val1]], %[[ins0]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins1:.*]] = llvm.insertvalue %[[val1]], %[[ins0]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val2:.*]] = llvm.mlir.constant(18 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val2:.*]] = llvm.mlir.constant(18 : index) : i64
// BAREPTR-NEXT: %[[ins2:.*]] = llvm.insertvalue %[[val2]], %[[ins1]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins2:.*]] = llvm.insertvalue %[[val2]], %[[ins1]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val3:.*]] = llvm.mlir.constant(18 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val3:.*]] = llvm.mlir.constant(18 : index) : i64
// BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : i64
// BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr<float> // BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr<float>
return %static : memref<32x18xf32> return %static : memref<32x18xf32>
} }
// ----- // -----
// CHECK-LABEL: func @check_static_return_with_offset // CHECK-LABEL: func @check_static_return_with_offset
// CHECK-COUNT-2: !llvm.ptr<float> // CHECK-COUNT-2: !llvm.ptr<float>
// CHECK-COUNT-5: !llvm.i64 // CHECK-COUNT-5: i64
// CHECK-SAME: -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-SAME: -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-LABEL: func @check_static_return_with_offset // BAREPTR-LABEL: func @check_static_return_with_offset
// BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr<float>) -> !llvm.ptr<float> { // BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr<float>) -> !llvm.ptr<float> {
func @check_static_return_with_offset(%static : memref<32x18xf32, offset:7, strides:[22,1]>) -> memref<32x18xf32, offset:7, strides:[22,1]> { func @check_static_return_with_offset(%static : memref<32x18xf32, offset:7, strides:[22,1]>) -> memref<32x18xf32, offset:7, strides:[22,1]> {
// CHECK: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.return %{{.*}} : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR: %[[udf:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR: %[[udf:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[base0:.*]] = llvm.insertvalue %[[arg]], %[[udf]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[base0:.*]] = llvm.insertvalue %[[arg]], %[[udf]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[aligned:.*]] = llvm.insertvalue %[[arg]], %[[base0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[aligned:.*]] = llvm.insertvalue %[[arg]], %[[base0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val0:.*]] = llvm.mlir.constant(7 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val0:.*]] = llvm.mlir.constant(7 : index) : i64
// BAREPTR-NEXT: %[[ins0:.*]] = llvm.insertvalue %[[val0]], %[[aligned]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins0:.*]] = llvm.insertvalue %[[val0]], %[[aligned]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val1:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val1:.*]] = llvm.mlir.constant(32 : index) : i64
// BAREPTR-NEXT: %[[ins1:.*]] = llvm.insertvalue %[[val1]], %[[ins0]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins1:.*]] = llvm.insertvalue %[[val1]], %[[ins0]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val2:.*]] = llvm.mlir.constant(22 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val2:.*]] = llvm.mlir.constant(22 : index) : i64
// BAREPTR-NEXT: %[[ins2:.*]] = llvm.insertvalue %[[val2]], %[[ins1]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins2:.*]] = llvm.insertvalue %[[val2]], %[[ins1]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val3:.*]] = llvm.mlir.constant(18 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val3:.*]] = llvm.mlir.constant(18 : index) : i64
// BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : i64
// BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr<float> // BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr<float>
return %static : memref<32x18xf32, offset:7, strides:[22,1]> return %static : memref<32x18xf32, offset:7, strides:[22,1]>
} }
// ----- // -----
// CHECK-LABEL: func @zero_d_alloc() -> !llvm.struct<(ptr<float>, ptr<float>, i64)> { // CHECK-LABEL: func @zero_d_alloc() -> !llvm.struct<(ptr<float>, ptr<float>, i64)> {
// BAREPTR-LABEL: func @zero_d_alloc() -> !llvm.ptr<float> { // BAREPTR-LABEL: func @zero_d_alloc() -> !llvm.ptr<float> {
func @zero_d_alloc() -> memref<f32> { func @zero_d_alloc() -> memref<f32> {
// CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: llvm.call @malloc(%[[size_bytes]]) : (!llvm.i64) -> !llvm.ptr<i8> // CHECK-NEXT: llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
// CHECK-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// BAREPTR-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // BAREPTR-NEXT: %[[one:.*]] = llvm.mlir.constant(1 : index) : i64
// BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[one]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// BAREPTR-NEXT: llvm.call @malloc(%[[size_bytes]]) : (!llvm.i64) -> !llvm.ptr<i8> // BAREPTR-NEXT: llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
// BAREPTR-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float> // BAREPTR-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float>
// BAREPTR-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)> // BAREPTR-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// BAREPTR-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // BAREPTR-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
%0 = alloc() : memref<f32> %0 = alloc() : memref<f32>
return %0 : memref<f32> return %0 : memref<f32>
} }
// ----- // -----
// CHECK-LABEL: func @zero_d_dealloc // CHECK-LABEL: func @zero_d_dealloc
Show All 10 Lines// BAREPTR-NEXT: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
return return
} }
// ----- // -----
// CHECK-LABEL: func @aligned_1d_alloc( // CHECK-LABEL: func @aligned_1d_alloc(
// BAREPTR-LABEL: func @aligned_1d_alloc( // BAREPTR-LABEL: func @aligned_1d_alloc(
func @aligned_1d_alloc() -> memref<42xf32> { func @aligned_1d_alloc() -> memref<42xf32> {
// CHECK-NEXT: %[[sz1:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: %[[sz1:.*]] = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: %[[alignment:.*]] = llvm.mlir.constant(8 : index) : !llvm.i64 // CHECK-NEXT: %[[alignment:.*]] = llvm.mlir.constant(8 : index) : i64
// CHECK-NEXT: %[[allocsize:.*]] = llvm.add %[[size_bytes]], %[[alignment]] : !llvm.i64 // CHECK-NEXT: %[[allocsize:.*]] = llvm.add %[[size_bytes]], %[[alignment]] : i64
// CHECK-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[allocsize]]) : (!llvm.i64) -> !llvm.ptr<i8> // CHECK-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[allocsize]]) : (i64) -> !llvm.ptr<i8>
// CHECK-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK-NEXT: %[[allocatedAsInt:.*]] = llvm.ptrtoint %[[ptr]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[allocatedAsInt:.*]] = llvm.ptrtoint %[[ptr]] : !llvm.ptr<float> to i64
// CHECK-NEXT: %[[one_1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[one_1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[bump:.*]] = llvm.sub %[[alignment]], %[[one_1]] : !llvm.i64 // CHECK-NEXT: %[[bump:.*]] = llvm.sub %[[alignment]], %[[one_1]] : i64
// CHECK-NEXT: %[[bumped:.*]] = llvm.add %[[allocatedAsInt]], %[[bump]] : !llvm.i64 // CHECK-NEXT: %[[bumped:.*]] = llvm.add %[[allocatedAsInt]], %[[bump]] : i64
// CHECK-NEXT: %[[mod:.*]] = llvm.urem %[[bumped]], %[[alignment]] : !llvm.i64 // CHECK-NEXT: %[[mod:.*]] = llvm.urem %[[bumped]], %[[alignment]] : i64
// CHECK-NEXT: %[[aligned:.*]] = llvm.sub %[[bumped]], %[[mod]] : !llvm.i64 // CHECK-NEXT: %[[aligned:.*]] = llvm.sub %[[bumped]], %[[mod]] : i64
// CHECK-NEXT: %[[alignedBitCast:.*]] = llvm.inttoptr %[[aligned]] : !llvm.i64 to !llvm.ptr<float> // CHECK-NEXT: %[[alignedBitCast:.*]] = llvm.inttoptr %[[aligned]] : i64 to !llvm.ptr<float>
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[alignedBitCast]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[alignedBitCast]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[sz1:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // BAREPTR-NEXT: %[[sz1:.*]] = llvm.mlir.constant(42 : index) : i64
// BAREPTR-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // BAREPTR-NEXT: %[[st1:.*]] = llvm.mlir.constant(1 : index) : i64
// BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[sz1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// BAREPTR-NEXT: %[[alignment:.*]] = llvm.mlir.constant(8 : index) : !llvm.i64 // BAREPTR-NEXT: %[[alignment:.*]] = llvm.mlir.constant(8 : index) : i64
// BAREPTR-NEXT: %[[allocsize:.*]] = llvm.add %[[size_bytes]], %[[alignment]] : !llvm.i64 // BAREPTR-NEXT: %[[allocsize:.*]] = llvm.add %[[size_bytes]], %[[alignment]] : i64
// BAREPTR-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[allocsize]]) : (!llvm.i64) -> !llvm.ptr<i8> // BAREPTR-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[allocsize]]) : (i64) -> !llvm.ptr<i8>
// BAREPTR-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float> // BAREPTR-NEXT: %[[ptr:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<i8> to !llvm.ptr<float>
// BAREPTR-NEXT: %[[allocatedAsInt:.*]] = llvm.ptrtoint %[[ptr]] : !llvm.ptr<float> to !llvm.i64 // BAREPTR-NEXT: %[[allocatedAsInt:.*]] = llvm.ptrtoint %[[ptr]] : !llvm.ptr<float> to i64
// BAREPTR-NEXT: %[[one_2:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // BAREPTR-NEXT: %[[one_2:.*]] = llvm.mlir.constant(1 : index) : i64
// BAREPTR-NEXT: %[[bump:.*]] = llvm.sub %[[alignment]], %[[one_2]] : !llvm.i64 // BAREPTR-NEXT: %[[bump:.*]] = llvm.sub %[[alignment]], %[[one_2]] : i64
// BAREPTR-NEXT: %[[bumped:.*]] = llvm.add %[[allocatedAsInt]], %[[bump]] : !llvm.i64 // BAREPTR-NEXT: %[[bumped:.*]] = llvm.add %[[allocatedAsInt]], %[[bump]] : i64
// BAREPTR-NEXT: %[[mod:.*]] = llvm.urem %[[bumped]], %[[alignment]] : !llvm.i64 // BAREPTR-NEXT: %[[mod:.*]] = llvm.urem %[[bumped]], %[[alignment]] : i64
// BAREPTR-NEXT: %[[aligned:.*]] = llvm.sub %[[bumped]], %[[mod]] : !llvm.i64 // BAREPTR-NEXT: %[[aligned:.*]] = llvm.sub %[[bumped]], %[[mod]] : i64
// BAREPTR-NEXT: %[[alignedBitCast:.*]] = llvm.inttoptr %[[aligned]] : !llvm.i64 to !llvm.ptr<float> // BAREPTR-NEXT: %[[alignedBitCast:.*]] = llvm.inttoptr %[[aligned]] : i64 to !llvm.ptr<float>
// BAREPTR-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: llvm.insertvalue %[[alignedBitCast]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: llvm.insertvalue %[[alignedBitCast]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// BAREPTR-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
%0 = alloc() {alignment = 8} : memref<42xf32> %0 = alloc() {alignment = 8} : memref<42xf32>
return %0 : memref<42xf32> return %0 : memref<42xf32>
} }
// ----- // -----
// CHECK-LABEL: func @static_alloc() -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> { // CHECK-LABEL: func @static_alloc() -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> {
// BAREPTR-LABEL: func @static_alloc() -> !llvm.ptr<float> { // BAREPTR-LABEL: func @static_alloc() -> !llvm.ptr<float> {
func @static_alloc() -> memref<32x18xf32> { func @static_alloc() -> memref<32x18xf32> {
// CHECK: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : !llvm.i64 // CHECK: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (!llvm.i64) -> !llvm.ptr<i8> // CHECK-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
// CHECK-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<float>
// BAREPTR: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : !llvm.i64 // BAREPTR: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
// BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // BAREPTR-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // BAREPTR-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// BAREPTR-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (!llvm.i64) -> !llvm.ptr<i8> // BAREPTR-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
// BAREPTR-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<float> // BAREPTR-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<float>
%0 = alloc() : memref<32x18xf32> %0 = alloc() : memref<32x18xf32>
return %0 : memref<32x18xf32> return %0 : memref<32x18xf32>
} }
// ----- // -----
// CHECK-LABEL: func @static_alloca() -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> { // CHECK-LABEL: func @static_alloca() -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> {
func @static_alloca() -> memref<32x18xf32> { func @static_alloca() -> memref<32x18xf32> {
// CHECK-NEXT: %[[sz1:.*]] = llvm.mlir.constant(32 : index) : !llvm.i64 // CHECK-NEXT: %[[sz1:.*]] = llvm.mlir.constant(32 : index) : i64
// CHECK-NEXT: %[[sz2:.*]] = llvm.mlir.constant(18 : index) : !llvm.i64 // CHECK-NEXT: %[[sz2:.*]] = llvm.mlir.constant(18 : index) : i64
// CHECK-NEXT: %[[st2:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[st2:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : !llvm.i64 // CHECK-NEXT: %[[num_elems:.*]] = llvm.mlir.constant(576 : index) : i64
// CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float> // CHECK-NEXT: %[[null:.*]] = llvm.mlir.null : !llvm.ptr<float>
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to !llvm.i64 // CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<float> to i64
// CHECK-NEXT: %[[allocated:.*]] = llvm.alloca %[[size_bytes]] x !llvm.float : (!llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[allocated:.*]] = llvm.alloca %[[size_bytes]] x !llvm.float : (i64) -> !llvm.ptr<float>
%0 = alloca() : memref<32x18xf32> %0 = alloca() : memref<32x18xf32>
// Test with explicitly specified alignment. llvm.alloca takes care of the // Test with explicitly specified alignment. llvm.alloca takes care of the
// alignment. The same pointer is thus used for allocation and aligned // alignment. The same pointer is thus used for allocation and aligned
// accesses. // accesses.
// CHECK: %[[alloca_aligned:.*]] = llvm.alloca %{{.*}} x !llvm.float {alignment = 32 : i64} : (!llvm.i64) -> !llvm.ptr<float> // CHECK: %[[alloca_aligned:.*]] = llvm.alloca %{{.*}} x !llvm.float {alignment = 32 : i64} : (i64) -> !llvm.ptr<float>
// CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
alloca() {alignment = 32} : memref<32x18xf32> alloca() {alignment = 32} : memref<32x18xf32>
return %0 : memref<32x18xf32> return %0 : memref<32x18xf32>
} }
// ----- // -----
Show All 25 Lines// BAREPTR-NEXT: llvm.load %[[ptr:.*]] : !llvm.ptr<float>
%0 = load %arg0[] : memref<f32> %0 = load %arg0[] : memref<f32>
return %0 : f32 return %0 : f32
} }
// ----- // -----
// CHECK-LABEL: func @static_load( // CHECK-LABEL: func @static_load(
// CHECK-COUNT-2: !llvm.ptr<float>, // CHECK-COUNT-2: !llvm.ptr<float>,
// CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i64 // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64
// CHECK: %[[I:.*]]: !llvm.i64, // CHECK: %[[I:.*]]: i64,
// CHECK: %[[J:.*]]: !llvm.i64) // CHECK: %[[J:.*]]: i64)
// BAREPTR-LABEL: func @static_load // BAREPTR-LABEL: func @static_load
// BAREPTR-SAME: (%[[A:.*]]: !llvm.ptr<float>, %[[I:.*]]: !llvm.i64, %[[J:.*]]: !llvm.i64) { // BAREPTR-SAME: (%[[A:.*]]: !llvm.ptr<float>, %[[I:.*]]: i64, %[[J:.*]]: i64) {
func @static_load(%static : memref<10x42xf32>, %i : index, %j : index) { func @static_load(%static : memref<10x42xf32>, %i : index, %j : index) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.load %[[addr]] : !llvm.ptr<float> // CHECK-NEXT: llvm.load %[[addr]] : !llvm.ptr<float>
// BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // BAREPTR-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64
// BAREPTR-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // BAREPTR-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// BAREPTR-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // BAREPTR-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// BAREPTR-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // BAREPTR-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// BAREPTR-NEXT: llvm.load %[[addr]] : !llvm.ptr<float> // BAREPTR-NEXT: llvm.load %[[addr]] : !llvm.ptr<float>
%0 = load %static[%i, %j] : memref<10x42xf32> %0 = load %static[%i, %j] : memref<10x42xf32>
return return
} }
// ----- // -----
// CHECK-LABEL: func @zero_d_store // CHECK-LABEL: func @zero_d_store
Show All 9 Lines// BAREPTR-NEXT: llvm.store %[[val]], %[[ptr]] : !llvm.ptr<float>
return return
} }
// ----- // -----
// CHECK-LABEL: func @static_store // CHECK-LABEL: func @static_store
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float> // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[I:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[J:[a-zA-Z0-9]*]]: i64
// BAREPTR-LABEL: func @static_store // BAREPTR-LABEL: func @static_store
// BAREPTR-SAME: %[[A:.*]]: !llvm.ptr<float> // BAREPTR-SAME: %[[A:.*]]: !llvm.ptr<float>
// BAREPTR-SAME: %[[I:[a-zA-Z0-9]*]]: !llvm.i64 // BAREPTR-SAME: %[[I:[a-zA-Z0-9]*]]: i64
// BAREPTR-SAME: %[[J:[a-zA-Z0-9]*]]: !llvm.i64 // BAREPTR-SAME: %[[J:[a-zA-Z0-9]*]]: i64
func @static_store(%static : memref<10x42xf32>, %i : index, %j : index, %val : f32) { func @static_store(%static : memref<10x42xf32>, %i : index, %j : index, %val : f32) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // CHECK-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float> // CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float>
// BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : !llvm.i64 // BAREPTR-NEXT: %[[st0:.*]] = llvm.mlir.constant(42 : index) : i64
// BAREPTR-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : !llvm.i64 // BAREPTR-NEXT: %[[offI:.*]] = llvm.mul %[[I]], %[[st0]] : i64
// BAREPTR-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : !llvm.i64 // BAREPTR-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// BAREPTR-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // BAREPTR-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// BAREPTR-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float> // BAREPTR-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<float>
store %val, %static[%i, %j] : memref<10x42xf32> store %val, %static[%i, %j] : memref<10x42xf32>
return return
} }
// ----- // -----
// CHECK-LABEL: func @static_memref_dim // CHECK-LABEL: func @static_memref_dim
// BAREPTR-LABEL: func @static_memref_dim(%{{.*}}: !llvm.ptr<float>) { // BAREPTR-LABEL: func @static_memref_dim(%{{.*}}: !llvm.ptr<float>) {
func @static_memref_dim(%static : memref<42x32x15x13x27xf32>) { func @static_memref_dim(%static : memref<42x32x15x13x27xf32>) {
// CHECK: llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(42 : index) : i64
// BAREPTR: llvm.insertvalue %{{.*}}, %{{.*}}[4, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // BAREPTR: llvm.insertvalue %{{.*}}, %{{.*}}[4, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// BAREPTR: llvm.mlir.constant(42 : index) : !llvm.i64 // BAREPTR: llvm.mlir.constant(42 : index) : i64
%c0 = constant 0 : index %c0 = constant 0 : index
%0 = dim %static, %c0 : memref<42x32x15x13x27xf32> %0 = dim %static, %c0 : memref<42x32x15x13x27xf32>
// CHECK: llvm.mlir.constant(32 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(32 : index) : i64
// BAREPTR: llvm.mlir.constant(32 : index) : !llvm.i64 // BAREPTR: llvm.mlir.constant(32 : index) : i64
%c1 = constant 1 : index %c1 = constant 1 : index
%1 = dim %static, %c1 : memref<42x32x15x13x27xf32> %1 = dim %static, %c1 : memref<42x32x15x13x27xf32>
// CHECK: llvm.mlir.constant(15 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(15 : index) : i64
// BAREPTR: llvm.mlir.constant(15 : index) : !llvm.i64 // BAREPTR: llvm.mlir.constant(15 : index) : i64
%c2 = constant 2 : index %c2 = constant 2 : index
%2 = dim %static, %c2 : memref<42x32x15x13x27xf32> %2 = dim %static, %c2 : memref<42x32x15x13x27xf32>
// CHECK: llvm.mlir.constant(13 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(13 : index) : i64
// BAREPTR: llvm.mlir.constant(13 : index) : !llvm.i64 // BAREPTR: llvm.mlir.constant(13 : index) : i64
%c3 = constant 3 : index %c3 = constant 3 : index
%3 = dim %static, %c3 : memref<42x32x15x13x27xf32> %3 = dim %static, %c3 : memref<42x32x15x13x27xf32>
// CHECK: llvm.mlir.constant(27 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(27 : index) : i64
// BAREPTR: llvm.mlir.constant(27 : index) : !llvm.i64 // BAREPTR: llvm.mlir.constant(27 : index) : i64
%c4 = constant 4 : index %c4 = constant 4 : index
%4 = dim %static, %c4 : memref<42x32x15x13x27xf32> %4 = dim %static, %c4 : memref<42x32x15x13x27xf32>
return return
} }
// ----- // -----
// BAREPTR: llvm.func @foo(!llvm.ptr<i8>) -> !llvm.ptr<i8> // BAREPTR: llvm.func @foo(!llvm.ptr<i8>) -> !llvm.ptr<i8>
func private @foo(memref<10xi8>) -> memref<20xi8> func private @foo(memref<10xi8>) -> memref<20xi8>
// BAREPTR-LABEL: func @check_memref_func_call // BAREPTR-LABEL: func @check_memref_func_call
// BAREPTR-SAME: %[[in:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8> // BAREPTR-SAME: %[[in:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8>
func @check_memref_func_call(%in : memref<10xi8>) -> memref<20xi8> { func @check_memref_func_call(%in : memref<10xi8>) -> memref<20xi8> {
// BAREPTR: %[[inDesc:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] // BAREPTR: %[[inDesc:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0]
// BAREPTR-NEXT: %[[barePtr:.*]] = llvm.extractvalue %[[inDesc]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[barePtr:.*]] = llvm.extractvalue %[[inDesc]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[call:.*]] = llvm.call @foo(%[[barePtr]]) : (!llvm.ptr<i8>) -> !llvm.ptr<i8> // BAREPTR-NEXT: %[[call:.*]] = llvm.call @foo(%[[barePtr]]) : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
// BAREPTR-NEXT: %[[desc0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[desc0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[desc1:.*]] = llvm.insertvalue %[[call]], %[[desc0]][0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[desc1:.*]] = llvm.insertvalue %[[call]], %[[desc0]][0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[desc2:.*]] = llvm.insertvalue %[[call]], %[[desc1]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[desc2:.*]] = llvm.insertvalue %[[call]], %[[desc1]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// BAREPTR-NEXT: %[[desc4:.*]] = llvm.insertvalue %[[c0]], %[[desc2]][2] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[desc4:.*]] = llvm.insertvalue %[[c0]], %[[desc2]][2] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[c20:.*]] = llvm.mlir.constant(20 : index) : !llvm.i64 // BAREPTR-NEXT: %[[c20:.*]] = llvm.mlir.constant(20 : index) : i64
// BAREPTR-NEXT: %[[desc6:.*]] = llvm.insertvalue %[[c20]], %[[desc4]][3, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[desc6:.*]] = llvm.insertvalue %[[c20]], %[[desc4]][3, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // BAREPTR-NEXT: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// BAREPTR-NEXT: %[[outDesc:.*]] = llvm.insertvalue %[[c1]], %[[desc6]][4, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[outDesc:.*]] = llvm.insertvalue %[[c1]], %[[desc6]][4, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
%res = call @foo(%in) : (memref<10xi8>) -> (memref<20xi8>) %res = call @foo(%in) : (memref<10xi8>) -> (memref<20xi8>)
// BAREPTR-NEXT: %[[res:.*]] = llvm.extractvalue %[[outDesc]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // BAREPTR-NEXT: %[[res:.*]] = llvm.extractvalue %[[outDesc]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: llvm.return %[[res]] : !llvm.ptr<i8> // BAREPTR-NEXT: llvm.return %[[res]] : !llvm.ptr<i8>
return %res : memref<20xi8> return %res : memref<20xi8>
} }
// ----- // -----
Show All 28 Lines

mlir/test/Conversion/StandardToLLVM/convert-to-llvmir.mlir

// RUN: mlir-opt -convert-std-to-llvm %s -split-input-file | FileCheck %s // RUN: mlir-opt -convert-std-to-llvm %s -split-input-file | FileCheck %s
// RUN: mlir-opt -convert-std-to-llvm='index-bitwidth=32' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s // RUN: mlir-opt -convert-std-to-llvm='index-bitwidth=32' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
// CHECK-LABEL: func @empty() { // CHECK-LABEL: func @empty() {
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
// CHECK-NEXT: } // CHECK-NEXT: }
func @empty() { func @empty() {
^bb0: ^bb0:
return return
} }
// CHECK-LABEL: llvm.func @body(!llvm.i64) // CHECK-LABEL: llvm.func @body(i64)
func private @body(index) func private @body(index)
// CHECK-LABEL: func @simple_loop() { // CHECK-LABEL: func @simple_loop() {
// CHECK32-LABEL: func @simple_loop() { // CHECK32-LABEL: func @simple_loop() {
func @simple_loop() { func @simple_loop() {
^bb0: ^bb0:
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
// CHECK32-NEXT: llvm.br ^bb1 // CHECK32-NEXT: llvm.br ^bb1
br ^bb1 br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32-NEXT: ^bb1: // pred: ^bb0 // CHECK32-NEXT: ^bb1: // pred: ^bb0
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : !llvm.i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c1 = constant 1 : index %c1 = constant 1 : index
%c42 = constant 42 : index %c42 = constant 42 : index
br ^bb2(%c1 : index) br ^bb2(%c1 : index)
// CHECK: ^bb2({{.*}}: !llvm.i64): // 2 preds: ^bb1, ^bb3 // CHECK: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
// CHECK32: ^bb2({{.*}}: !llvm.i32): // 2 preds: ^bb1, ^bb3 // CHECK32: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3
// CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
^bb2(%0: index): // 2 preds: ^bb1, ^bb3 ^bb2(%0: index): // 2 preds: ^bb1, ^bb3
%1 = cmpi "slt", %0, %c42 : index %1 = cmpi "slt", %0, %c42 : index
cond_br %1, ^bb3, ^bb4 cond_br %1, ^bb3, ^bb4
// CHECK: ^bb3: // pred: ^bb2 // CHECK: ^bb3: // pred: ^bb2
// CHECK-NEXT: llvm.call @body({{.*}}) : (!llvm.i64) -> () // CHECK-NEXT: llvm.call @body({{.*}}) : (i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32: ^bb3: // pred: ^bb2 // CHECK32: ^bb3: // pred: ^bb2
// CHECK32-NEXT: llvm.call @body({{.*}}) : (!llvm.i32) -> () // CHECK32-NEXT: llvm.call @body({{.*}}) : (i32) -> ()
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : !llvm.i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
call @body(%0) : (index) -> () call @body(%0) : (index) -> ()
%c1_0 = constant 1 : index %c1_0 = constant 1 : index
%2 = addi %0, %c1_0 : index %2 = addi %0, %c1_0 : index
br ^bb2(%2 : index) br ^bb2(%2 : index)
// CHECK: ^bb4: // pred: ^bb2 // CHECK: ^bb4: // pred: ^bb2
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
// CHECK-NEXT: } // CHECK-NEXT: }
func @ml_caller() { func @ml_caller() {
^bb0: ^bb0:
call @simple_loop() : () -> () call @simple_loop() : () -> ()
call @more_imperfectly_nested_loops() : () -> () call @more_imperfectly_nested_loops() : () -> ()
return return
} }
// CHECK-LABEL: llvm.func @body_args(!llvm.i64) -> !llvm.i64 // CHECK-LABEL: llvm.func @body_args(i64) -> i64
// CHECK32-LABEL: llvm.func @body_args(!llvm.i32) -> !llvm.i32 // CHECK32-LABEL: llvm.func @body_args(i32) -> i32
func private @body_args(index) -> index func private @body_args(index) -> index
// CHECK-LABEL: llvm.func @other(!llvm.i64, !llvm.i32) -> !llvm.i32 // CHECK-LABEL: llvm.func @other(i64, i32) -> i32
// CHECK32-LABEL: llvm.func @other(!llvm.i32, !llvm.i32) -> !llvm.i32 // CHECK32-LABEL: llvm.func @other(i32, i32) -> i32
func private @other(index, i32) -> i32 func private @other(index, i32) -> i32
// CHECK-LABEL: func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 { // CHECK-LABEL: func @func_args(%arg0: i32, %arg1: i32) -> i32 {
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : i32
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
// CHECK32-LABEL: func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 { // CHECK32-LABEL: func @func_args(%arg0: i32, %arg1: i32) -> i32 {
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : i32
// CHECK32-NEXT: llvm.br ^bb1 // CHECK32-NEXT: llvm.br ^bb1
func @func_args(i32, i32) -> i32 { func @func_args(i32, i32) -> i32 {
^bb0(%arg0: i32, %arg1: i32): ^bb0(%arg0: i32, %arg1: i32):
%c0_i32 = constant 0 : i32 %c0_i32 = constant 0 : i32
br ^bb1 br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32-NEXT: ^bb1: // pred: ^bb0 // CHECK32-NEXT: ^bb1: // pred: ^bb0
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : !llvm.i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c0 = constant 0 : index %c0 = constant 0 : index
%c42 = constant 42 : index %c42 = constant 42 : index
br ^bb2(%c0 : index) br ^bb2(%c0 : index)
// CHECK-NEXT: ^bb2({{.*}}: !llvm.i64): // 2 preds: ^bb1, ^bb3 // CHECK-NEXT: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
// CHECK32-NEXT: ^bb2({{.*}}: !llvm.i32): // 2 preds: ^bb1, ^bb3 // CHECK32-NEXT: ^bb2({{.*}}: i32): // 2 preds: ^bb1, ^bb3
// CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4 // CHECK32-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb4
^bb2(%0: index): // 2 preds: ^bb1, ^bb3 ^bb2(%0: index): // 2 preds: ^bb1, ^bb3
%1 = cmpi "slt", %0, %c42 : index %1 = cmpi "slt", %0, %c42 : index
cond_br %1, ^bb3, ^bb4 cond_br %1, ^bb3, ^bb4
// CHECK-NEXT: ^bb3: // pred: ^bb2 // CHECK-NEXT: ^bb3: // pred: ^bb2
// CHECK-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (!llvm.i64) -> !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (i64) -> i64
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (!llvm.i64, !llvm.i32) -> !llvm.i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (i64, i32) -> i32
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i32) -> !llvm.i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i64, i32) -> i32
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (!llvm.i64, !llvm.i32) -> !llvm.i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (i64, i32) -> i32
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK32-NEXT: ^bb3: // pred: ^bb2 // CHECK32-NEXT: ^bb3: // pred: ^bb2
// CHECK32-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (!llvm.i32) -> !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.call @body_args({{.*}}) : (i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (!llvm.i32, !llvm.i32) -> !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (i32, i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (!llvm.i32, !llvm.i32) -> !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i32, i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (i32, i32) -> i32
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i32
// CHECK32-NEXT: llvm.br ^bb2({{.*}} : !llvm.i32) // CHECK32-NEXT: llvm.br ^bb2({{.*}} : i32)
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
%2 = call @body_args(%0) : (index) -> index %2 = call @body_args(%0) : (index) -> index
%3 = call @other(%2, %arg0) : (index, i32) -> i32 %3 = call @other(%2, %arg0) : (index, i32) -> i32
%4 = call @other(%2, %3) : (index, i32) -> i32 %4 = call @other(%2, %3) : (index, i32) -> i32
%5 = call @other(%2, %arg1) : (index, i32) -> i32 %5 = call @other(%2, %arg1) : (index, i32) -> i32
%c1 = constant 1 : index %c1 = constant 1 : index
%6 = addi %0, %c1 : index %6 = addi %0, %c1 : index
br ^bb2(%6 : index) br ^bb2(%6 : index)
// CHECK-NEXT: ^bb4: // pred: ^bb2 // CHECK-NEXT: ^bb4: // pred: ^bb2
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i32) -> !llvm.i32 // CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i64, i32) -> i32
// CHECK-NEXT: llvm.return {{.*}} : !llvm.i32 // CHECK-NEXT: llvm.return {{.*}} : i32
// CHECK32-NEXT: ^bb4: // pred: ^bb2 // CHECK32-NEXT: ^bb4: // pred: ^bb2
// CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i32
// CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (!llvm.i32, !llvm.i32) -> !llvm.i32 // CHECK32-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (i32, i32) -> i32
// CHECK32-NEXT: llvm.return {{.*}} : !llvm.i32 // CHECK32-NEXT: llvm.return {{.*}} : i32
^bb4: // pred: ^bb2 ^bb4: // pred: ^bb2
%c0_0 = constant 0 : index %c0_0 = constant 0 : index
%7 = call @other(%c0_0, %c0_i32) : (index, i32) -> i32 %7 = call @other(%c0_0, %c0_i32) : (index, i32) -> i32
return %7 : i32 return %7 : i32
} }
// CHECK-LABEL: llvm.func @pre(!llvm.i64) // CHECK-LABEL: llvm.func @pre(i64)
// CHECK32-LABEL: llvm.func @pre(!llvm.i32) // CHECK32-LABEL: llvm.func @pre(i32)
func private @pre(index) func private @pre(index)
// CHECK-LABEL: llvm.func @body2(!llvm.i64, !llvm.i64) // CHECK-LABEL: llvm.func @body2(i64, i64)
// CHECK32-LABEL: llvm.func @body2(!llvm.i32, !llvm.i32) // CHECK32-LABEL: llvm.func @body2(i32, i32)
func private @body2(index, index) func private @body2(index, index)
// CHECK-LABEL: llvm.func @post(!llvm.i64) // CHECK-LABEL: llvm.func @post(i64)
// CHECK32-LABEL: llvm.func @post(!llvm.i32) // CHECK32-LABEL: llvm.func @post(i32)
func private @post(index) func private @post(index)
// CHECK-LABEL: func @imperfectly_nested_loops() { // CHECK-LABEL: func @imperfectly_nested_loops() {
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
func @imperfectly_nested_loops() { func @imperfectly_nested_loops() {
^bb0: ^bb0:
br ^bb1 br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0 // CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c0 = constant 0 : index %c0 = constant 0 : index
%c42 = constant 42 : index %c42 = constant 42 : index
br ^bb2(%c0 : index) br ^bb2(%c0 : index)
// CHECK-NEXT: ^bb2({{.*}}: !llvm.i64): // 2 preds: ^bb1, ^bb7 // CHECK-NEXT: ^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb7
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb8 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb8
^bb2(%0: index): // 2 preds: ^bb1, ^bb7 ^bb2(%0: index): // 2 preds: ^bb1, ^bb7
%1 = cmpi "slt", %0, %c42 : index %1 = cmpi "slt", %0, %c42 : index
cond_br %1, ^bb3, ^bb8 cond_br %1, ^bb3, ^bb8
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
// CHECK-NEXT: llvm.call @pre({{.*}}) : (!llvm.i64) -> () // CHECK-NEXT: llvm.call @pre({{.*}}) : (i64) -> ()
// CHECK-NEXT: llvm.br ^bb4 // CHECK-NEXT: llvm.br ^bb4
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
call @pre(%0) : (index) -> () call @pre(%0) : (index) -> ()
br ^bb4 br ^bb4
// CHECK-NEXT: ^bb4: // pred: ^bb3 // CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb5({{.*}} : i64)
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
%c7 = constant 7 : index %c7 = constant 7 : index
%c56 = constant 56 : index %c56 = constant 56 : index
br ^bb5(%c7 : index) br ^bb5(%c7 : index)
// CHECK-NEXT: ^bb5({{.*}}: !llvm.i64): // 2 preds: ^bb4, ^bb6 // CHECK-NEXT: ^bb5({{.*}}: i64): // 2 preds: ^bb4, ^bb6
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7
^bb5(%2: index): // 2 preds: ^bb4, ^bb6 ^bb5(%2: index): // 2 preds: ^bb4, ^bb6
%3 = cmpi "slt", %2, %c56 : index %3 = cmpi "slt", %2, %c56 : index
cond_br %3, ^bb6, ^bb7 cond_br %3, ^bb6, ^bb7
// CHECK-NEXT: ^bb6: // pred: ^bb5 // CHECK-NEXT: ^bb6: // pred: ^bb5
// CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i64) -> () // CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (i64, i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb5({{.*}} : i64)
^bb6: // pred: ^bb5 ^bb6: // pred: ^bb5
call @body2(%0, %2) : (index, index) -> () call @body2(%0, %2) : (index, index) -> ()
%c2 = constant 2 : index %c2 = constant 2 : index
%4 = addi %2, %c2 : index %4 = addi %2, %c2 : index
br ^bb5(%4 : index) br ^bb5(%4 : index)
// CHECK-NEXT: ^bb7: // pred: ^bb5 // CHECK-NEXT: ^bb7: // pred: ^bb5
// CHECK-NEXT: llvm.call @post({{.*}}) : (!llvm.i64) -> () // CHECK-NEXT: llvm.call @post({{.*}}) : (i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
^bb7: // pred: ^bb5 ^bb7: // pred: ^bb5
call @post(%0) : (index) -> () call @post(%0) : (index) -> ()
%c1 = constant 1 : index %c1 = constant 1 : index
%5 = addi %0, %c1 : index %5 = addi %0, %c1 : index
br ^bb2(%5 : index) br ^bb2(%5 : index)
// CHECK-NEXT: ^bb8: // pred: ^bb2 // CHECK-NEXT: ^bb8: // pred: ^bb2
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
^bb8: // pred: ^bb2 ^bb8: // pred: ^bb2
return return
} }
// CHECK-LABEL: llvm.func @mid(!llvm.i64) // CHECK-LABEL: llvm.func @mid(i64)
func private @mid(index) func private @mid(index)
// CHECK-LABEL: llvm.func @body3(!llvm.i64, !llvm.i64) // CHECK-LABEL: llvm.func @body3(i64, i64)
func private @body3(index, index) func private @body3(index, index)
// A complete function transformation check. // A complete function transformation check.
// CHECK-LABEL: func @more_imperfectly_nested_loops() { // CHECK-LABEL: func @more_imperfectly_nested_loops() {
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
// CHECK-NEXT:^bb1: // pred: ^bb0 // CHECK-NEXT:^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK-NEXT:^bb2({{.*}}: !llvm.i64): // 2 preds: ^bb1, ^bb11 // CHECK-NEXT:^bb2({{.*}}: i64): // 2 preds: ^bb1, ^bb11
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb12 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb3, ^bb12
// CHECK-NEXT:^bb3: // pred: ^bb2 // CHECK-NEXT:^bb3: // pred: ^bb2
// CHECK-NEXT: llvm.call @pre({{.*}}) : (!llvm.i64) -> () // CHECK-NEXT: llvm.call @pre({{.*}}) : (i64) -> ()
// CHECK-NEXT: llvm.br ^bb4 // CHECK-NEXT: llvm.br ^bb4
// CHECK-NEXT:^bb4: // pred: ^bb3 // CHECK-NEXT:^bb4: // pred: ^bb3
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb5({{.*}} : i64)
// CHECK-NEXT:^bb5({{.*}}: !llvm.i64): // 2 preds: ^bb4, ^bb6 // CHECK-NEXT:^bb5({{.*}}: i64): // 2 preds: ^bb4, ^bb6
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7
// CHECK-NEXT:^bb6: // pred: ^bb5 // CHECK-NEXT:^bb6: // pred: ^bb5
// CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i64) -> () // CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (i64, i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb5({{.*}} : i64)
// CHECK-NEXT:^bb7: // pred: ^bb5 // CHECK-NEXT:^bb7: // pred: ^bb5
// CHECK-NEXT: llvm.call @mid({{.*}}) : (!llvm.i64) -> () // CHECK-NEXT: llvm.call @mid({{.*}}) : (i64) -> ()
// CHECK-NEXT: llvm.br ^bb8 // CHECK-NEXT: llvm.br ^bb8
// CHECK-NEXT:^bb8: // pred: ^bb7 // CHECK-NEXT:^bb8: // pred: ^bb7
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(18 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(18 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(37 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(37 : index) : i64
// CHECK-NEXT: llvm.br ^bb9({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb9({{.*}} : i64)
// CHECK-NEXT:^bb9({{.*}}: !llvm.i64): // 2 preds: ^bb8, ^bb10 // CHECK-NEXT:^bb9({{.*}}: i64): // 2 preds: ^bb8, ^bb10
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb10, ^bb11 // CHECK-NEXT: llvm.cond_br {{.*}}, ^bb10, ^bb11
// CHECK-NEXT:^bb10: // pred: ^bb9 // CHECK-NEXT:^bb10: // pred: ^bb9
// CHECK-NEXT: llvm.call @body3({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i64) -> () // CHECK-NEXT: llvm.call @body3({{.*}}, {{.*}}) : (i64, i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(3 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb9({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb9({{.*}} : i64)
// CHECK-NEXT:^bb11: // pred: ^bb9 // CHECK-NEXT:^bb11: // pred: ^bb9
// CHECK-NEXT: llvm.call @post({{.*}}) : (!llvm.i64) -> () // CHECK-NEXT: llvm.call @post({{.*}}) : (i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64) // CHECK-NEXT: llvm.br ^bb2({{.*}} : i64)
// CHECK-NEXT:^bb12: // pred: ^bb2 // CHECK-NEXT:^bb12: // pred: ^bb2
// CHECK-NEXT: llvm.return // CHECK-NEXT: llvm.return
// CHECK-NEXT: } // CHECK-NEXT: }
func @more_imperfectly_nested_loops() { func @more_imperfectly_nested_loops() {
^bb0: ^bb0:
br ^bb1 br ^bb1
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%c0 = constant 0 : index %c0 = constant 0 : index
Show All 36 Lines^bb11: // pred: ^bb9
call @post(%0) : (index) -> () call @post(%0) : (index) -> ()
%c1 = constant 1 : index %c1 = constant 1 : index
%8 = addi %0, %c1 : index %8 = addi %0, %c1 : index
br ^bb2(%8 : index) br ^bb2(%8 : index)
^bb12: // pred: ^bb2 ^bb12: // pred: ^bb2
return return
} }
// CHECK-LABEL: llvm.func @get_i64() -> !llvm.i64 // CHECK-LABEL: llvm.func @get_i64() -> i64
func private @get_i64() -> (i64) func private @get_i64() -> (i64)
// CHECK-LABEL: llvm.func @get_f32() -> !llvm.float // CHECK-LABEL: llvm.func @get_f32() -> !llvm.float
func private @get_f32() -> (f32) func private @get_f32() -> (f32)
// CHECK-LABEL: llvm.func @get_c16() -> !llvm.struct<(half, half)> // CHECK-LABEL: llvm.func @get_c16() -> !llvm.struct<(half, half)>
func private @get_c16() -> (complex<f16>) func private @get_c16() -> (complex<f16>)
// CHECK-LABEL: llvm.func @get_c32() -> !llvm.struct<(float, float)> // CHECK-LABEL: llvm.func @get_c32() -> !llvm.struct<(float, float)>
func private @get_c32() -> (complex<f32>) func private @get_c32() -> (complex<f32>)
// CHECK-LABEL: llvm.func @get_c64() -> !llvm.struct<(double, double)> // CHECK-LABEL: llvm.func @get_c64() -> !llvm.struct<(double, double)>
func private @get_c64() -> (complex<f64>) func private @get_c64() -> (complex<f64>)
// CHECK-LABEL: llvm.func @get_memref() -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)> // CHECK-LABEL: llvm.func @get_memref() -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>
// CHECK32-LABEL: llvm.func @get_memref() -> !llvm.struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)> // CHECK32-LABEL: llvm.func @get_memref() -> !llvm.struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>
func private @get_memref() -> (memref<42x?x10x?xf32>) func private @get_memref() -> (memref<42x?x10x?xf32>)
// CHECK-LABEL: llvm.func @multireturn() -> !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> { // CHECK-LABEL: llvm.func @multireturn() -> !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> {
// CHECK32-LABEL: llvm.func @multireturn() -> !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)> { // CHECK32-LABEL: llvm.func @multireturn() -> !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)> {
func @multireturn() -> (i64, f32, memref<42x?x10x?xf32>) { func @multireturn() -> (i64, f32, memref<42x?x10x?xf32>) {
^bb0: ^bb0:
// CHECK-NEXT: {{.*}} = llvm.call @get_i64() : () -> !llvm.i64 // CHECK-NEXT: {{.*}} = llvm.call @get_i64() : () -> i64
// CHECK-NEXT: {{.*}} = llvm.call @get_f32() : () -> !llvm.float // CHECK-NEXT: {{.*}} = llvm.call @get_f32() : () -> !llvm.float
// CHECK-NEXT: {{.*}} = llvm.call @get_memref() : () -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)> // CHECK-NEXT: {{.*}} = llvm.call @get_memref() : () -> !llvm.struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>
// CHECK32-NEXT: {{.*}} = llvm.call @get_i64() : () -> !llvm.i64 // CHECK32-NEXT: {{.*}} = llvm.call @get_i64() : () -> i64
// CHECK32-NEXT: {{.*}} = llvm.call @get_f32() : () -> !llvm.float // CHECK32-NEXT: {{.*}} = llvm.call @get_f32() : () -> !llvm.float
// CHECK32-NEXT: {{.*}} = llvm.call @get_memref() : () -> !llvm.struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)> // CHECK32-NEXT: {{.*}} = llvm.call @get_memref() : () -> !llvm.struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>
%0 = call @get_i64() : () -> (i64) %0 = call @get_i64() : () -> (i64)
%1 = call @get_f32() : () -> (f32) %1 = call @get_f32() : () -> (f32)
%2 = call @get_memref() : () -> (memref<42x?x10x?xf32>) %2 = call @get_memref() : () -> (memref<42x?x10x?xf32>)
// CHECK-NEXT: {{.*}} = llvm.mlir.undef : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> // CHECK-NEXT: {{.*}} = llvm.mlir.undef : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)>
// CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[0] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> // CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[0] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)>
// CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[1] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> // CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[1] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)>
Show All 17 Lines
// CHECK-NEXT: {{.*}} = llvm.extractvalue {{.*}}[1] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> // CHECK-NEXT: {{.*}} = llvm.extractvalue {{.*}}[1] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)>
// CHECK-NEXT: {{.*}} = llvm.extractvalue {{.*}}[2] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)> // CHECK-NEXT: {{.*}} = llvm.extractvalue {{.*}}[2] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i64, array<4 x i64>, array<4 x i64>)>)>
// CHECK32-NEXT: {{.*}} = llvm.call @multireturn() : () -> !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)> // CHECK32-NEXT: {{.*}} = llvm.call @multireturn() : () -> !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)>
// CHECK32-NEXT: {{.*}} = llvm.extractvalue {{.*}}[0] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)> // CHECK32-NEXT: {{.*}} = llvm.extractvalue {{.*}}[0] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)>
// CHECK32-NEXT: {{.*}} = llvm.extractvalue {{.*}}[1] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)> // CHECK32-NEXT: {{.*}} = llvm.extractvalue {{.*}}[1] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)>
// CHECK32-NEXT: {{.*}} = llvm.extractvalue {{.*}}[2] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)> // CHECK32-NEXT: {{.*}} = llvm.extractvalue {{.*}}[2] : !llvm.struct<(i64, float, struct<(ptr<float>, ptr<float>, i32, array<4 x i32>, array<4 x i32>)>)>
%0:3 = call @multireturn() : () -> (i64, f32, memref<42x?x10x?xf32>) %0:3 = call @multireturn() : () -> (i64, f32, memref<42x?x10x?xf32>)
%1 = constant 42 : i64 %1 = constant 42 : i64
// CHECK: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64 // CHECK: {{.*}} = llvm.add {{.*}}, {{.*}} : i64
%2 = addi %0#0, %1 : i64 %2 = addi %0#0, %1 : i64
%3 = constant 42.0 : f32 %3 = constant 42.0 : f32
// CHECK: {{.*}} = llvm.fadd {{.*}}, {{.*}} : !llvm.float // CHECK: {{.*}} = llvm.fadd {{.*}}, {{.*}} : !llvm.float
%4 = addf %0#1, %3 : f32 %4 = addf %0#1, %3 : f32
%5 = constant 0 : index %5 = constant 0 : index
return return
} }
Show All 30 Lines// CHECK-NEXT: %13 = llvm.lshr %arg2, %arg2 : !llvm.vec<4 x i64>
return %1 : vector<4xf32> return %1 : vector<4xf32>
} }
// CHECK-LABEL: @ops // CHECK-LABEL: @ops
func @ops(f32, f32, i32, i32, f64) -> (f32, i32) { func @ops(f32, f32, i32, i32, f64) -> (f32, i32) {
^bb0(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64): ^bb0(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: i32, %arg4: f64):
// CHECK-NEXT: %0 = llvm.fsub %arg0, %arg1 : !llvm.float // CHECK-NEXT: %0 = llvm.fsub %arg0, %arg1 : !llvm.float
%0 = subf %arg0, %arg1: f32 %0 = subf %arg0, %arg1: f32
// CHECK-NEXT: %1 = llvm.sub %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %1 = llvm.sub %arg2, %arg3 : i32
%1 = subi %arg2, %arg3: i32 %1 = subi %arg2, %arg3: i32
// CHECK-NEXT: %2 = llvm.icmp "slt" %arg2, %1 : !llvm.i32 // CHECK-NEXT: %2 = llvm.icmp "slt" %arg2, %1 : i32
%2 = cmpi "slt", %arg2, %1 : i32 %2 = cmpi "slt", %arg2, %1 : i32
// CHECK-NEXT: %3 = llvm.sdiv %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %3 = llvm.sdiv %arg2, %arg3 : i32
%3 = divi_signed %arg2, %arg3 : i32 %3 = divi_signed %arg2, %arg3 : i32
// CHECK-NEXT: %4 = llvm.udiv %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %4 = llvm.udiv %arg2, %arg3 : i32
%4 = divi_unsigned %arg2, %arg3 : i32 %4 = divi_unsigned %arg2, %arg3 : i32
// CHECK-NEXT: %5 = llvm.srem %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %5 = llvm.srem %arg2, %arg3 : i32
%5 = remi_signed %arg2, %arg3 : i32 %5 = remi_signed %arg2, %arg3 : i32
// CHECK-NEXT: %6 = llvm.urem %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %6 = llvm.urem %arg2, %arg3 : i32
%6 = remi_unsigned %arg2, %arg3 : i32 %6 = remi_unsigned %arg2, %arg3 : i32
// CHECK-NEXT: %7 = llvm.select %2, %arg2, %arg3 : !llvm.i1, !llvm.i32 // CHECK-NEXT: %7 = llvm.select %2, %arg2, %arg3 : i1, i32
%7 = select %2, %arg2, %arg3 : i32 %7 = select %2, %arg2, %arg3 : i32
// CHECK-NEXT: %8 = llvm.fdiv %arg0, %arg1 : !llvm.float // CHECK-NEXT: %8 = llvm.fdiv %arg0, %arg1 : !llvm.float
%8 = divf %arg0, %arg1 : f32 %8 = divf %arg0, %arg1 : f32
// CHECK-NEXT: %9 = llvm.frem %arg0, %arg1 : !llvm.float // CHECK-NEXT: %9 = llvm.frem %arg0, %arg1 : !llvm.float
%9 = remf %arg0, %arg1 : f32 %9 = remf %arg0, %arg1 : f32
// CHECK-NEXT: %10 = llvm.and %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %10 = llvm.and %arg2, %arg3 : i32
%10 = and %arg2, %arg3 : i32 %10 = and %arg2, %arg3 : i32
// CHECK-NEXT: %11 = llvm.or %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %11 = llvm.or %arg2, %arg3 : i32
%11 = or %arg2, %arg3 : i32 %11 = or %arg2, %arg3 : i32
// CHECK-NEXT: %12 = llvm.xor %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %12 = llvm.xor %arg2, %arg3 : i32
%12 = xor %arg2, %arg3 : i32 %12 = xor %arg2, %arg3 : i32
// CHECK-NEXT: %13 = "llvm.intr.exp"(%arg0) : (!llvm.float) -> !llvm.float // CHECK-NEXT: %13 = "llvm.intr.exp"(%arg0) : (!llvm.float) -> !llvm.float
%13 = std.exp %arg0 : f32 %13 = std.exp %arg0 : f32
// CHECK-NEXT: %14 = "llvm.intr.exp2"(%arg0) : (!llvm.float) -> !llvm.float // CHECK-NEXT: %14 = "llvm.intr.exp2"(%arg0) : (!llvm.float) -> !llvm.float
%14 = std.exp2 %arg0 : f32 %14 = std.exp2 %arg0 : f32
// CHECK-NEXT: %15 = llvm.mlir.constant(7.900000e-01 : f64) : !llvm.double // CHECK-NEXT: %15 = llvm.mlir.constant(7.900000e-01 : f64) : !llvm.double
%15 = constant 7.9e-01 : f64 %15 = constant 7.9e-01 : f64
// CHECK-NEXT: %16 = llvm.shl %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %16 = llvm.shl %arg2, %arg3 : i32
%16 = shift_left %arg2, %arg3 : i32 %16 = shift_left %arg2, %arg3 : i32
// CHECK-NEXT: %17 = llvm.ashr %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %17 = llvm.ashr %arg2, %arg3 : i32
%17 = shift_right_signed %arg2, %arg3 : i32 %17 = shift_right_signed %arg2, %arg3 : i32
// CHECK-NEXT: %18 = llvm.lshr %arg2, %arg3 : !llvm.i32 // CHECK-NEXT: %18 = llvm.lshr %arg2, %arg3 : i32
%18 = shift_right_unsigned %arg2, %arg3 : i32 %18 = shift_right_unsigned %arg2, %arg3 : i32
// CHECK-NEXT: %{{[0-9]+}} = "llvm.intr.sqrt"(%arg0) : (!llvm.float) -> !llvm.float // CHECK-NEXT: %{{[0-9]+}} = "llvm.intr.sqrt"(%arg0) : (!llvm.float) -> !llvm.float
%19 = std.sqrt %arg0 : f32 %19 = std.sqrt %arg0 : f32
// CHECK-NEXT: %{{[0-9]+}} = "llvm.intr.sqrt"(%arg4) : (!llvm.double) -> !llvm.double // CHECK-NEXT: %{{[0-9]+}} = "llvm.intr.sqrt"(%arg4) : (!llvm.double) -> !llvm.double
%20 = std.sqrt %arg4 : f64 %20 = std.sqrt %arg4 : f64
return %0, %4 : f32, i32 return %0, %4 : f32, i32
} }
// Checking conversion of index types to integers using i1, assuming no target // Checking conversion of index types to integers using i1, assuming no target
// system would have a 1-bit address space. Otherwise, we would have had to // system would have a 1-bit address space. Otherwise, we would have had to
// make this test dependent on the pointer size on the target system. // make this test dependent on the pointer size on the target system.
// CHECK-LABEL: @index_cast // CHECK-LABEL: @index_cast
func @index_cast(%arg0: index, %arg1: i1) { func @index_cast(%arg0: index, %arg1: i1) {
// CHECK-NEXT: = llvm.trunc %arg0 : !llvm.i{{.*}} to !llvm.i1 // CHECK-NEXT: = llvm.trunc %arg0 : i{{.*}} to i1
%0 = index_cast %arg0: index to i1 %0 = index_cast %arg0: index to i1
// CHECK-NEXT: = llvm.sext %arg1 : !llvm.i1 to !llvm.i{{.*}} // CHECK-NEXT: = llvm.sext %arg1 : i1 to i{{.*}}
%1 = index_cast %arg1: i1 to index %1 = index_cast %arg1: i1 to index
return return
} }
// Checking conversion of signed integer types to floating point. // Checking conversion of signed integer types to floating point.
// CHECK-LABEL: @sitofp // CHECK-LABEL: @sitofp
func @sitofp(%arg0 : i32, %arg1 : i64) { func @sitofp(%arg0 : i32, %arg1 : i64) {
// CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i32 to !llvm.float // CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to !llvm.float
%0 = sitofp %arg0: i32 to f32 %0 = sitofp %arg0: i32 to f32
// CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i32 to !llvm.double // CHECK-NEXT: = llvm.sitofp {{.*}} : i32 to !llvm.double
%1 = sitofp %arg0: i32 to f64 %1 = sitofp %arg0: i32 to f64
// CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i64 to !llvm.float // CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to !llvm.float
%2 = sitofp %arg1: i64 to f32 %2 = sitofp %arg1: i64 to f32
// CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.i64 to !llvm.double // CHECK-NEXT: = llvm.sitofp {{.*}} : i64 to !llvm.double
%3 = sitofp %arg1: i64 to f64 %3 = sitofp %arg1: i64 to f64
return return
} }
// Checking conversion of integer vectors to floating point vector types. // Checking conversion of integer vectors to floating point vector types.
// CHECK-LABEL: @sitofp_vector // CHECK-LABEL: @sitofp_vector
func @sitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) { func @sitofp_vector(%arg0 : vector<2xi16>, %arg1 : vector<2xi32>, %arg2 : vector<2xi64>) {
// CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.vec<2 x i16> to !llvm.vec<2 x float> // CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.vec<2 x i16> to !llvm.vec<2 x float>
Show All 9 Lines
// CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.vec<2 x i64> to !llvm.vec<2 x double> // CHECK-NEXT: = llvm.sitofp {{.*}} : !llvm.vec<2 x i64> to !llvm.vec<2 x double>
%5 = sitofp %arg2: vector<2xi64> to vector<2xf64> %5 = sitofp %arg2: vector<2xi64> to vector<2xf64>
return return
} }
// Checking conversion of unsigned integer types to floating point. // Checking conversion of unsigned integer types to floating point.
// CHECK-LABEL: @uitofp // CHECK-LABEL: @uitofp
func @uitofp(%arg0 : i32, %arg1 : i64) { func @uitofp(%arg0 : i32, %arg1 : i64) {
// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i32 to !llvm.float // CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to !llvm.float
%0 = uitofp %arg0: i32 to f32 %0 = uitofp %arg0: i32 to f32
// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i32 to !llvm.double // CHECK-NEXT: = llvm.uitofp {{.*}} : i32 to !llvm.double
%1 = uitofp %arg0: i32 to f64 %1 = uitofp %arg0: i32 to f64
// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i64 to !llvm.float // CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to !llvm.float
%2 = uitofp %arg1: i64 to f32 %2 = uitofp %arg1: i64 to f32
// CHECK-NEXT: = llvm.uitofp {{.*}} : !llvm.i64 to !llvm.double // CHECK-NEXT: = llvm.uitofp {{.*}} : i64 to !llvm.double
%3 = uitofp %arg1: i64 to f64 %3 = uitofp %arg1: i64 to f64
return return
} }
// Checking conversion of integer types to floating point. // Checking conversion of integer types to floating point.
// CHECK-LABEL: @fpext // CHECK-LABEL: @fpext
func @fpext(%arg0 : f16, %arg1 : f32) { func @fpext(%arg0 : f16, %arg1 : f32) {
// CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.half to !llvm.float // CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.half to !llvm.float
Show All 15 Lines
// CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.vec<2 x float> to !llvm.vec<2 x double> // CHECK-NEXT: = llvm.fpext {{.*}} : !llvm.vec<2 x float> to !llvm.vec<2 x double>
%2 = fpext %arg1: vector<2xf32> to vector<2xf64> %2 = fpext %arg1: vector<2xf32> to vector<2xf64>
return return
} }
// Checking conversion of floating point to integer types. // Checking conversion of floating point to integer types.
// CHECK-LABEL: @fptosi // CHECK-LABEL: @fptosi
func @fptosi(%arg0 : f32, %arg1 : f64) { func @fptosi(%arg0 : f32, %arg1 : f64) {
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.float to !llvm.i32 // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.float to i32
%0 = fptosi %arg0: f32 to i32 %0 = fptosi %arg0: f32 to i32
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.float to !llvm.i64 // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.float to i64
%1 = fptosi %arg0: f32 to i64 %1 = fptosi %arg0: f32 to i64
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.double to !llvm.i32 // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.double to i32
%2 = fptosi %arg1: f64 to i32 %2 = fptosi %arg1: f64 to i32
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.double to !llvm.i64 // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.double to i64
%3 = fptosi %arg1: f64 to i64 %3 = fptosi %arg1: f64 to i64
return return
} }
// Checking conversion of floating point vectors to integer vector types. // Checking conversion of floating point vectors to integer vector types.
// CHECK-LABEL: @fptosi_vector // CHECK-LABEL: @fptosi_vector
func @fptosi_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) { func @fptosi_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) {
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.vec<2 x half> to !llvm.vec<2 x i32> // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.vec<2 x half> to !llvm.vec<2 x i32>
Show All 9 Lines
// CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.vec<2 x double> to !llvm.vec<2 x i64> // CHECK-NEXT: = llvm.fptosi {{.*}} : !llvm.vec<2 x double> to !llvm.vec<2 x i64>
%5 = fptosi %arg2: vector<2xf64> to vector<2xi64> %5 = fptosi %arg2: vector<2xf64> to vector<2xi64>
return return
} }
// Checking conversion of floating point to integer types. // Checking conversion of floating point to integer types.
// CHECK-LABEL: @fptoui // CHECK-LABEL: @fptoui
func @fptoui(%arg0 : f32, %arg1 : f64) { func @fptoui(%arg0 : f32, %arg1 : f64) {
// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.float to !llvm.i32 // CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.float to i32
%0 = fptoui %arg0: f32 to i32 %0 = fptoui %arg0: f32 to i32
// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.float to !llvm.i64 // CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.float to i64
%1 = fptoui %arg0: f32 to i64 %1 = fptoui %arg0: f32 to i64
// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.double to !llvm.i32 // CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.double to i32
%2 = fptoui %arg1: f64 to i32 %2 = fptoui %arg1: f64 to i32
// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.double to !llvm.i64 // CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.double to i64
%3 = fptoui %arg1: f64 to i64 %3 = fptoui %arg1: f64 to i64
return return
} }
// Checking conversion of floating point vectors to integer vector types. // Checking conversion of floating point vectors to integer vector types.
// CHECK-LABEL: @fptoui_vector // CHECK-LABEL: @fptoui_vector
func @fptoui_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) { func @fptoui_vector(%arg0 : vector<2xf16>, %arg1 : vector<2xf32>, %arg2 : vector<2xf64>) {
// CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.vec<2 x half> to !llvm.vec<2 x i32> // CHECK-NEXT: = llvm.fptoui {{.*}} : !llvm.vec<2 x half> to !llvm.vec<2 x i32>
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
// CHECK-NEXT: = llvm.fptrunc {{.*}} : !llvm.vec<2 x double> to !llvm.vec<2 x float> // CHECK-NEXT: = llvm.fptrunc {{.*}} : !llvm.vec<2 x double> to !llvm.vec<2 x float>
%2 = fptrunc %arg1: vector<2xf64> to vector<2xf32> %2 = fptrunc %arg1: vector<2xf64> to vector<2xf32>
return return
} }
// Check sign and zero extension and truncation of integers. // Check sign and zero extension and truncation of integers.
// CHECK-LABEL: @integer_extension_and_truncation // CHECK-LABEL: @integer_extension_and_truncation
func @integer_extension_and_truncation() { func @integer_extension_and_truncation() {
// CHECK-NEXT: %0 = llvm.mlir.constant(-3 : i3) : !llvm.i3 // CHECK-NEXT: %0 = llvm.mlir.constant(-3 : i3) : i3
%0 = constant 5 : i3 %0 = constant 5 : i3
// CHECK-NEXT: = llvm.sext %0 : !llvm.i3 to !llvm.i6 // CHECK-NEXT: = llvm.sext %0 : i3 to i6
%1 = sexti %0 : i3 to i6 %1 = sexti %0 : i3 to i6
// CHECK-NEXT: = llvm.zext %0 : !llvm.i3 to !llvm.i6 // CHECK-NEXT: = llvm.zext %0 : i3 to i6
%2 = zexti %0 : i3 to i6 %2 = zexti %0 : i3 to i6
// CHECK-NEXT: = llvm.trunc %0 : !llvm.i3 to !llvm.i2 // CHECK-NEXT: = llvm.trunc %0 : i3 to i2
%3 = trunci %0 : i3 to i2 %3 = trunci %0 : i3 to i2
return return
} }
// CHECK-LABEL: @dfs_block_order // CHECK-LABEL: @dfs_block_order
func @dfs_block_order(%arg0: i32) -> (i32) { func @dfs_block_order(%arg0: i32) -> (i32) {
// CHECK-NEXT: %[[CST:.*]] = llvm.mlir.constant(42 : i32) : !llvm.i32 // CHECK-NEXT: %[[CST:.*]] = llvm.mlir.constant(42 : i32) : i32
%0 = constant 42 : i32 %0 = constant 42 : i32
// CHECK-NEXT: llvm.br ^bb2 // CHECK-NEXT: llvm.br ^bb2
br ^bb2 br ^bb2
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: %[[ADD:.*]] = llvm.add %arg0, %[[CST]] : !llvm.i32 // CHECK-NEXT: %[[ADD:.*]] = llvm.add %arg0, %[[CST]] : i32
// CHECK-NEXT: llvm.return %[[ADD]] : !llvm.i32 // CHECK-NEXT: llvm.return %[[ADD]] : i32
^bb1: ^bb1:
%2 = addi %arg0, %0 : i32 %2 = addi %arg0, %0 : i32
return %2 : i32 return %2 : i32
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^bb2: ^bb2:
// CHECK-NEXT: llvm.br ^bb1 // CHECK-NEXT: llvm.br ^bb1
br ^bb1 br ^bb1
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
// CHECK-SAME: %[[A:arg[0-9]+]]: !llvm.vec<4 x float> // CHECK-SAME: %[[A:arg[0-9]+]]: !llvm.vec<4 x float>
// CHECK-SAME: %[[ELT:arg[0-9]+]]: !llvm.float // CHECK-SAME: %[[ELT:arg[0-9]+]]: !llvm.float
func @splat(%a: vector<4xf32>, %b: f32) -> vector<4xf32> { func @splat(%a: vector<4xf32>, %b: f32) -> vector<4xf32> {
%vb = splat %b : vector<4xf32> %vb = splat %b : vector<4xf32>
%r = mulf %a, %vb : vector<4xf32> %r = mulf %a, %vb : vector<4xf32>
return %r : vector<4xf32> return %r : vector<4xf32>
} }
// CHECK-NEXT: %[[UNDEF:[0-9]+]] = llvm.mlir.undef : !llvm.vec<4 x float> // CHECK-NEXT: %[[UNDEF:[0-9]+]] = llvm.mlir.undef : !llvm.vec<4 x float>
// CHECK-NEXT: %[[ZERO:[0-9]+]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK-NEXT: %[[ZERO:[0-9]+]] = llvm.mlir.constant(0 : i32) : i32
// CHECK-NEXT: %[[V:[0-9]+]] = llvm.insertelement %[[ELT]], %[[UNDEF]][%[[ZERO]] : !llvm.i32] : !llvm.vec<4 x float> // CHECK-NEXT: %[[V:[0-9]+]] = llvm.insertelement %[[ELT]], %[[UNDEF]][%[[ZERO]] : i32] : !llvm.vec<4 x float>
// CHECK-NEXT: %[[SPLAT:[0-9]+]] = llvm.shufflevector %[[V]], %[[UNDEF]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] // CHECK-NEXT: %[[SPLAT:[0-9]+]] = llvm.shufflevector %[[V]], %[[UNDEF]] [0 : i32, 0 : i32, 0 : i32, 0 : i32]
// CHECK-NEXT: %[[SCALE:[0-9]+]] = llvm.fmul %[[A]], %[[SPLAT]] : !llvm.vec<4 x float> // CHECK-NEXT: %[[SCALE:[0-9]+]] = llvm.fmul %[[A]], %[[SPLAT]] : !llvm.vec<4 x float>
// CHECK-NEXT: llvm.return %[[SCALE]] : !llvm.vec<4 x float> // CHECK-NEXT: llvm.return %[[SCALE]] : !llvm.vec<4 x float>
// CHECK-LABEL: func @view( // CHECK-LABEL: func @view(
// CHECK: %[[ARG0:.*]]: !llvm.i64, %[[ARG1:.*]]: !llvm.i64, %[[ARG2:.*]]: !llvm.i64 // CHECK: %[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64, %[[ARG2:.*]]: i64
func @view(%arg0 : index, %arg1 : index, %arg2 : index) { func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: llvm.mlir.constant(2048 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(2048 : index) : i64
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
%0 = alloc() : memref<2048xi8> %0 = alloc() : memref<2048xi8>
// Test two dynamic sizes. // Test two dynamic sizes.
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BASE_PTR:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[BASE_PTR:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: %[[SHIFTED_BASE_PTR:.*]] = llvm.getelementptr %[[BASE_PTR]][%[[ARG2]]] : (!llvm.ptr<i8>, !llvm.i64) -> !llvm.ptr<i8> // CHECK: %[[SHIFTED_BASE_PTR:.*]] = llvm.getelementptr %[[BASE_PTR]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
// CHECK: %[[CAST_SHIFTED_BASE_PTR:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR]] : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK: %[[CAST_SHIFTED_BASE_PTR:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR]] : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[C0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[C0]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mul %{{.*}}, %[[ARG1]] // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
%1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32> %1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
// Test one dynamic size. // Test one dynamic size.
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr<i8>, !llvm.i64) -> !llvm.ptr<i8> // CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
// CHECK: %[[CAST_SHIFTED_BASE_PTR_2:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_2]] : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK: %[[CAST_SHIFTED_BASE_PTR_2:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_2]] : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_2]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_2]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[C0_2:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[C0_2:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[C0_2]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[C0_2]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mul %{{.*}}, %[[ARG1]] // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
%3 = view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32> %3 = view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
// Test static sizes. // Test static sizes.
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BASE_PTR_3:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[BASE_PTR_3:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: %[[SHIFTED_BASE_PTR_3:.*]] = llvm.getelementptr %[[BASE_PTR_3]][%[[ARG2]]] : (!llvm.ptr<i8>, !llvm.i64) -> !llvm.ptr<i8> // CHECK: %[[SHIFTED_BASE_PTR_3:.*]] = llvm.getelementptr %[[BASE_PTR_3]][%[[ARG2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
// CHECK: %[[CAST_SHIFTED_BASE_PTR_3:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_3]] : !llvm.ptr<i8> to !llvm.ptr<float> // CHECK: %[[CAST_SHIFTED_BASE_PTR_3:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_3]] : !llvm.ptr<i8> to !llvm.ptr<float>
// CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_3]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_3]], %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[C0_3:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[C0_3:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[C0_3]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[C0_3]], %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(64 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(64 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
%5 = view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32> %5 = view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32>
// Test view memory space. // Test view memory space.
// CHECK: llvm.mlir.constant(2048 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(2048 : index) : i64
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)>
%6 = alloc() : memref<2048xi8, 4> %6 = alloc() : memref<2048xi8, 4>
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BASE_PTR_4:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: %[[BASE_PTR_4:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: %[[SHIFTED_BASE_PTR_4:.*]] = llvm.getelementptr %[[BASE_PTR_4]][%[[ARG2]]] : (!llvm.ptr<i8, 4>, !llvm.i64) -> !llvm.ptr<i8, 4> // CHECK: %[[SHIFTED_BASE_PTR_4:.*]] = llvm.getelementptr %[[BASE_PTR_4]][%[[ARG2]]] : (!llvm.ptr<i8, 4>, i64) -> !llvm.ptr<i8, 4>
// CHECK: %[[CAST_SHIFTED_BASE_PTR_4:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_4]] : !llvm.ptr<i8, 4> to !llvm.ptr<float, 4> // CHECK: %[[CAST_SHIFTED_BASE_PTR_4:.*]] = llvm.bitcast %[[SHIFTED_BASE_PTR_4]] : !llvm.ptr<i8, 4> to !llvm.ptr<float, 4>
// CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_4]], %{{.*}}[1] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[CAST_SHIFTED_BASE_PTR_4]], %{{.*}}[1] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[C0_4:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[C0_4:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[C0_4]], %{{.*}}[2] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[C0_4]], %{{.*}}[2] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(64 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(64 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float, 4>, ptr<float, 4>, i64, array<2 x i64>, array<2 x i64>)>
%7 = view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4> %7 = view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4>
return return
} }
// CHECK-LABEL: func @subview( // CHECK-LABEL: func @subview(
// CHECK-COUNT-2: !llvm.ptr<float>, // CHECK-COUNT-2: !llvm.ptr<float>,
// CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i64, // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64,
// CHECK: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.i64, // CHECK: %[[ARG0:[a-zA-Z0-9]*]]: i64,
// CHECK: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.i64, // CHECK: %[[ARG1:[a-zA-Z0-9]*]]: i64,
// CHECK: %[[ARG2:.*]]: !llvm.i64) // CHECK: %[[ARG2:.*]]: i64)
// CHECK32-LABEL: func @subview( // CHECK32-LABEL: func @subview(
// CHECK32-COUNT-2: !llvm.ptr<float>, // CHECK32-COUNT-2: !llvm.ptr<float>,
// CHECK32-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i32, // CHECK32-COUNT-5: {{%[a-zA-Z0-9]*}}: i32,
// CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.i32, // CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: i32,
// CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.i32, // CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: i32,
// CHECK32: %[[ARG2:.*]]: !llvm.i32) // CHECK32: %[[ARG2:.*]]: i32)
func @subview(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { func @subview(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) {
// The last "insertvalue" that populates the memref descriptor from the function arguments. // The last "insertvalue" that populates the memref descriptor from the function arguments.
// CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i64
// CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64 // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i64
// CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i64
// CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64 // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i64
// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i64
// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i64
// CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i32
// CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i32 // CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i32
// CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i32
// CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i32 // CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i32
// CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i32
// CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i32
%1 = subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] : %1 = subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] :
memref<64x4xf32, offset: 0, strides: [4, 1]> memref<64x4xf32, offset: 0, strides: [4, 1]>
to memref<?x?xf32, offset: ?, strides: [?, ?]> to memref<?x?xf32, offset: ?, strides: [?, ?]>
return return
} }
// CHECK-LABEL: func @subview_non_zero_addrspace( // CHECK-LABEL: func @subview_non_zero_addrspace(
// CHECK-COUNT-2: !llvm.ptr<float, 3>, // CHECK-COUNT-2: !llvm.ptr<float, 3>,
// CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i64, // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64,
// CHECK: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.i64, // CHECK: %[[ARG0:[a-zA-Z0-9]*]]: i64,
// CHECK: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.i64, // CHECK: %[[ARG1:[a-zA-Z0-9]*]]: i64,
// CHECK: %[[ARG2:.*]]: !llvm.i64) // CHECK: %[[ARG2:.*]]: i64)
// CHECK32-LABEL: func @subview_non_zero_addrspace( // CHECK32-LABEL: func @subview_non_zero_addrspace(
// CHECK32-COUNT-2: !llvm.ptr<float, 3>, // CHECK32-COUNT-2: !llvm.ptr<float, 3>,
// CHECK32-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i32, // CHECK32-COUNT-5: {{%[a-zA-Z0-9]*}}: i32,
// CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.i32, // CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: i32,
// CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.i32, // CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: i32,
// CHECK32: %[[ARG2:.*]]: !llvm.i32) // CHECK32: %[[ARG2:.*]]: i32)
func @subview_non_zero_addrspace(%0 : memref<64x4xf32, offset: 0, strides: [4, 1], 3>, %arg0 : index, %arg1 : index, %arg2 : index) { func @subview_non_zero_addrspace(%0 : memref<64x4xf32, offset: 0, strides: [4, 1], 3>, %arg0 : index, %arg1 : index, %arg2 : index) {
// The last "insertvalue" that populates the memref descriptor from the function arguments. // The last "insertvalue" that populates the memref descriptor from the function arguments.
// CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3>
// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3> // CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3>
// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i64
// CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64 // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i64
// CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i64
// CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64 // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i64
// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i64
// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i64
// CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3>
// CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3> // CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float, 3> to !llvm.ptr<float, 3>
// CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i32
// CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i32 // CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i32
// CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i32
// CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i32 // CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i32
// CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : i32
// CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i32
%1 = subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] : %1 = subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] :
memref<64x4xf32, offset: 0, strides: [4, 1], 3> memref<64x4xf32, offset: 0, strides: [4, 1], 3>
to memref<?x?xf32, offset: ?, strides: [?, ?], 3> to memref<?x?xf32, offset: ?, strides: [?, ?], 3>
return return
} }
// CHECK-LABEL: func @subview_const_size( // CHECK-LABEL: func @subview_const_size(
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG7:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG7:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG8:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG8:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG9:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG9:[a-zA-Z0-9]*]]: i64
// CHECK32-LABEL: func @subview_const_size( // CHECK32-LABEL: func @subview_const_size(
// CHECK32-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK32-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK32-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK32-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK32-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG7:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG7:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG8:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG8:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG9:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG9:[a-zA-Z0-9]*]]: i32
func @subview_const_size(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { func @subview_const_size(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) {
// The last "insertvalue" that populates the memref descriptor from the function arguments. // The last "insertvalue" that populates the memref descriptor from the function arguments.
// CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : i64
// CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64 // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i64
// CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : i64
// CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64 // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i64
// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i64) // CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i64)
// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[CST2]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[CST2]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : i64
// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i64) // CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i64)
// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[CST4]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[CST4]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : i64
// CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : i32
// CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i32 // CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i32
// CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : i32
// CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i32 // CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i32
// CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[CST2:.*]] = llvm.mlir.constant(2 : i64) // CHECK32: %[[CST2:.*]] = llvm.mlir.constant(2 : i64)
// CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[CST2]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[CST2]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : i32
// CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[CST4:.*]] = llvm.mlir.constant(4 : i64) // CHECK32: %[[CST4:.*]] = llvm.mlir.constant(4 : i64)
// CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[CST4]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[CST4]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : i32
// CHECK32: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
%1 = subview %0[%arg0, %arg1][4, 2][%arg0, %arg1] : %1 = subview %0[%arg0, %arg1][4, 2][%arg0, %arg1] :
memref<64x4xf32, offset: 0, strides: [4, 1]> memref<64x4xf32, offset: 0, strides: [4, 1]>
to memref<4x2xf32, offset: ?, strides: [?, ?]> to memref<4x2xf32, offset: ?, strides: [?, ?]>
return return
} }
// CHECK-LABEL: func @subview_const_stride( // CHECK-LABEL: func @subview_const_stride(
// CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG7:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG7:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG8:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG8:[a-zA-Z0-9]*]]: i64
// CHECK-SAME: %[[ARG9:[a-zA-Z0-9]*]]: !llvm.i64 // CHECK-SAME: %[[ARG9:[a-zA-Z0-9]*]]: i64
// CHECK32-LABEL: func @subview_const_stride( // CHECK32-LABEL: func @subview_const_stride(
// CHECK32-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK32-SAME: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK32-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>, // CHECK32-SAME: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.ptr<float>,
// CHECK32-SAME: %[[ARG2:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG2:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG3:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG3:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG4:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG4:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG5:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG5:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG6:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG6:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG7:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG7:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG8:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG8:[a-zA-Z0-9]*]]: i32
// CHECK32-SAME: %[[ARG9:[a-zA-Z0-9]*]]: !llvm.i32 // CHECK32-SAME: %[[ARG9:[a-zA-Z0-9]*]]: i32
func @subview_const_stride(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { func @subview_const_stride(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) {
// The last "insertvalue" that populates the memref descriptor from the function arguments. // The last "insertvalue" that populates the memref descriptor from the function arguments.
// CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : !llvm.i64 // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : i64
// CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64 // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i64
// CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : !llvm.i64 // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : i64
// CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64 // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i64
// CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG8]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG8]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i64) // CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i64)
// CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[CST2]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[CST2]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG7]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG7]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i64) // CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i64)
// CHECK: llvm.insertvalue %[[CST4]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[CST4]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[OFFINC:.*]] = llvm.mul %[[ARG7]], %[[STRIDE0]] : i32
// CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i32 // CHECK32: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : i32
// CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[OFFINC1:.*]] = llvm.mul %[[ARG8]], %[[STRIDE1]] : i32
// CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i32 // CHECK32: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : i32
// CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG8]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG8]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[CST2:.*]] = llvm.mlir.constant(2 : i64) // CHECK32: %[[CST2:.*]] = llvm.mlir.constant(2 : i64)
// CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[CST2]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[CST2]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[ARG7]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[ARG7]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[CST4:.*]] = llvm.mlir.constant(4 : i64) // CHECK32: %[[CST4:.*]] = llvm.mlir.constant(4 : i64)
// CHECK32: llvm.insertvalue %[[CST4]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: llvm.insertvalue %[[CST4]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
%1 = subview %0[%arg0, %arg1][%arg0, %arg1][1, 2] : %1 = subview %0[%arg0, %arg1][%arg0, %arg1][1, 2] :
Show All 29 Linesfunc @subview_const_stride_and_offset(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>) {
%1 = subview %0[0, 8][62, 3][1, 1] : %1 = subview %0[0, 8][62, 3][1, 1] :
memref<64x4xf32, offset: 0, strides: [4, 1]> memref<64x4xf32, offset: 0, strides: [4, 1]>
to memref<62x3xf32, offset: 8, strides: [4, 1]> to memref<62x3xf32, offset: 8, strides: [4, 1]>
return return
} }
// CHECK-LABEL: func @subview_mixed_static_dynamic( // CHECK-LABEL: func @subview_mixed_static_dynamic(
// CHECK-COUNT-2: !llvm.ptr<float>, // CHECK-COUNT-2: !llvm.ptr<float>,
// CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i64, // CHECK-COUNT-5: {{%[a-zA-Z0-9]*}}: i64,
// CHECK: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.i64, // CHECK: %[[ARG0:[a-zA-Z0-9]*]]: i64,
// CHECK: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.i64, // CHECK: %[[ARG1:[a-zA-Z0-9]*]]: i64,
// CHECK: %[[ARG2:.*]]: !llvm.i64) // CHECK: %[[ARG2:.*]]: i64)
// CHECK32-LABEL: func @subview_mixed_static_dynamic( // CHECK32-LABEL: func @subview_mixed_static_dynamic(
// CHECK32-COUNT-2: !llvm.ptr<float>, // CHECK32-COUNT-2: !llvm.ptr<float>,
// CHECK32-COUNT-5: {{%[a-zA-Z0-9]*}}: !llvm.i32, // CHECK32-COUNT-5: {{%[a-zA-Z0-9]*}}: i32,
// CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: !llvm.i32, // CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: i32,
// CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: !llvm.i32, // CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: i32,
// CHECK32: %[[ARG2:.*]]: !llvm.i32) // CHECK32: %[[ARG2:.*]]: i32)
func @subview_mixed_static_dynamic(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) { func @subview_mixed_static_dynamic(%0 : memref<64x4xf32, offset: 0, strides: [4, 1]>, %arg0 : index, %arg1 : index, %arg2 : index) {
// The last "insertvalue" that populates the memref descriptor from the function arguments. // The last "insertvalue" that populates the memref descriptor from the function arguments.
// CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] // CHECK32: %[[MEMREF:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 1]
// CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST0:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC0:.*]] = llvm.insertvalue %[[BITCAST0]], %[[DESC]][0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float> // CHECK32: %[[BITCAST1:.*]] = llvm.bitcast %{{.*}} : !llvm.ptr<float> to !llvm.ptr<float>
// CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC1:.*]] = llvm.insertvalue %[[BITCAST1]], %[[DESC0]][1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[OFFM1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[OFFM1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE0]] : i32
// CHECK32: %[[OFFA1:.*]] = llvm.add %[[OFF]], %[[OFFM1]] : !llvm.i32 // CHECK32: %[[OFFA1:.*]] = llvm.add %[[OFF]], %[[OFFM1]] : i32
// CHECK32: %[[CST8:.*]] = llvm.mlir.constant(8 : i64) : !llvm.i32 // CHECK32: %[[CST8:.*]] = llvm.mlir.constant(8 : i64) : i32
// CHECK32: %[[OFFM2:.*]] = llvm.mul %[[CST8]], %[[STRIDE1]] : !llvm.i32 // CHECK32: %[[OFFM2:.*]] = llvm.mul %[[CST8]], %[[STRIDE1]] : i32
// CHECK32: %[[OFFA2:.*]] = llvm.add %[[OFFA1]], %[[OFFM2]] : !llvm.i32 // CHECK32: %[[OFFA2:.*]] = llvm.add %[[OFFA1]], %[[OFFM2]] : i32
// CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFFA2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC2:.*]] = llvm.insertvalue %[[OFFA2]], %[[DESC1]][2] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG2]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC3:.*]] = llvm.insertvalue %[[ARG2]], %[[DESC2]][3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[CST1:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i32 // CHECK32: %[[CST1:.*]] = llvm.mlir.constant(1 : i64) : i32
// CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[CST1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC4:.*]] = llvm.insertvalue %[[CST1]], %[[DESC3]][4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[CST62:.*]] = llvm.mlir.constant(62 : i64) : !llvm.i32 // CHECK32: %[[CST62:.*]] = llvm.mlir.constant(62 : i64) : i32
// CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[CST62]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: %[[DESC5:.*]] = llvm.insertvalue %[[CST62]], %[[DESC4]][3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
// CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i32 // CHECK32: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : i32
// CHECK32: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)> // CHECK32: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i32, array<2 x i32>, array<2 x i32>)>
%1 = subview %0[%arg1, 8][62, %arg2][%arg0, 1] : %1 = subview %0[%arg1, 8][62, %arg2][%arg0, 1] :
memref<64x4xf32, offset: 0, strides: [4, 1]> memref<64x4xf32, offset: 0, strides: [4, 1]>
to memref<62x?xf32, offset: ?, strides: [?, 1]> to memref<62x?xf32, offset: ?, strides: [?, 1]>
return return
} }
// ----- // -----
Show All 22 Lines
// CHECK-LABEL: func @generic_atomic_rmw // CHECK-LABEL: func @generic_atomic_rmw
func @generic_atomic_rmw(%I : memref<10xi32>, %i : index) -> i32 { func @generic_atomic_rmw(%I : memref<10xi32>, %i : index) -> i32 {
%x = generic_atomic_rmw %I[%i] : memref<10xi32> { %x = generic_atomic_rmw %I[%i] : memref<10xi32> {
^bb0(%old_value : i32): ^bb0(%old_value : i32):
%c1 = constant 1 : i32 %c1 = constant 1 : i32
atomic_yield %c1 : i32 atomic_yield %c1 : i32
} }
// CHECK: [[init:%.*]] = llvm.load %{{.*}} : !llvm.ptr<i32> // CHECK: [[init:%.*]] = llvm.load %{{.*}} : !llvm.ptr<i32>
// CHECK-NEXT: llvm.br ^bb1([[init]] : !llvm.i32) // CHECK-NEXT: llvm.br ^bb1([[init]] : i32)
// CHECK-NEXT: ^bb1([[loaded:%.*]]: !llvm.i32): // CHECK-NEXT: ^bb1([[loaded:%.*]]: i32):
// CHECK-NEXT: [[c1:%.*]] = llvm.mlir.constant(1 : i32) // CHECK-NEXT: [[c1:%.*]] = llvm.mlir.constant(1 : i32)
// CHECK-NEXT: [[pair:%.*]] = llvm.cmpxchg %{{.*}}, [[loaded]], [[c1]] // CHECK-NEXT: [[pair:%.*]] = llvm.cmpxchg %{{.*}}, [[loaded]], [[c1]]
// CHECK-SAME: acq_rel monotonic : !llvm.i32 // CHECK-SAME: acq_rel monotonic : i32
// CHECK-NEXT: [[new:%.*]] = llvm.extractvalue [[pair]][0] // CHECK-NEXT: [[new:%.*]] = llvm.extractvalue [[pair]][0]
// CHECK-NEXT: [[ok:%.*]] = llvm.extractvalue [[pair]][1] // CHECK-NEXT: [[ok:%.*]] = llvm.extractvalue [[pair]][1]
// CHECK-NEXT: llvm.cond_br [[ok]], ^bb2, ^bb1([[new]] : !llvm.i32) // CHECK-NEXT: llvm.cond_br [[ok]], ^bb2, ^bb1([[new]] : i32)
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
%c2 = constant 2 : i32 %c2 = constant 2 : i32
%add = addi %c2, %x : i32 %add = addi %c2, %x : i32
return %add : i32 return %add : i32
// CHECK-NEXT: [[c2:%.*]] = llvm.mlir.constant(2 : i32) // CHECK-NEXT: [[c2:%.*]] = llvm.mlir.constant(2 : i32)
// CHECK-NEXT: [[add:%.*]] = llvm.add [[c2]], [[new]] : !llvm.i32 // CHECK-NEXT: [[add:%.*]] = llvm.add [[c2]], [[new]] : i32
// CHECK-NEXT: llvm.return [[add]] // CHECK-NEXT: llvm.return [[add]]
} }
// ----- // -----
// CHECK-LABEL: func @assume_alignment // CHECK-LABEL: func @assume_alignment
func @assume_alignment(%0 : memref<4x4xf16>) { func @assume_alignment(%0 : memref<4x4xf16>) {
// CHECK: %[[PTR:.*]] = llvm.extractvalue %[[MEMREF:.*]][1] : !llvm.struct<(ptr<half>, ptr<half>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: %[[PTR:.*]] = llvm.extractvalue %[[MEMREF:.*]][1] : !llvm.struct<(ptr<half>, ptr<half>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: %[[MASK:.*]] = llvm.mlir.constant(15 : index) : !llvm.i64 // CHECK-NEXT: %[[MASK:.*]] = llvm.mlir.constant(15 : index) : i64
// CHECK-NEXT: %[[INT:.*]] = llvm.ptrtoint %[[PTR]] : !llvm.ptr<half> to !llvm.i64 // CHECK-NEXT: %[[INT:.*]] = llvm.ptrtoint %[[PTR]] : !llvm.ptr<half> to i64
// CHECK-NEXT: %[[MASKED_PTR:.*]] = llvm.and %[[INT]], %[[MASK:.*]] : !llvm.i64 // CHECK-NEXT: %[[MASKED_PTR:.*]] = llvm.and %[[INT]], %[[MASK:.*]] : i64
// CHECK-NEXT: %[[CONDITION:.*]] = llvm.icmp "eq" %[[MASKED_PTR]], %[[ZERO]] : !llvm.i64 // CHECK-NEXT: %[[CONDITION:.*]] = llvm.icmp "eq" %[[MASKED_PTR]], %[[ZERO]] : i64
// CHECK-NEXT: "llvm.intr.assume"(%[[CONDITION]]) : (!llvm.i1) -> () // CHECK-NEXT: "llvm.intr.assume"(%[[CONDITION]]) : (i1) -> ()
assume_alignment %0, 16 : memref<4x4xf16> assume_alignment %0, 16 : memref<4x4xf16>
return return
} }
// ----- // -----
// CHECK-LABEL: func @mlir_cast_to_llvm // CHECK-LABEL: func @mlir_cast_to_llvm
// CHECK-SAME: %[[ARG:.*]]: // CHECK-SAME: %[[ARG:.*]]:
Show All 37 Linesfunc @bfloat(%arg0: bf16) -> bf16 {
return %arg0 : bf16 return %arg0 : bf16
} }
// CHECK-NEXT: return %{{.*}} : !llvm.bfloat // CHECK-NEXT: return %{{.*}} : !llvm.bfloat
// ----- // -----
// CHECK-LABEL: func @memref_index // CHECK-LABEL: func @memref_index
// CHECK-SAME: %arg0: !llvm.ptr<i64>, %arg1: !llvm.ptr<i64>, // CHECK-SAME: %arg0: !llvm.ptr<i64>, %arg1: !llvm.ptr<i64>,
// CHECK-SAME: %arg2: !llvm.i64, %arg3: !llvm.i64, %arg4: !llvm.i64) // CHECK-SAME: %arg2: i64, %arg3: i64, %arg4: i64)
// CHECK-SAME: -> !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-SAME: -> !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK32-LABEL: func @memref_index // CHECK32-LABEL: func @memref_index
// CHECK32-SAME: %arg0: !llvm.ptr<i32>, %arg1: !llvm.ptr<i32>, // CHECK32-SAME: %arg0: !llvm.ptr<i32>, %arg1: !llvm.ptr<i32>,
// CHECK32-SAME: %arg2: !llvm.i32, %arg3: !llvm.i32, %arg4: !llvm.i32) // CHECK32-SAME: %arg2: i32, %arg3: i32, %arg4: i32)
// CHECK32-SAME: -> !llvm.struct<(ptr<i32>, ptr<i32>, i32, array<1 x i32>, array<1 x i32>)> // CHECK32-SAME: -> !llvm.struct<(ptr<i32>, ptr<i32>, i32, array<1 x i32>, array<1 x i32>)>
func @memref_index(%arg0: memref<32xindex>) -> memref<32xindex> { func @memref_index(%arg0: memref<32xindex>) -> memref<32xindex> {
return %arg0 : memref<32xindex> return %arg0 : memref<32xindex>
} }
// ----- // -----
// CHECK-LABEL: func @rank_of_unranked // CHECK-LABEL: func @rank_of_unranked
Show All 9 Lines
// CHECK32: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i32, ptr<i8>)> // CHECK32: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i32, ptr<i8>)>
// CHECK-LABEL: func @rank_of_ranked // CHECK-LABEL: func @rank_of_ranked
// CHECK32-LABEL: func @rank_of_ranked // CHECK32-LABEL: func @rank_of_ranked
func @rank_of_ranked(%ranked: memref<?xi32>) { func @rank_of_ranked(%ranked: memref<?xi32>) {
%rank = rank %ranked : memref<?xi32> %rank = rank %ranked : memref<?xi32>
return return
} }
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK32: llvm.mlir.constant(1 : index) : !llvm.i32 // CHECK32: llvm.mlir.constant(1 : index) : i32
// ----- // -----
// CHECK-LABEL: func @dim_of_unranked // CHECK-LABEL: func @dim_of_unranked
// CHECK32-LABEL: func @dim_of_unranked // CHECK32-LABEL: func @dim_of_unranked
func @dim_of_unranked(%unranked: memref<*xi32>) -> index { func @dim_of_unranked(%unranked: memref<*xi32>) -> index {
%c0 = constant 0 : index %c0 = constant 0 : index
%dim = dim %unranked, %c0 : memref<*xi32> %dim = dim %unranked, %c0 : memref<*xi32>
return %dim : index return %dim : index
} }
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK-NEXT: llvm.insertvalue // CHECK-NEXT: llvm.insertvalue
// CHECK-NEXT: %[[UNRANKED_DESC:.*]] = llvm.insertvalue // CHECK-NEXT: %[[UNRANKED_DESC:.*]] = llvm.insertvalue
// CHECK-NEXT: %[[C0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: %[[RANKED_DESC:.*]] = llvm.extractvalue %[[UNRANKED_DESC]][1] // CHECK-NEXT: %[[RANKED_DESC:.*]] = llvm.extractvalue %[[UNRANKED_DESC]][1]
// CHECK-SAME: : !llvm.struct<(i64, ptr<i8>)> // CHECK-SAME: : !llvm.struct<(i64, ptr<i8>)>
// CHECK-NEXT: %[[ZERO_D_DESC:.*]] = llvm.bitcast %[[RANKED_DESC]] // CHECK-NEXT: %[[ZERO_D_DESC:.*]] = llvm.bitcast %[[RANKED_DESC]]
// CHECK-SAME: : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64)>> // CHECK-SAME: : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<i32>, ptr<i32>, i64)>>
// CHECK-NEXT: %[[C2_i32:.*]] = llvm.mlir.constant(2 : i32) : !llvm.i32 // CHECK-NEXT: %[[C2_i32:.*]] = llvm.mlir.constant(2 : i32) : i32
// CHECK-NEXT: %[[C0_:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: %[[C0_:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: %[[OFFSET_PTR:.*]] = llvm.getelementptr %[[ZERO_D_DESC]]{{\[}} // CHECK-NEXT: %[[OFFSET_PTR:.*]] = llvm.getelementptr %[[ZERO_D_DESC]]{{\[}}
// CHECK-SAME: %[[C0_]], %[[C2_i32]]] : (!llvm.ptr<struct<(ptr<i32>, ptr<i32>, // CHECK-SAME: %[[C0_]], %[[C2_i32]]] : (!llvm.ptr<struct<(ptr<i32>, ptr<i32>,
// CHECK-SAME: i64)>>, !llvm.i64, !llvm.i32) -> !llvm.ptr<i64> // CHECK-SAME: i64)>>, i64, i32) -> !llvm.ptr<i64>
// CHECK-NEXT: %[[C1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %[[INDEX_INC:.*]] = llvm.add %[[C1]], %[[C0]] : !llvm.i64 // CHECK-NEXT: %[[INDEX_INC:.*]] = llvm.add %[[C1]], %[[C0]] : i64
// CHECK-NEXT: %[[SIZE_PTR:.*]] = llvm.getelementptr %[[OFFSET_PTR]]{{\[}} // CHECK-NEXT: %[[SIZE_PTR:.*]] = llvm.getelementptr %[[OFFSET_PTR]]{{\[}}
// CHECK-SAME: %[[INDEX_INC]]] : (!llvm.ptr<i64>, !llvm.i64) -> !llvm.ptr<i64> // CHECK-SAME: %[[INDEX_INC]]] : (!llvm.ptr<i64>, i64) -> !llvm.ptr<i64>
// CHECK-NEXT: %[[SIZE:.*]] = llvm.load %[[SIZE_PTR]] : !llvm.ptr<i64> // CHECK-NEXT: %[[SIZE:.*]] = llvm.load %[[SIZE_PTR]] : !llvm.ptr<i64>
// CHECK-NEXT: llvm.return %[[SIZE]] : !llvm.i64 // CHECK-NEXT: llvm.return %[[SIZE]] : i64
// CHECK32: %[[SIZE:.*]] = llvm.load %{{.*}} : !llvm.ptr<i32> // CHECK32: %[[SIZE:.*]] = llvm.load %{{.*}} : !llvm.ptr<i32>
// CHECK32-NEXT: llvm.return %[[SIZE]] : !llvm.i32 // CHECK32-NEXT: llvm.return %[[SIZE]] : i32

mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesfunc @rsqrt_multidim_vector(%arg0 : vector<4x3xf32>) {
std.return std.return
} }
// ----- // -----
// Lowers `assert` to a function call to `abort` if the assertion is violated. // Lowers `assert` to a function call to `abort` if the assertion is violated.
// CHECK: llvm.func @abort() // CHECK: llvm.func @abort()
// CHECK-LABEL: @assert_test_function // CHECK-LABEL: @assert_test_function
// CHECK-SAME: (%[[ARG:.*]]: !llvm.i1) // CHECK-SAME: (%[[ARG:.*]]: i1)
func @assert_test_function(%arg : i1) { func @assert_test_function(%arg : i1) {
// CHECK: llvm.cond_br %[[ARG]], ^[[CONTINUATION_BLOCK:.*]], ^[[FAILURE_BLOCK:.*]] // CHECK: llvm.cond_br %[[ARG]], ^[[CONTINUATION_BLOCK:.*]], ^[[FAILURE_BLOCK:.*]]
// CHECK: ^[[CONTINUATION_BLOCK]]: // CHECK: ^[[CONTINUATION_BLOCK]]:
// CHECK: llvm.return // CHECK: llvm.return
// CHECK: ^[[FAILURE_BLOCK]]: // CHECK: ^[[FAILURE_BLOCK]]:
// CHECK: llvm.call @abort() : () -> () // CHECK: llvm.call @abort() : () -> ()
// CHECK: llvm.unreachable // CHECK: llvm.unreachable
assert %arg, "Computer says no" assert %arg, "Computer says no"
Show All 28 Lines
// CHECK: llvm.mlir.global external @gv2(dense<{{\[\[}}0.000000e+00, 1.000000e+00, 2.000000e+00], [3.000000e+00, 4.000000e+00, 5.000000e+00]]> : tensor<2x3xf32>) : !llvm.array<2 x array<3 x float>> // CHECK: llvm.mlir.global external @gv2(dense<{{\[\[}}0.000000e+00, 1.000000e+00, 2.000000e+00], [3.000000e+00, 4.000000e+00, 5.000000e+00]]> : tensor<2x3xf32>) : !llvm.array<2 x array<3 x float>>
global_memref @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]> global_memref @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]>
// Test 1D memref. // Test 1D memref.
// CHECK-LABEL: func @get_gv0_memref // CHECK-LABEL: func @get_gv0_memref
func @get_gv0_memref() { func @get_gv0_memref() {
%0 = get_global_memref @gv0 : memref<2xf32> %0 = get_global_memref @gv0 : memref<2xf32>
// CHECK: %[[DIM:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[DIM:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv0 : !llvm.ptr<array<2 x float>> // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv0 : !llvm.ptr<array<2 x float>>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]], %[[ZERO]]] : (!llvm.ptr<array<2 x float>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<float> // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]], %[[ZERO]]] : (!llvm.ptr<array<2 x float>>, i64, i64) -> !llvm.ptr<float>
// CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : !llvm.i64 // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64
// CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : !llvm.i64 to !llvm.ptr<float> // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr<float>
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: llvm.insertvalue %[[DIM]], {{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.insertvalue %[[DIM]], {{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK: llvm.insertvalue %[[STRIDE]], {{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.insertvalue %[[STRIDE]], {{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
return return
} }
// Test 2D memref. // Test 2D memref.
// CHECK-LABEL: func @get_gv2_memref // CHECK-LABEL: func @get_gv2_memref
func @get_gv2_memref() { func @get_gv2_memref() {
// CHECK: %[[DIM0:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[DIM0:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[DIM1:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: %[[DIM1:.*]] = llvm.mlir.constant(3 : index) : i64
// CHECK: %[[STRIDE1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[STRIDE1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv2 : !llvm.ptr<array<2 x array<3 x float>>> // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv2 : !llvm.ptr<array<2 x array<3 x float>>>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]], %[[ZERO]], %[[ZERO]]] : (!llvm.ptr<array<2 x array<3 x float>>>, !llvm.i64, !llvm.i64, !llvm.i64) -> !llvm.ptr<float> // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]], %[[ZERO]], %[[ZERO]]] : (!llvm.ptr<array<2 x array<3 x float>>>, i64, i64, i64) -> !llvm.ptr<float>
// CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : !llvm.i64 // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64
// CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : !llvm.i64 to !llvm.ptr<float> // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr<float>
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[DIM0]], {{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DIM0]], {{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[STRIDE1]], {{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %[[STRIDE1]], {{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
%0 = get_global_memref @gv2 : memref<2x3xf32> %0 = get_global_memref @gv2 : memref<2x3xf32>
return return
} }
// Test scalar memref. // Test scalar memref.
// CHECK: llvm.mlir.global external @gv3(1.000000e+00 : f32) : !llvm.float // CHECK: llvm.mlir.global external @gv3(1.000000e+00 : f32) : !llvm.float
global_memref @gv3 : memref<f32> = dense<1.0> global_memref @gv3 : memref<f32> = dense<1.0>
// CHECK-LABEL: func @get_gv3_memref // CHECK-LABEL: func @get_gv3_memref
func @get_gv3_memref() { func @get_gv3_memref() {
// CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv3 : !llvm.ptr<float> // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv3 : !llvm.ptr<float>
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]]] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][%[[ZERO]]] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : !llvm.i64 // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64
// CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : !llvm.i64 to !llvm.ptr<float> // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr<float>
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
%0 = get_global_memref @gv3 : memref<f32> %0 = get_global_memref @gv3 : memref<f32>
return return
} }
// This should not trigger an assertion by creating an LLVM::CallOp with a // This should not trigger an assertion by creating an LLVM::CallOp with a
// nullptr result type. // nullptr result type.
Show All 17 Lines

mlir/test/Conversion/VectorToLLVM/vector-mask-to-llvm.mlir

// RUN: mlir-opt %s --convert-vector-to-llvm='enable-index-optimizations=1' | FileCheck %s --check-prefix=CMP32 // RUN: mlir-opt %s --convert-vector-to-llvm='enable-index-optimizations=1' | FileCheck %s --check-prefix=CMP32
// RUN: mlir-opt %s --convert-vector-to-llvm='enable-index-optimizations=0' | FileCheck %s --check-prefix=CMP64 // RUN: mlir-opt %s --convert-vector-to-llvm='enable-index-optimizations=0' | FileCheck %s --check-prefix=CMP64
// CMP32-LABEL: llvm.func @genbool_var_1d( // CMP32-LABEL: llvm.func @genbool_var_1d(
// CMP32-SAME: %[[A:.*]]: !llvm.i64) // CMP32-SAME: %[[A:.*]]: i64)
// CMP32: %[[T0:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]> : vector<11xi32>) : !llvm.vec<11 x i32> // CMP32: %[[T0:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]> : vector<11xi32>) : !llvm.vec<11 x i32>
// CMP32: %[[T1:.*]] = llvm.trunc %[[A]] : !llvm.i64 to !llvm.i32 // CMP32: %[[T1:.*]] = llvm.trunc %[[A]] : i64 to i32
// CMP32: %[[T2:.*]] = llvm.mlir.undef : !llvm.vec<11 x i32> // CMP32: %[[T2:.*]] = llvm.mlir.undef : !llvm.vec<11 x i32>
// CMP32: %[[T3:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CMP32: %[[T3:.*]] = llvm.mlir.constant(0 : i32) : i32
// CMP32: %[[T4:.*]] = llvm.insertelement %[[T1]], %[[T2]][%[[T3]] : !llvm.i32] : !llvm.vec<11 x i32> // CMP32: %[[T4:.*]] = llvm.insertelement %[[T1]], %[[T2]][%[[T3]] : i32] : !llvm.vec<11 x i32>
// CMP32: %[[T5:.*]] = llvm.shufflevector %[[T4]], %[[T2]] [0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<11 x i32>, !llvm.vec<11 x i32> // CMP32: %[[T5:.*]] = llvm.shufflevector %[[T4]], %[[T2]] [0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<11 x i32>, !llvm.vec<11 x i32>
// CMP32: %[[T6:.*]] = llvm.icmp "slt" %[[T0]], %[[T5]] : !llvm.vec<11 x i32> // CMP32: %[[T6:.*]] = llvm.icmp "slt" %[[T0]], %[[T5]] : !llvm.vec<11 x i32>
// CMP32: llvm.return %[[T6]] : !llvm.vec<11 x i1> // CMP32: llvm.return %[[T6]] : !llvm.vec<11 x i1>
// CMP64-LABEL: llvm.func @genbool_var_1d( // CMP64-LABEL: llvm.func @genbool_var_1d(
// CMP64-SAME: %[[A:.*]]: !llvm.i64) // CMP64-SAME: %[[A:.*]]: i64)
// CMP64: %[[T0:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]> : vector<11xi64>) : !llvm.vec<11 x i64> // CMP64: %[[T0:.*]] = llvm.mlir.constant(dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]> : vector<11xi64>) : !llvm.vec<11 x i64>
// CMP64: %[[T1:.*]] = llvm.mlir.undef : !llvm.vec<11 x i64> // CMP64: %[[T1:.*]] = llvm.mlir.undef : !llvm.vec<11 x i64>
// CMP64: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CMP64: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : i32
// CMP64: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm.vec<11 x i64> // CMP64: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : i32] : !llvm.vec<11 x i64>
// CMP64: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T1]] [0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<11 x i64>, !llvm.vec<11 x i64> // CMP64: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T1]] [0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<11 x i64>, !llvm.vec<11 x i64>
// CMP64: %[[T5:.*]] = llvm.icmp "slt" %[[T0]], %[[T4]] : !llvm.vec<11 x i64> // CMP64: %[[T5:.*]] = llvm.icmp "slt" %[[T0]], %[[T4]] : !llvm.vec<11 x i64>
// CMP64: llvm.return %[[T5]] : !llvm.vec<11 x i1> // CMP64: llvm.return %[[T5]] : !llvm.vec<11 x i1>
func @genbool_var_1d(%arg0: index) -> vector<11xi1> { func @genbool_var_1d(%arg0: index) -> vector<11xi1> {
%0 = vector.create_mask %arg0 : vector<11xi1> %0 = vector.create_mask %arg0 : vector<11xi1>
return %0 : vector<11xi1> return %0 : vector<11xi1>
} }
Show All 20 Lines

mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

// RUN: mlir-opt %s -convert-vector-to-llvm | FileCheck %s // RUN: mlir-opt %s -convert-vector-to-llvm | FileCheck %s
func @broadcast_vec1d_from_scalar(%arg0: f32) -> vector<2xf32> { func @broadcast_vec1d_from_scalar(%arg0: f32) -> vector<2xf32> {
%0 = vector.broadcast %arg0 : f32 to vector<2xf32> %0 = vector.broadcast %arg0 : f32 to vector<2xf32>
return %0 : vector<2xf32> return %0 : vector<2xf32>
} }
// CHECK-LABEL: llvm.func @broadcast_vec1d_from_scalar( // CHECK-LABEL: llvm.func @broadcast_vec1d_from_scalar(
// CHECK-SAME: %[[A:.*]]: !llvm.float) // CHECK-SAME: %[[A:.*]]: !llvm.float)
// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.vec<2 x float> // CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.vec<2 x float>
// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T2:.*]] = llvm.insertelement %[[A]], %[[T0]][%[[T1]] : !llvm.i32] : !llvm.vec<2 x float> // CHECK: %[[T2:.*]] = llvm.insertelement %[[A]], %[[T0]][%[[T1]] : i32] : !llvm.vec<2 x float>
// CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T0]] [0 : i32, 0 : i32] : !llvm.vec<2 x float>, !llvm.vec<2 x float> // CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T0]] [0 : i32, 0 : i32] : !llvm.vec<2 x float>, !llvm.vec<2 x float>
// CHECK: llvm.return %[[T3]] : !llvm.vec<2 x float> // CHECK: llvm.return %[[T3]] : !llvm.vec<2 x float>
func @broadcast_vec2d_from_scalar(%arg0: f32) -> vector<2x3xf32> { func @broadcast_vec2d_from_scalar(%arg0: f32) -> vector<2x3xf32> {
%0 = vector.broadcast %arg0 : f32 to vector<2x3xf32> %0 = vector.broadcast %arg0 : f32 to vector<2x3xf32>
return %0 : vector<2x3xf32> return %0 : vector<2x3xf32>
} }
// CHECK-LABEL: llvm.func @broadcast_vec2d_from_scalar( // CHECK-LABEL: llvm.func @broadcast_vec2d_from_scalar(
// CHECK-SAME: %[[A:.*]]: !llvm.float) // CHECK-SAME: %[[A:.*]]: !llvm.float)
// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vec<3 x float>>
// CHECK: %[[T1:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T1:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0] : !llvm.array<2 x vec<3 x float>>
// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][1] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][1] : !llvm.array<2 x vec<3 x float>>
// CHECK: llvm.return %[[T6]] : !llvm.array<2 x vec<3 x float>> // CHECK: llvm.return %[[T6]] : !llvm.array<2 x vec<3 x float>>
func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> { func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> {
%0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32> %0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32>
return %0 : vector<2x3x4xf32> return %0 : vector<2x3x4xf32>
} }
// CHECK-LABEL: llvm.func @broadcast_vec3d_from_scalar( // CHECK-LABEL: llvm.func @broadcast_vec3d_from_scalar(
// CHECK-SAME: %[[A:.*]]: !llvm.float) // CHECK-SAME: %[[A:.*]]: !llvm.float)
// CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: %[[T1:.*]] = llvm.mlir.undef : !llvm.vec<4 x float> // CHECK: %[[T1:.*]] = llvm.mlir.undef : !llvm.vec<4 x float>
// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm.vec<4 x float> // CHECK: %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : i32] : !llvm.vec<4 x float>
// CHECK: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float> // CHECK: %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
// CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0, 0] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0, 0] : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0, 1] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0, 1] : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][0, 2] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][0, 2] : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][1, 0] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][1, 0] : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: %[[T9:.*]] = llvm.insertvalue %[[T4]], %[[T8]][1, 1] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T4]], %[[T8]][1, 1] : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: %[[T10:.*]] = llvm.insertvalue %[[T4]], %[[T9]][1, 2] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: %[[T10:.*]] = llvm.insertvalue %[[T4]], %[[T9]][1, 2] : !llvm.array<2 x array<3 x vec<4 x float>>>
// CHECK: llvm.return %[[T10]] : !llvm.array<2 x array<3 x vec<4 x float>>> // CHECK: llvm.return %[[T10]] : !llvm.array<2 x array<3 x vec<4 x float>>>
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
// CHECK: llvm.return %[[T4]] : !llvm.array<4 x array<3 x vec<2 x float>>> // CHECK: llvm.return %[[T4]] : !llvm.array<4 x array<3 x vec<2 x float>>>
func @broadcast_stretch(%arg0: vector<1xf32>) -> vector<4xf32> { func @broadcast_stretch(%arg0: vector<1xf32>) -> vector<4xf32> {
%0 = vector.broadcast %arg0 : vector<1xf32> to vector<4xf32> %0 = vector.broadcast %arg0 : vector<1xf32> to vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// CHECK-LABEL: llvm.func @broadcast_stretch( // CHECK-LABEL: llvm.func @broadcast_stretch(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<1 x float>) // CHECK-SAME: %[[A:.*]]: !llvm.vec<1 x float>)
// CHECK: %[[T0:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T0:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T1:.*]] = llvm.extractelement %[[A]][%[[T0]] : !llvm.i64] : !llvm.vec<1 x float> // CHECK: %[[T1:.*]] = llvm.extractelement %[[A]][%[[T0]] : i64] : !llvm.vec<1 x float>
// CHECK: %[[T2:.*]] = llvm.mlir.undef : !llvm.vec<4 x float> // CHECK: %[[T2:.*]] = llvm.mlir.undef : !llvm.vec<4 x float>
// CHECK: %[[T3:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T3:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T4:.*]] = llvm.insertelement %[[T1]], %[[T2]][%3 : !llvm.i32] : !llvm.vec<4 x float> // CHECK: %[[T4:.*]] = llvm.insertelement %[[T1]], %[[T2]][%3 : i32] : !llvm.vec<4 x float>
// CHECK: %[[T5:.*]] = llvm.shufflevector %[[T4]], %[[T2]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float> // CHECK: %[[T5:.*]] = llvm.shufflevector %[[T4]], %[[T2]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
// CHECK: llvm.return %[[T5]] : !llvm.vec<4 x float> // CHECK: llvm.return %[[T5]] : !llvm.vec<4 x float>
func @broadcast_stretch_at_start(%arg0: vector<1x4xf32>) -> vector<3x4xf32> { func @broadcast_stretch_at_start(%arg0: vector<1x4xf32>) -> vector<3x4xf32> {
%0 = vector.broadcast %arg0 : vector<1x4xf32> to vector<3x4xf32> %0 = vector.broadcast %arg0 : vector<1x4xf32> to vector<3x4xf32>
return %0 : vector<3x4xf32> return %0 : vector<3x4xf32>
} }
// CHECK-LABEL: llvm.func @broadcast_stretch_at_start( // CHECK-LABEL: llvm.func @broadcast_stretch_at_start(
// CHECK-SAME: %[[A:.*]]: !llvm.array<1 x vec<4 x float>>) // CHECK-SAME: %[[A:.*]]: !llvm.array<1 x vec<4 x float>>)
// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x4xf32>) : !llvm.array<3 x vec<4 x float>> // CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x4xf32>) : !llvm.array<3 x vec<4 x float>>
// CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<1 x vec<4 x float>> // CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<1 x vec<4 x float>>
// CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm.array<3 x vec<4 x float>> // CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm.array<3 x vec<4 x float>>
// CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][1] : !llvm.array<3 x vec<4 x float>> // CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][1] : !llvm.array<3 x vec<4 x float>>
// CHECK: %[[T4:.*]] = llvm.insertvalue %[[T1]], %[[T3]][2] : !llvm.array<3 x vec<4 x float>> // CHECK: %[[T4:.*]] = llvm.insertvalue %[[T1]], %[[T3]][2] : !llvm.array<3 x vec<4 x float>>
// CHECK: llvm.return %[[T4]] : !llvm.array<3 x vec<4 x float>> // CHECK: llvm.return %[[T4]] : !llvm.array<3 x vec<4 x float>>
func @broadcast_stretch_at_end(%arg0: vector<4x1xf32>) -> vector<4x3xf32> { func @broadcast_stretch_at_end(%arg0: vector<4x1xf32>) -> vector<4x3xf32> {
%0 = vector.broadcast %arg0 : vector<4x1xf32> to vector<4x3xf32> %0 = vector.broadcast %arg0 : vector<4x1xf32> to vector<4x3xf32>
return %0 : vector<4x3xf32> return %0 : vector<4x3xf32>
} }
// CHECK-LABEL: llvm.func @broadcast_stretch_at_end( // CHECK-LABEL: llvm.func @broadcast_stretch_at_end(
// CHECK-SAME: %[[A:.*]]: !llvm.array<4 x vec<1 x float>>) // CHECK-SAME: %[[A:.*]]: !llvm.array<4 x vec<1 x float>>)
// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3xf32>) : !llvm.array<4 x vec<3 x float>> // CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3xf32>) : !llvm.array<4 x vec<3 x float>>
// CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<4 x vec<1 x float>> // CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<4 x vec<1 x float>>
// CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T3:.*]] = llvm.extractelement %[[T1]][%[[T2]] : !llvm.i64] : !llvm.vec<1 x float> // CHECK: %[[T3:.*]] = llvm.extractelement %[[T1]][%[[T2]] : i64] : !llvm.vec<1 x float>
// CHECK: %[[T4:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T4:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T5:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T5:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T6:.*]] = llvm.insertelement %[[T3]], %[[T4]][%[[T5]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T6:.*]] = llvm.insertelement %[[T3]], %[[T4]][%[[T5]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T7:.*]] = llvm.shufflevector %[[T6]], %[[T4]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T7:.*]] = llvm.shufflevector %[[T6]], %[[T4]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm.array<4 x vec<3 x float>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm.array<4 x vec<3 x float>>
// CHECK: %[[T9:.*]] = llvm.extractvalue %[[A]][1] : !llvm.array<4 x vec<1 x float>> // CHECK: %[[T9:.*]] = llvm.extractvalue %[[A]][1] : !llvm.array<4 x vec<1 x float>>
// CHECK: %[[T10:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T10:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T11:.*]] = llvm.extractelement %[[T9]][%[[T10]] : !llvm.i64] : !llvm.vec<1 x float> // CHECK: %[[T11:.*]] = llvm.extractelement %[[T9]][%[[T10]] : i64] : !llvm.vec<1 x float>
// CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm.array<4 x vec<3 x float>> // CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm.array<4 x vec<3 x float>>
// CHECK: %[[T17:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vec<1 x float>> // CHECK: %[[T17:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vec<1 x float>>
// CHECK: %[[T18:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T18:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T19:.*]] = llvm.extractelement %[[T17]][%[[T18]] : !llvm.i64] : !llvm.vec<1 x float> // CHECK: %[[T19:.*]] = llvm.extractelement %[[T17]][%[[T18]] : i64] : !llvm.vec<1 x float>
// CHECK: %[[T20:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T20:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T21:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T21:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T22:.*]] = llvm.insertelement %[[T19]], %[[T20]][%[[T21]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T22:.*]] = llvm.insertelement %[[T19]], %[[T20]][%[[T21]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T23:.*]] = llvm.shufflevector %[[T22]], %[[T20]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T23:.*]] = llvm.shufflevector %[[T22]], %[[T20]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T16]][2] : !llvm.array<4 x vec<3 x float>> // CHECK: %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T16]][2] : !llvm.array<4 x vec<3 x float>>
// CHECK: %[[T25:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vec<1 x float>> // CHECK: %[[T25:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vec<1 x float>>
// CHECK: %[[T26:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T26:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T27:.*]] = llvm.extractelement %[[T25]][%[[T26]] : !llvm.i64] : !llvm.vec<1 x float> // CHECK: %[[T27:.*]] = llvm.extractelement %[[T25]][%[[T26]] : i64] : !llvm.vec<1 x float>
// CHECK: %[[T28:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T28:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T29:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T29:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T30:.*]] = llvm.insertelement %[[T27]], %[[T28]][%[[T29]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T30:.*]] = llvm.insertelement %[[T27]], %[[T28]][%[[T29]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T31:.*]] = llvm.shufflevector %[[T30]], %[[T28]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T31:.*]] = llvm.shufflevector %[[T30]], %[[T28]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T32:.*]] = llvm.insertvalue %[[T31]], %[[T24]][3] : !llvm.array<4 x vec<3 x float>> // CHECK: %[[T32:.*]] = llvm.insertvalue %[[T31]], %[[T24]][3] : !llvm.array<4 x vec<3 x float>>
// CHECK: llvm.return %[[T32]] : !llvm.array<4 x vec<3 x float>> // CHECK: llvm.return %[[T32]] : !llvm.array<4 x vec<3 x float>>
func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> { func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> {
%0 = vector.broadcast %arg0 : vector<4x1x2xf32> to vector<4x3x2xf32> %0 = vector.broadcast %arg0 : vector<4x1x2xf32> to vector<4x3x2xf32>
return %0 : vector<4x3x2xf32> return %0 : vector<4x3x2xf32>
} }
Show All 26 Lines
func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32> { func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32> {
%2 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32> %2 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32>
return %2 : vector<2x3xf32> return %2 : vector<2x3xf32>
} }
// CHECK-LABEL: llvm.func @outerproduct( // CHECK-LABEL: llvm.func @outerproduct(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>, // CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>,
// CHECK-SAME: %[[B:.*]]: !llvm.vec<3 x float>) // CHECK-SAME: %[[B:.*]]: !llvm.vec<3 x float>)
// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>) // CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>)
// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : i64] : !llvm.vec<2 x float>
// CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%4 : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%4 : i32] : !llvm.vec<3 x float>
// CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T7:.*]] = llvm.fmul %[[T6]], %[[B]] : !llvm.vec<3 x float> // CHECK: %[[T7:.*]] = llvm.fmul %[[T6]], %[[B]] : !llvm.vec<3 x float>
// CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm.array<2 x vec<3 x float>>
// CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i64 // CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : i64
// CHECK: %[[T10:.*]] = llvm.extractelement %[[A]][%9 : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[T10:.*]] = llvm.extractelement %[[A]][%9 : i64] : !llvm.vec<2 x float>
// CHECK: %[[T11:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T11:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T12:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T12:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T13:.*]] = llvm.insertelement %[[T10]], %[[T11]][%12 : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T13:.*]] = llvm.insertelement %[[T10]], %[[T11]][%12 : i32] : !llvm.vec<3 x float>
// CHECK: %[[T14:.*]] = llvm.shufflevector %[[T13]], %[[T11]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T14:.*]] = llvm.shufflevector %[[T13]], %[[T11]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T15:.*]] = llvm.fmul %[[T14]], %[[B]] : !llvm.vec<3 x float> // CHECK: %[[T15:.*]] = llvm.fmul %[[T14]], %[[B]] : !llvm.vec<3 x float>
// CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm.array<2 x vec<3 x float>>
// CHECK: llvm.return %[[T16]] : !llvm.array<2 x vec<3 x float>> // CHECK: llvm.return %[[T16]] : !llvm.array<2 x vec<3 x float>>
func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector<2x3xf32>) -> vector<2x3xf32> { func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector<2x3xf32>) -> vector<2x3xf32> {
%2 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32> %2 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32>
return %2 : vector<2x3xf32> return %2 : vector<2x3xf32>
} }
// CHECK-LABEL: llvm.func @outerproduct_add( // CHECK-LABEL: llvm.func @outerproduct_add(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>, // CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>,
// CHECK-SAME: %[[B:.*]]: !llvm.vec<3 x float>, // CHECK-SAME: %[[B:.*]]: !llvm.vec<3 x float>,
// CHECK-SAME: %[[C:.*]]: !llvm.array<2 x vec<3 x float>>) // CHECK-SAME: %[[C:.*]]: !llvm.array<2 x vec<3 x float>>)
// CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>) // CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>)
// CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : i64] : !llvm.vec<2 x float>
// CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%[[T4]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%[[T4]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T7:.*]] = llvm.extractvalue %[[C]][0] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T7:.*]] = llvm.extractvalue %[[C]][0] : !llvm.array<2 x vec<3 x float>>
// CHECK: %[[T8:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T7]]) : (!llvm.vec<3 x float>, !llvm.vec<3 x float>, !llvm.vec<3 x float>) // CHECK: %[[T8:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T7]]) : (!llvm.vec<3 x float>, !llvm.vec<3 x float>, !llvm.vec<3 x float>)
// CHECK: %[[T9:.*]] = llvm.insertvalue %[[T8]], %[[T0]][0] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T8]], %[[T0]][0] : !llvm.array<2 x vec<3 x float>>
// CHECK: %[[T10:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i64 // CHECK: %[[T10:.*]] = llvm.mlir.constant(1 : i64) : i64
// CHECK: %[[T11:.*]] = llvm.extractelement %[[A]][%[[T10]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[T11:.*]] = llvm.extractelement %[[A]][%[[T10]] : i64] : !llvm.vec<2 x float>
// CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm.vec<3 x float> // CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm.vec<3 x float>
// CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : !llvm.i32] : !llvm.vec<3 x float> // CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : i32] : !llvm.vec<3 x float>
// CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float> // CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm.vec<3 x float>, !llvm.vec<3 x float>
// CHECK: %[[T16:.*]] = llvm.extractvalue %[[C]][1] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T16:.*]] = llvm.extractvalue %[[C]][1] : !llvm.array<2 x vec<3 x float>>
// CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T15]], %[[B]], %[[T16]]) : (!llvm.vec<3 x float>, !llvm.vec<3 x float>, !llvm.vec<3 x float>) // CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T15]], %[[B]], %[[T16]]) : (!llvm.vec<3 x float>, !llvm.vec<3 x float>, !llvm.vec<3 x float>)
// CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T9]][1] : !llvm.array<2 x vec<3 x float>> // CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T9]][1] : !llvm.array<2 x vec<3 x float>>
// CHECK: llvm.return %[[T18]] : !llvm.array<2 x vec<3 x float>> // CHECK: llvm.return %[[T18]] : !llvm.array<2 x vec<3 x float>>
func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> { func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> {
%1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32> %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32>
return %1 : vector<2xf32> return %1 : vector<2xf32>
} }
// CHECK-LABEL: llvm.func @shuffle_1D_direct( // CHECK-LABEL: llvm.func @shuffle_1D_direct(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>, // CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>,
// CHECK-SAME: %[[B:.*]]: !llvm.vec<2 x float>) // CHECK-SAME: %[[B:.*]]: !llvm.vec<2 x float>)
// CHECK: %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, 1] : !llvm.vec<2 x float>, !llvm.vec<2 x float> // CHECK: %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, 1] : !llvm.vec<2 x float>, !llvm.vec<2 x float>
// CHECK: llvm.return %[[s]] : !llvm.vec<2 x float> // CHECK: llvm.return %[[s]] : !llvm.vec<2 x float>
func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> { func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> {
%1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32> %1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32>
return %1 : vector<5xf32> return %1 : vector<5xf32>
} }
// CHECK-LABEL: llvm.func @shuffle_1D( // CHECK-LABEL: llvm.func @shuffle_1D(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>, // CHECK-SAME: %[[A:.*]]: !llvm.vec<2 x float>,
// CHECK-SAME: %[[B:.*]]: !llvm.vec<3 x float>) // CHECK-SAME: %[[B:.*]]: !llvm.vec<3 x float>)
// CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm.vec<5 x float> // CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm.vec<5 x float>
// CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[e1:.*]] = llvm.extractelement %[[B]][%[[c2]] : !llvm.i64] : !llvm.vec<3 x float> // CHECK: %[[e1:.*]] = llvm.extractelement %[[B]][%[[c2]] : i64] : !llvm.vec<3 x float>
// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[i1:.*]] = llvm.insertelement %[[e1]], %[[u0]][%[[c0]] : !llvm.i64] : !llvm.vec<5 x float> // CHECK: %[[i1:.*]] = llvm.insertelement %[[e1]], %[[u0]][%[[c0]] : i64] : !llvm.vec<5 x float>
// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[e2:.*]] = llvm.extractelement %[[B]][%[[c1]] : !llvm.i64] : !llvm.vec<3 x float> // CHECK: %[[e2:.*]] = llvm.extractelement %[[B]][%[[c1]] : i64] : !llvm.vec<3 x float>
// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[i2:.*]] = llvm.insertelement %[[e2]], %[[i1]][%[[c1]] : !llvm.i64] : !llvm.vec<5 x float> // CHECK: %[[i2:.*]] = llvm.insertelement %[[e2]], %[[i1]][%[[c1]] : i64] : !llvm.vec<5 x float>
// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[e3:.*]] = llvm.extractelement %[[B]][%[[c0]] : !llvm.i64] : !llvm.vec<3 x float> // CHECK: %[[e3:.*]] = llvm.extractelement %[[B]][%[[c0]] : i64] : !llvm.vec<3 x float>
// CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[i3:.*]] = llvm.insertelement %[[e3]], %[[i2]][%[[c2]] : !llvm.i64] : !llvm.vec<5 x float> // CHECK: %[[i3:.*]] = llvm.insertelement %[[e3]], %[[i2]][%[[c2]] : i64] : !llvm.vec<5 x float>
// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[e4:.*]] = llvm.extractelement %[[A]][%[[c1]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[e4:.*]] = llvm.extractelement %[[A]][%[[c1]] : i64] : !llvm.vec<2 x float>
// CHECK: %[[c3:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: %[[c3:.*]] = llvm.mlir.constant(3 : index) : i64
// CHECK: %[[i4:.*]] = llvm.insertelement %[[e4]], %[[i3]][%[[c3]] : !llvm.i64] : !llvm.vec<5 x float> // CHECK: %[[i4:.*]] = llvm.insertelement %[[e4]], %[[i3]][%[[c3]] : i64] : !llvm.vec<5 x float>
// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[e5:.*]] = llvm.extractelement %[[A]][%[[c0]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[e5:.*]] = llvm.extractelement %[[A]][%[[c0]] : i64] : !llvm.vec<2 x float>
// CHECK: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
// CHECK: %[[i5:.*]] = llvm.insertelement %[[e5]], %[[i4]][%[[c4]] : !llvm.i64] : !llvm.vec<5 x float> // CHECK: %[[i5:.*]] = llvm.insertelement %[[e5]], %[[i4]][%[[c4]] : i64] : !llvm.vec<5 x float>
// CHECK: llvm.return %[[i5]] : !llvm.vec<5 x float> // CHECK: llvm.return %[[i5]] : !llvm.vec<5 x float>
func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> { func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {
%1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32> %1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32>
return %1 : vector<3x4xf32> return %1 : vector<3x4xf32>
} }
// CHECK-LABEL: llvm.func @shuffle_2D( // CHECK-LABEL: llvm.func @shuffle_2D(
// CHECK-SAME: %[[A:.*]]: !llvm.array<1 x vec<4 x float>>, // CHECK-SAME: %[[A:.*]]: !llvm.array<1 x vec<4 x float>>,
Show All 9 Lines
func @extract_element(%arg0: vector<16xf32>) -> f32 { func @extract_element(%arg0: vector<16xf32>) -> f32 {
%0 = constant 15 : i32 %0 = constant 15 : i32
%1 = vector.extractelement %arg0[%0 : i32]: vector<16xf32> %1 = vector.extractelement %arg0[%0 : i32]: vector<16xf32>
return %1 : f32 return %1 : f32
} }
// CHECK-LABEL: llvm.func @extract_element( // CHECK-LABEL: llvm.func @extract_element(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x float>) // CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x float>)
// CHECK: %[[c:.*]] = llvm.mlir.constant(15 : i32) : !llvm.i32 // CHECK: %[[c:.*]] = llvm.mlir.constant(15 : i32) : i32
// CHECK: %[[x:.*]] = llvm.extractelement %[[A]][%[[c]] : !llvm.i32] : !llvm.vec<16 x float> // CHECK: %[[x:.*]] = llvm.extractelement %[[A]][%[[c]] : i32] : !llvm.vec<16 x float>
// CHECK: llvm.return %[[x]] : !llvm.float // CHECK: llvm.return %[[x]] : !llvm.float
func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 { func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 {
%0 = vector.extract %arg0[15]: vector<16xf32> %0 = vector.extract %arg0[15]: vector<16xf32>
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: llvm.func @extract_element_from_vec_1d // CHECK-LABEL: llvm.func @extract_element_from_vec_1d
// CHECK: llvm.mlir.constant(15 : i64) : !llvm.i64 // CHECK: llvm.mlir.constant(15 : i64) : i64
// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<16 x float> // CHECK: llvm.extractelement {{.*}}[{{.*}} : i64] : !llvm.vec<16 x float>
// CHECK: llvm.return {{.*}} : !llvm.float // CHECK: llvm.return {{.*}} : !llvm.float
func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> { func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> {
%0 = vector.extract %arg0[0]: vector<4x3x16xf32> %0 = vector.extract %arg0[0]: vector<4x3x16xf32>
return %0 : vector<3x16xf32> return %0 : vector<3x16xf32>
} }
// CHECK-LABEL: llvm.func @extract_vec_2d_from_vec_3d // CHECK-LABEL: llvm.func @extract_vec_2d_from_vec_3d
// CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<4 x array<3 x vec<16 x float>>> // CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<4 x array<3 x vec<16 x float>>>
// CHECK: llvm.return {{.*}} : !llvm.array<3 x vec<16 x float>> // CHECK: llvm.return {{.*}} : !llvm.array<3 x vec<16 x float>>
func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> { func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> {
%0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32> %0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32>
return %0 : vector<16xf32> return %0 : vector<16xf32>
} }
// CHECK-LABEL: llvm.func @extract_vec_1d_from_vec_3d // CHECK-LABEL: llvm.func @extract_vec_1d_from_vec_3d
// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vec<16 x float>>> // CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vec<16 x float>>>
// CHECK: llvm.return {{.*}} : !llvm.vec<16 x float> // CHECK: llvm.return {{.*}} : !llvm.vec<16 x float>
func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 { func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 {
%0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32> %0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32>
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: llvm.func @extract_element_from_vec_3d // CHECK-LABEL: llvm.func @extract_element_from_vec_3d
// CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vec<16 x float>>> // CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vec<16 x float>>>
// CHECK: llvm.mlir.constant(0 : i64) : !llvm.i64 // CHECK: llvm.mlir.constant(0 : i64) : i64
// CHECK: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<16 x float> // CHECK: llvm.extractelement {{.*}}[{{.*}} : i64] : !llvm.vec<16 x float>
// CHECK: llvm.return {{.*}} : !llvm.float // CHECK: llvm.return {{.*}} : !llvm.float
func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> { func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
%0 = constant 3 : i32 %0 = constant 3 : i32
%1 = vector.insertelement %arg0, %arg1[%0 : i32] : vector<4xf32> %1 = vector.insertelement %arg0, %arg1[%0 : i32] : vector<4xf32>
return %1 : vector<4xf32> return %1 : vector<4xf32>
} }
// CHECK-LABEL: llvm.func @insert_element( // CHECK-LABEL: llvm.func @insert_element(
// CHECK-SAME: %[[A:.*]]: !llvm.float, // CHECK-SAME: %[[A:.*]]: !llvm.float,
// CHECK-SAME: %[[B:.*]]: !llvm.vec<4 x float>) // CHECK-SAME: %[[B:.*]]: !llvm.vec<4 x float>)
// CHECK: %[[c:.*]] = llvm.mlir.constant(3 : i32) : !llvm.i32 // CHECK: %[[c:.*]] = llvm.mlir.constant(3 : i32) : i32
// CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[c]] : !llvm.i32] : !llvm.vec<4 x float> // CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[c]] : i32] : !llvm.vec<4 x float>
// CHECK: llvm.return %[[x]] : !llvm.vec<4 x float> // CHECK: llvm.return %[[x]] : !llvm.vec<4 x float>
func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> { func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
%0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32> %0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// CHECK-LABEL: llvm.func @insert_element_into_vec_1d // CHECK-LABEL: llvm.func @insert_element_into_vec_1d
// CHECK: llvm.mlir.constant(3 : i64) : !llvm.i64 // CHECK: llvm.mlir.constant(3 : i64) : i64
// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<4 x float> // CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : !llvm.vec<4 x float>
// CHECK: llvm.return {{.*}} : !llvm.vec<4 x float> // CHECK: llvm.return {{.*}} : !llvm.vec<4 x float>
func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
%0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32> %0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32>
return %0 : vector<4x8x16xf32> return %0 : vector<4x8x16xf32>
} }
// CHECK-LABEL: llvm.func @insert_vec_2d_into_vec_3d // CHECK-LABEL: llvm.func @insert_vec_2d_into_vec_3d
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x array<8 x vec<16 x float>>>
// CHECK: llvm.return {{.*}} : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.return {{.*}} : !llvm.array<4 x array<8 x vec<16 x float>>>
func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
%0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32> %0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32>
return %0 : vector<4x8x16xf32> return %0 : vector<4x8x16xf32>
} }
// CHECK-LABEL: llvm.func @insert_vec_1d_into_vec_3d // CHECK-LABEL: llvm.func @insert_vec_1d_into_vec_3d
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vec<16 x float>>>
// CHECK: llvm.return {{.*}} : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.return {{.*}} : !llvm.array<4 x array<8 x vec<16 x float>>>
func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> { func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
%0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32> %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32>
return %0 : vector<4x8x16xf32> return %0 : vector<4x8x16xf32>
} }
// CHECK-LABEL: llvm.func @insert_element_into_vec_3d // CHECK-LABEL: llvm.func @insert_element_into_vec_3d
// CHECK: llvm.extractvalue {{.*}}[3, 7] : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.extractvalue {{.*}}[3, 7] : !llvm.array<4 x array<8 x vec<16 x float>>>
// CHECK: llvm.mlir.constant(15 : i64) : !llvm.i64 // CHECK: llvm.mlir.constant(15 : i64) : i64
// CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<16 x float> // CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : !llvm.vec<16 x float>
// CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vec<16 x float>>>
// CHECK: llvm.return {{.*}} : !llvm.array<4 x array<8 x vec<16 x float>>> // CHECK: llvm.return {{.*}} : !llvm.array<4 x array<8 x vec<16 x float>>>
func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> { func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {
%0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>> %0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>>
return %0 : memref<vector<8x8x8xf32>> return %0 : memref<vector<8x8x8xf32>>
} }
// CHECK-LABEL: llvm.func @vector_type_cast // CHECK-LABEL: llvm.func @vector_type_cast
Show All 25 Lines
func @vector_print_scalar_i1(%arg0: i1) { func @vector_print_scalar_i1(%arg0: i1) {
vector.print %arg0 : i1 vector.print %arg0 : i1
return return
} }
// //
// Type "boolean" always uses zero extension. // Type "boolean" always uses zero extension.
// //
// CHECK-LABEL: llvm.func @vector_print_scalar_i1( // CHECK-LABEL: llvm.func @vector_print_scalar_i1(
// CHECK-SAME: %[[A:.*]]: !llvm.i1) // CHECK-SAME: %[[A:.*]]: i1)
// CHECK: %[[S:.*]] = llvm.zext %[[A]] : !llvm.i1 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.zext %[[A]] : i1 to i64
// CHECK: llvm.call @printI64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_i4(%arg0: i4) { func @vector_print_scalar_i4(%arg0: i4) {
vector.print %arg0 : i4 vector.print %arg0 : i4
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_i4( // CHECK-LABEL: llvm.func @vector_print_scalar_i4(
// CHECK-SAME: %[[A:.*]]: !llvm.i4) // CHECK-SAME: %[[A:.*]]: i4)
// CHECK: %[[S:.*]] = llvm.sext %[[A]] : !llvm.i4 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.sext %[[A]] : i4 to i64
// CHECK: llvm.call @printI64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_si4(%arg0: si4) { func @vector_print_scalar_si4(%arg0: si4) {
vector.print %arg0 : si4 vector.print %arg0 : si4
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_si4( // CHECK-LABEL: llvm.func @vector_print_scalar_si4(
// CHECK-SAME: %[[A:.*]]: !llvm.i4) // CHECK-SAME: %[[A:.*]]: i4)
// CHECK: %[[S:.*]] = llvm.sext %[[A]] : !llvm.i4 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.sext %[[A]] : i4 to i64
// CHECK: llvm.call @printI64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_ui4(%arg0: ui4) { func @vector_print_scalar_ui4(%arg0: ui4) {
vector.print %arg0 : ui4 vector.print %arg0 : ui4
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_ui4( // CHECK-LABEL: llvm.func @vector_print_scalar_ui4(
// CHECK-SAME: %[[A:.*]]: !llvm.i4) // CHECK-SAME: %[[A:.*]]: i4)
// CHECK: %[[S:.*]] = llvm.zext %[[A]] : !llvm.i4 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.zext %[[A]] : i4 to i64
// CHECK: llvm.call @printU64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_i32(%arg0: i32) { func @vector_print_scalar_i32(%arg0: i32) {
vector.print %arg0 : i32 vector.print %arg0 : i32
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_i32( // CHECK-LABEL: llvm.func @vector_print_scalar_i32(
// CHECK-SAME: %[[A:.*]]: !llvm.i32) // CHECK-SAME: %[[A:.*]]: i32)
// CHECK: %[[S:.*]] = llvm.sext %[[A]] : !llvm.i32 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.sext %[[A]] : i32 to i64
// CHECK: llvm.call @printI64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_ui32(%arg0: ui32) { func @vector_print_scalar_ui32(%arg0: ui32) {
vector.print %arg0 : ui32 vector.print %arg0 : ui32
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_ui32( // CHECK-LABEL: llvm.func @vector_print_scalar_ui32(
// CHECK-SAME: %[[A:.*]]: !llvm.i32) // CHECK-SAME: %[[A:.*]]: i32)
// CHECK: %[[S:.*]] = llvm.zext %[[A]] : !llvm.i32 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.zext %[[A]] : i32 to i64
// CHECK: llvm.call @printU64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
func @vector_print_scalar_i40(%arg0: i40) { func @vector_print_scalar_i40(%arg0: i40) {
vector.print %arg0 : i40 vector.print %arg0 : i40
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_i40( // CHECK-LABEL: llvm.func @vector_print_scalar_i40(
// CHECK-SAME: %[[A:.*]]: !llvm.i40) // CHECK-SAME: %[[A:.*]]: i40)
// CHECK: %[[S:.*]] = llvm.sext %[[A]] : !llvm.i40 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.sext %[[A]] : i40 to i64
// CHECK: llvm.call @printI64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_si40(%arg0: si40) { func @vector_print_scalar_si40(%arg0: si40) {
vector.print %arg0 : si40 vector.print %arg0 : si40
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_si40( // CHECK-LABEL: llvm.func @vector_print_scalar_si40(
// CHECK-SAME: %[[A:.*]]: !llvm.i40) // CHECK-SAME: %[[A:.*]]: i40)
// CHECK: %[[S:.*]] = llvm.sext %[[A]] : !llvm.i40 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.sext %[[A]] : i40 to i64
// CHECK: llvm.call @printI64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_ui40(%arg0: ui40) { func @vector_print_scalar_ui40(%arg0: ui40) {
vector.print %arg0 : ui40 vector.print %arg0 : ui40
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_ui40( // CHECK-LABEL: llvm.func @vector_print_scalar_ui40(
// CHECK-SAME: %[[A:.*]]: !llvm.i40) // CHECK-SAME: %[[A:.*]]: i40)
// CHECK: %[[S:.*]] = llvm.zext %[[A]] : !llvm.i40 to !llvm.i64 // CHECK: %[[S:.*]] = llvm.zext %[[A]] : i40 to i64
// CHECK: llvm.call @printU64(%[[S]]) : (!llvm.i64) -> () // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_i64(%arg0: i64) { func @vector_print_scalar_i64(%arg0: i64) {
vector.print %arg0 : i64 vector.print %arg0 : i64
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_i64( // CHECK-LABEL: llvm.func @vector_print_scalar_i64(
// CHECK-SAME: %[[A:.*]]: !llvm.i64) // CHECK-SAME: %[[A:.*]]: i64)
// CHECK: llvm.call @printI64(%[[A]]) : (!llvm.i64) -> () // CHECK: llvm.call @printI64(%[[A]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_ui64(%arg0: ui64) { func @vector_print_scalar_ui64(%arg0: ui64) {
vector.print %arg0 : ui64 vector.print %arg0 : ui64
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_ui64( // CHECK-LABEL: llvm.func @vector_print_scalar_ui64(
// CHECK-SAME: %[[A:.*]]: !llvm.i64) // CHECK-SAME: %[[A:.*]]: i64)
// CHECK: llvm.call @printU64(%[[A]]) : (!llvm.i64) -> () // CHECK: llvm.call @printU64(%[[A]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_index(%arg0: index) { func @vector_print_scalar_index(%arg0: index) {
vector.print %arg0 : index vector.print %arg0 : index
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_index( // CHECK-LABEL: llvm.func @vector_print_scalar_index(
// CHECK-SAME: %[[A:.*]]: !llvm.i64) // CHECK-SAME: %[[A:.*]]: i64)
// CHECK: llvm.call @printU64(%[[A]]) : (!llvm.i64) -> () // CHECK: llvm.call @printU64(%[[A]]) : (i64) -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @vector_print_scalar_f32(%arg0: f32) { func @vector_print_scalar_f32(%arg0: f32) {
vector.print %arg0 : f32 vector.print %arg0 : f32
return return
} }
// CHECK-LABEL: llvm.func @vector_print_scalar_f32( // CHECK-LABEL: llvm.func @vector_print_scalar_f32(
// CHECK-SAME: %[[A:.*]]: !llvm.float) // CHECK-SAME: %[[A:.*]]: !llvm.float)
Show All 13 Linesfunc @vector_print_vector(%arg0: vector<2x2xf32>) {
vector.print %arg0 : vector<2x2xf32> vector.print %arg0 : vector<2x2xf32>
return return
} }
// CHECK-LABEL: llvm.func @vector_print_vector( // CHECK-LABEL: llvm.func @vector_print_vector(
// CHECK-SAME: %[[A:.*]]: !llvm.array<2 x vec<2 x float>>) // CHECK-SAME: %[[A:.*]]: !llvm.array<2 x vec<2 x float>>)
// CHECK: llvm.call @printOpen() : () -> () // CHECK: llvm.call @printOpen() : () -> ()
// CHECK: %[[x0:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<2 x vec<2 x float>> // CHECK: %[[x0:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<2 x vec<2 x float>>
// CHECK: llvm.call @printOpen() : () -> () // CHECK: llvm.call @printOpen() : () -> ()
// CHECK: %[[x1:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[x1:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[x2:.*]] = llvm.extractelement %[[x0]][%[[x1]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[x2:.*]] = llvm.extractelement %[[x0]][%[[x1]] : i64] : !llvm.vec<2 x float>
// CHECK: llvm.call @printF32(%[[x2]]) : (!llvm.float) -> () // CHECK: llvm.call @printF32(%[[x2]]) : (!llvm.float) -> ()
// CHECK: llvm.call @printComma() : () -> () // CHECK: llvm.call @printComma() : () -> ()
// CHECK: %[[x3:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[x3:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[x4:.*]] = llvm.extractelement %[[x0]][%[[x3]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[x4:.*]] = llvm.extractelement %[[x0]][%[[x3]] : i64] : !llvm.vec<2 x float>
// CHECK: llvm.call @printF32(%[[x4]]) : (!llvm.float) -> () // CHECK: llvm.call @printF32(%[[x4]]) : (!llvm.float) -> ()
// CHECK: llvm.call @printClose() : () -> () // CHECK: llvm.call @printClose() : () -> ()
// CHECK: llvm.call @printComma() : () -> () // CHECK: llvm.call @printComma() : () -> ()
// CHECK: %[[x5:.*]] = llvm.extractvalue %[[A]][1] : !llvm.array<2 x vec<2 x float>> // CHECK: %[[x5:.*]] = llvm.extractvalue %[[A]][1] : !llvm.array<2 x vec<2 x float>>
// CHECK: llvm.call @printOpen() : () -> () // CHECK: llvm.call @printOpen() : () -> ()
// CHECK: %[[x6:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[x6:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[x7:.*]] = llvm.extractelement %[[x5]][%[[x6]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[x7:.*]] = llvm.extractelement %[[x5]][%[[x6]] : i64] : !llvm.vec<2 x float>
// CHECK: llvm.call @printF32(%[[x7]]) : (!llvm.float) -> () // CHECK: llvm.call @printF32(%[[x7]]) : (!llvm.float) -> ()
// CHECK: llvm.call @printComma() : () -> () // CHECK: llvm.call @printComma() : () -> ()
// CHECK: %[[x8:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[x8:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : !llvm.i64] : !llvm.vec<2 x float> // CHECK: %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : i64] : !llvm.vec<2 x float>
// CHECK: llvm.call @printF32(%[[x9]]) : (!llvm.float) -> () // CHECK: llvm.call @printF32(%[[x9]]) : (!llvm.float) -> ()
// CHECK: llvm.call @printClose() : () -> () // CHECK: llvm.call @printClose() : () -> ()
// CHECK: llvm.call @printClose() : () -> () // CHECK: llvm.call @printClose() : () -> ()
// CHECK: llvm.call @printNewline() : () -> () // CHECK: llvm.call @printNewline() : () -> ()
func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> { func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> {
%0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32> %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
return %0 : vector<2xf32> return %0 : vector<2xf32>
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesfunc @insert_strided_slice2(%a: vector<2x2xf32>, %b: vector<4x4xf32>) -> vector<4x4xf32> {
return %0 : vector<4x4xf32> return %0 : vector<4x4xf32>
} }
// CHECK-LABEL: llvm.func @insert_strided_slice2 // CHECK-LABEL: llvm.func @insert_strided_slice2
// //
// Subvector vector<2xf32> @0 into vector<4xf32> @2 // Subvector vector<2xf32> @0 into vector<4xf32> @2
// CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<2 x vec<2 x float>> // CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<2 x vec<2 x float>>
// CHECK-NEXT: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x vec<4 x float>> // CHECK-NEXT: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x vec<4 x float>>
// Element @0 -> element @2 // Element @0 -> element @2
// CHECK-NEXT: llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<2 x float> // CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : !llvm.vec<2 x float>
// CHECK-NEXT: llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(2 : index) : i64
// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<4 x float> // CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : !llvm.vec<4 x float>
// Element @1 -> element @3 // Element @1 -> element @3
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<2 x float> // CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : !llvm.vec<2 x float>
// CHECK-NEXT: llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(3 : index) : i64
// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<4 x float> // CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : !llvm.vec<4 x float>
// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x vec<4 x float>> // CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x vec<4 x float>>
// //
// Subvector vector<2xf32> @1 into vector<4xf32> @3 // Subvector vector<2xf32> @1 into vector<4xf32> @3
// CHECK: llvm.extractvalue {{.*}}[1] : !llvm.array<2 x vec<2 x float>> // CHECK: llvm.extractvalue {{.*}}[1] : !llvm.array<2 x vec<2 x float>>
// CHECK-NEXT: llvm.extractvalue {{.*}}[3] : !llvm.array<4 x vec<4 x float>> // CHECK-NEXT: llvm.extractvalue {{.*}}[3] : !llvm.array<4 x vec<4 x float>>
// Element @0 -> element @2 // Element @0 -> element @2
// CHECK-NEXT: llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<2 x float> // CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : !llvm.vec<2 x float>
// CHECK-NEXT: llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(2 : index) : i64
// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<4 x float> // CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : !llvm.vec<4 x float>
// Element @1 -> element @3 // Element @1 -> element @3
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<2 x float> // CHECK-NEXT: llvm.extractelement {{.*}}[{{.*}} : i64] : !llvm.vec<2 x float>
// CHECK-NEXT: llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(3 : index) : i64
// CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm.vec<4 x float> // CHECK-NEXT: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : !llvm.vec<4 x float>
// CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x vec<4 x float>> // CHECK-NEXT: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x vec<4 x float>>
func @insert_strided_slice3(%arg0: vector<2x4xf32>, %arg1: vector<16x4x8xf32>) -> vector<16x4x8xf32> { func @insert_strided_slice3(%arg0: vector<2x4xf32>, %arg1: vector<16x4x8xf32>) -> vector<16x4x8xf32> {
%0 = vector.insert_strided_slice %arg0, %arg1 {offsets = [0, 0, 2], strides = [1, 1]}: %0 = vector.insert_strided_slice %arg0, %arg1 {offsets = [0, 0, 2], strides = [1, 1]}:
vector<2x4xf32> into vector<16x4x8xf32> vector<2x4xf32> into vector<16x4x8xf32>
return %0 : vector<16x4x8xf32> return %0 : vector<16x4x8xf32>
} }
// CHECK-LABEL: llvm.func @insert_strided_slice3( // CHECK-LABEL: llvm.func @insert_strided_slice3(
// CHECK-SAME: %[[A:.*]]: !llvm.array<2 x vec<4 x float>>, // CHECK-SAME: %[[A:.*]]: !llvm.array<2 x vec<4 x float>>,
// CHECK-SAME: %[[B:.*]]: !llvm.array<16 x array<4 x vec<8 x float>>>) // CHECK-SAME: %[[B:.*]]: !llvm.array<16 x array<4 x vec<8 x float>>>)
// CHECK: %[[s0:.*]] = llvm.extractvalue %[[B]][0] : !llvm.array<16 x array<4 x vec<8 x float>>> // CHECK: %[[s0:.*]] = llvm.extractvalue %[[B]][0] : !llvm.array<16 x array<4 x vec<8 x float>>>
// CHECK: %[[s1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<2 x vec<4 x float>> // CHECK: %[[s1:.*]] = llvm.extractvalue %[[A]][0] : !llvm.array<2 x vec<4 x float>>
// CHECK: %[[s2:.*]] = llvm.extractvalue %[[B]][0, 0] : !llvm.array<16 x array<4 x vec<8 x float>>> // CHECK: %[[s2:.*]] = llvm.extractvalue %[[B]][0, 0] : !llvm.array<16 x array<4 x vec<8 x float>>>
// CHECK: %[[s3:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[s3:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[s4:.*]] = llvm.extractelement %[[s1]][%[[s3]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s4:.*]] = llvm.extractelement %[[s1]][%[[s3]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s5:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[s5:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[s6:.*]] = llvm.insertelement %[[s4]], %[[s2]][%[[s5]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s6:.*]] = llvm.insertelement %[[s4]], %[[s2]][%[[s5]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s7:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[s7:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[s8:.*]] = llvm.extractelement %[[s1]][%[[s7]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s8:.*]] = llvm.extractelement %[[s1]][%[[s7]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s9:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: %[[s9:.*]] = llvm.mlir.constant(3 : index) : i64
// CHECK: %[[s10:.*]] = llvm.insertelement %[[s8]], %[[s6]][%[[s9]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s10:.*]] = llvm.insertelement %[[s8]], %[[s6]][%[[s9]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s11:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[s11:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[s12:.*]] = llvm.extractelement %[[s1]][%[[s11]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s12:.*]] = llvm.extractelement %[[s1]][%[[s11]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s13:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: %[[s13:.*]] = llvm.mlir.constant(4 : index) : i64
// CHECK: %[[s14:.*]] = llvm.insertelement %[[s12]], %[[s10]][%[[s13]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s14:.*]] = llvm.insertelement %[[s12]], %[[s10]][%[[s13]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s15:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: %[[s15:.*]] = llvm.mlir.constant(3 : index) : i64
// CHECK: %[[s16:.*]] = llvm.extractelement %[[s1]][%[[s15]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s16:.*]] = llvm.extractelement %[[s1]][%[[s15]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s17:.*]] = llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: %[[s17:.*]] = llvm.mlir.constant(5 : index) : i64
// CHECK: %[[s18:.*]] = llvm.insertelement %[[s16]], %[[s14]][%[[s17]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s18:.*]] = llvm.insertelement %[[s16]], %[[s14]][%[[s17]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s19:.*]] = llvm.insertvalue %[[s18]], %[[s0]][0] : !llvm.array<4 x vec<8 x float>> // CHECK: %[[s19:.*]] = llvm.insertvalue %[[s18]], %[[s0]][0] : !llvm.array<4 x vec<8 x float>>
// CHECK: %[[s20:.*]] = llvm.extractvalue %[[A]][1] : !llvm.array<2 x vec<4 x float>> // CHECK: %[[s20:.*]] = llvm.extractvalue %[[A]][1] : !llvm.array<2 x vec<4 x float>>
// CHECK: %[[s21:.*]] = llvm.extractvalue %[[B]][0, 1] : !llvm.array<16 x array<4 x vec<8 x float>>> // CHECK: %[[s21:.*]] = llvm.extractvalue %[[B]][0, 1] : !llvm.array<16 x array<4 x vec<8 x float>>>
// CHECK: %[[s22:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: %[[s22:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: %[[s23:.*]] = llvm.extractelement %[[s20]][%[[s22]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s23:.*]] = llvm.extractelement %[[s20]][%[[s22]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s24:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[s24:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[s25:.*]] = llvm.insertelement %[[s23]], %[[s21]][%[[s24]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s25:.*]] = llvm.insertelement %[[s23]], %[[s21]][%[[s24]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s26:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: %[[s26:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[s27:.*]] = llvm.extractelement %[[s20]][%[[s26]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s27:.*]] = llvm.extractelement %[[s20]][%[[s26]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s28:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: %[[s28:.*]] = llvm.mlir.constant(3 : index) : i64
// CHECK: %[[s29:.*]] = llvm.insertelement %[[s27]], %[[s25]][%[[s28]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s29:.*]] = llvm.insertelement %[[s27]], %[[s25]][%[[s28]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s30:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64 // CHECK: %[[s30:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[s31:.*]] = llvm.extractelement %[[s20]][%[[s30]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s31:.*]] = llvm.extractelement %[[s20]][%[[s30]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s32:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: %[[s32:.*]] = llvm.mlir.constant(4 : index) : i64
// CHECK: %[[s33:.*]] = llvm.insertelement %[[s31]], %[[s29]][%[[s32]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s33:.*]] = llvm.insertelement %[[s31]], %[[s29]][%[[s32]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s34:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: %[[s34:.*]] = llvm.mlir.constant(3 : index) : i64
// CHECK: %[[s35:.*]] = llvm.extractelement %[[s20]][%[[s34]] : !llvm.i64] : !llvm.vec<4 x float> // CHECK: %[[s35:.*]] = llvm.extractelement %[[s20]][%[[s34]] : i64] : !llvm.vec<4 x float>
// CHECK: %[[s36:.*]] = llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: %[[s36:.*]] = llvm.mlir.constant(5 : index) : i64
// CHECK: %[[s37:.*]] = llvm.insertelement %[[s35]], %[[s33]][%[[s36]] : !llvm.i64] : !llvm.vec<8 x float> // CHECK: %[[s37:.*]] = llvm.insertelement %[[s35]], %[[s33]][%[[s36]] : i64] : !llvm.vec<8 x float>
// CHECK: %[[s38:.*]] = llvm.insertvalue %[[s37]], %[[s19]][1] : !llvm.array<4 x vec<8 x float>> // CHECK: %[[s38:.*]] = llvm.insertvalue %[[s37]], %[[s19]][1] : !llvm.array<4 x vec<8 x float>>
// CHECK: %[[s39:.*]] = llvm.insertvalue %[[s38]], %[[B]][0] : !llvm.array<16 x array<4 x vec<8 x float>>> // CHECK: %[[s39:.*]] = llvm.insertvalue %[[s38]], %[[B]][0] : !llvm.array<16 x array<4 x vec<8 x float>>>
// CHECK: llvm.return %[[s39]] : !llvm.array<16 x array<4 x vec<8 x float>>> // CHECK: llvm.return %[[s39]] : !llvm.array<16 x array<4 x vec<8 x float>>>
func @extract_strides(%arg0: vector<3x3xf32>) -> vector<1x1xf32> { func @extract_strides(%arg0: vector<3x3xf32>) -> vector<1x1xf32> {
%0 = vector.extract_slices %arg0, [2, 2], [1, 1] %0 = vector.extract_slices %arg0, [2, 2], [1, 1]
: vector<3x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>> : vector<3x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>>
%1 = vector.tuple_get %0, 3 : tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>> %1 = vector.tuple_get %0, 3 : tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>>
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
func @reduce_i8(%arg0: vector<16xi8>) -> i8 { func @reduce_i8(%arg0: vector<16xi8>) -> i8 {
%0 = vector.reduction "add", %arg0 : vector<16xi8> into i8 %0 = vector.reduction "add", %arg0 : vector<16xi8> into i8
return %0 : i8 return %0 : i8
} }
// CHECK-LABEL: llvm.func @reduce_i8( // CHECK-LABEL: llvm.func @reduce_i8(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x i8>) // CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x i8>)
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]]) // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: llvm.return %[[V]] : !llvm.i8 // CHECK: llvm.return %[[V]] : i8
func @reduce_i32(%arg0: vector<16xi32>) -> i32 { func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
%0 = vector.reduction "add", %arg0 : vector<16xi32> into i32 %0 = vector.reduction "add", %arg0 : vector<16xi32> into i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: llvm.func @reduce_i32( // CHECK-LABEL: llvm.func @reduce_i32(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x i32>) // CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x i32>)
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]]) // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: llvm.return %[[V]] : !llvm.i32 // CHECK: llvm.return %[[V]] : i32
func @reduce_i64(%arg0: vector<16xi64>) -> i64 { func @reduce_i64(%arg0: vector<16xi64>) -> i64 {
%0 = vector.reduction "add", %arg0 : vector<16xi64> into i64 %0 = vector.reduction "add", %arg0 : vector<16xi64> into i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: llvm.func @reduce_i64( // CHECK-LABEL: llvm.func @reduce_i64(
// CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x i64>) // CHECK-SAME: %[[A:.*]]: !llvm.vec<16 x i64>)
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]]) // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: llvm.return %[[V]] : !llvm.i64 // CHECK: llvm.return %[[V]] : i64
// 4x16 16x3 4x3 // 4x16 16x3 4x3
func @matrix_ops(%A: vector<64xf64>, %B: vector<48xf64>) -> vector<12xf64> { func @matrix_ops(%A: vector<64xf64>, %B: vector<48xf64>) -> vector<12xf64> {
%C = vector.matrix_multiply %A, %B %C = vector.matrix_multiply %A, %B
{ lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } : { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
(vector<64xf64>, vector<48xf64>) -> vector<12xf64> (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
return %C: vector<12xf64> return %C: vector<12xf64>
Show All 9 Lines %f = vector.transfer_read %A[%base], %f7
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
memref<?xf32>, vector<17xf32> memref<?xf32>, vector<17xf32>
vector.transfer_write %f, %A[%base] vector.transfer_write %f, %A[%base]
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
vector<17xf32>, memref<?xf32> vector<17xf32>, memref<?xf32>
return %f: vector<17xf32> return %f: vector<17xf32>
} }
// CHECK-LABEL: func @transfer_read_1d // CHECK-LABEL: func @transfer_read_1d
// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm.vec<17 x float> // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: i64) -> !llvm.vec<17 x float>
// //
// 1. Bitcast to vector form. // 1. Bitcast to vector form.
// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
// CHECK-SAME: (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-SAME: (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : // CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
// CHECK-SAME: !llvm.ptr<float> to !llvm.ptr<vec<17 x float>> // CHECK-SAME: !llvm.ptr<float> to !llvm.ptr<vec<17 x float>>
// CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] : // CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] :
// CHECK-SAME: !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-SAME: !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// //
// 2. Create a vector with linear indices [ 0 .. vector_length - 1 ]. // 2. Create a vector with linear indices [ 0 .. vector_length - 1 ].
// CHECK: %[[linearIndex:.*]] = llvm.mlir.constant(dense // CHECK: %[[linearIndex:.*]] = llvm.mlir.constant(dense
// CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> : // CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> :
// CHECK-SAME: vector<17xi32>) : !llvm.vec<17 x i32> // CHECK-SAME: vector<17xi32>) : !llvm.vec<17 x i32>
// //
// 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. // 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
// CHECK: %[[otrunc:.*]] = llvm.trunc %[[BASE]] : !llvm.i64 to !llvm.i32 // CHECK: %[[otrunc:.*]] = llvm.trunc %[[BASE]] : i64 to i32
// CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32> // CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32>
// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[otrunc]], %[[offsetVec]][%[[c0]] : // CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[otrunc]], %[[offsetVec]][%[[c0]] :
// CHECK-SAME: !llvm.i32] : !llvm.vec<17 x i32> // CHECK-SAME: i32] : !llvm.vec<17 x i32>
// CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [ // CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] :
// CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32> // CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32>
// CHECK: %[[offsetVec4:.*]] = llvm.add %[[offsetVec3]], %[[linearIndex]] : // CHECK: %[[offsetVec4:.*]] = llvm.add %[[offsetVec3]], %[[linearIndex]] :
// CHECK-SAME: !llvm.vec<17 x i32> // CHECK-SAME: !llvm.vec<17 x i32>
// //
// 4. Let dim the memref dimension, compute the vector comparison mask: // 4. Let dim the memref dimension, compute the vector comparison mask:
// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] // [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
// CHECK: %[[dtrunc:.*]] = llvm.trunc %[[DIM]] : !llvm.i64 to !llvm.i32 // CHECK: %[[dtrunc:.*]] = llvm.trunc %[[DIM]] : i64 to i32
// CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32> // CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32>
// CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[dtrunc]], %[[dimVec]][%[[c01]] : // CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[dtrunc]], %[[dimVec]][%[[c01]] :
// CHECK-SAME: !llvm.i32] : !llvm.vec<17 x i32> // CHECK-SAME: i32] : !llvm.vec<17 x i32>
// CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [ // CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] :
// CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32> // CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32>
// CHECK: %[[mask:.*]] = llvm.icmp "slt" %[[offsetVec4]], %[[dimVec3]] : // CHECK: %[[mask:.*]] = llvm.icmp "slt" %[[offsetVec4]], %[[dimVec3]] :
// CHECK-SAME: !llvm.vec<17 x i32> // CHECK-SAME: !llvm.vec<17 x i32>
// //
// 5. Rewrite as a masked read. // 5. Rewrite as a masked read.
// CHECK: %[[PASS_THROUGH:.*]] = llvm.mlir.constant(dense<7.000000e+00> : // CHECK: %[[PASS_THROUGH:.*]] = llvm.mlir.constant(dense<7.000000e+00> :
// CHECK-SAME: vector<17xf32>) : !llvm.vec<17 x float> // CHECK-SAME: vector<17xf32>) : !llvm.vec<17 x float>
// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[vecPtr]], %[[mask]], // CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[vecPtr]], %[[mask]],
// CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} : // CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} :
// CHECK-SAME: (!llvm.ptr<vec<17 x float>>, !llvm.vec<17 x i1>, !llvm.vec<17 x float>) -> !llvm.vec<17 x float> // CHECK-SAME: (!llvm.ptr<vec<17 x float>>, !llvm.vec<17 x i1>, !llvm.vec<17 x float>) -> !llvm.vec<17 x float>
// //
// 1. Bitcast to vector form. // 1. Bitcast to vector form.
// CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} : // CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} :
// CHECK-SAME: (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-SAME: (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] : // CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] :
// CHECK-SAME: !llvm.ptr<float> to !llvm.ptr<vec<17 x float>> // CHECK-SAME: !llvm.ptr<float> to !llvm.ptr<vec<17 x float>>
// //
// 2. Create a vector with linear indices [ 0 .. vector_length - 1 ]. // 2. Create a vector with linear indices [ 0 .. vector_length - 1 ].
// CHECK: %[[linearIndex_b:.*]] = llvm.mlir.constant(dense // CHECK: %[[linearIndex_b:.*]] = llvm.mlir.constant(dense
// CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> : // CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> :
// CHECK-SAME: vector<17xi32>) : !llvm.vec<17 x i32> // CHECK-SAME: vector<17xi32>) : !llvm.vec<17 x i32>
// //
Show All 20 Lines
func @transfer_read_2d_to_1d(%A : memref<?x?xf32>, %base0: index, %base1: index) -> vector<17xf32> { func @transfer_read_2d_to_1d(%A : memref<?x?xf32>, %base0: index, %base1: index) -> vector<17xf32> {
%f7 = constant 7.0: f32 %f7 = constant 7.0: f32
%f = vector.transfer_read %A[%base0, %base1], %f7 %f = vector.transfer_read %A[%base0, %base1], %f7
{permutation_map = affine_map<(d0, d1) -> (d1)>} : {permutation_map = affine_map<(d0, d1) -> (d1)>} :
memref<?x?xf32>, vector<17xf32> memref<?x?xf32>, vector<17xf32>
return %f: vector<17xf32> return %f: vector<17xf32>
} }
// CHECK-LABEL: func @transfer_read_2d_to_1d // CHECK-LABEL: func @transfer_read_2d_to_1d
// CHECK-SAME: %[[BASE_0:[a-zA-Z0-9]*]]: !llvm.i64, %[[BASE_1:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm.vec<17 x float> // CHECK-SAME: %[[BASE_0:[a-zA-Z0-9]*]]: i64, %[[BASE_1:[a-zA-Z0-9]*]]: i64) -> !llvm.vec<17 x float>
// CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 1] : // CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 1] :
// CHECK-SAME: !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK-SAME: !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// //
// Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. // Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
// CHECK: %[[trunc:.*]] = llvm.trunc %[[BASE_1]] : !llvm.i64 to !llvm.i32 // CHECK: %[[trunc:.*]] = llvm.trunc %[[BASE_1]] : i64 to i32
// CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32> // CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32>
// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[trunc]], %[[offsetVec]][%[[c0]] : // CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[trunc]], %[[offsetVec]][%[[c0]] :
// CHECK-SAME: !llvm.i32] : !llvm.vec<17 x i32> // CHECK-SAME: i32] : !llvm.vec<17 x i32>
// CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [ // CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] :
// CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32> // CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32>
// //
// Let dim the memref dimension, compute the vector comparison mask: // Let dim the memref dimension, compute the vector comparison mask:
// [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ] // [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
// CHECK: %[[dimtrunc:.*]] = llvm.trunc %[[DIM]] : !llvm.i64 to !llvm.i32 // CHECK: %[[dimtrunc:.*]] = llvm.trunc %[[DIM]] : i64 to i32
// CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32> // CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm.vec<17 x i32>
// CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[dimtrunc]], %[[dimVec]][%[[c01]] : // CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[dimtrunc]], %[[dimVec]][%[[c01]] :
// CHECK-SAME: !llvm.i32] : !llvm.vec<17 x i32> // CHECK-SAME: i32] : !llvm.vec<17 x i32>
// CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [ // CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
// CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] : // CHECK-SAME: 0 : i32, 0 : i32, 0 : i32] :
// CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32> // CHECK-SAME: !llvm.vec<17 x i32>, !llvm.vec<17 x i32>
func @transfer_read_1d_non_zero_addrspace(%A : memref<?xf32, 3>, %base: index) -> vector<17xf32> { func @transfer_read_1d_non_zero_addrspace(%A : memref<?xf32, 3>, %base: index) -> vector<17xf32> {
%f7 = constant 7.0: f32 %f7 = constant 7.0: f32
%f = vector.transfer_read %A[%base], %f7 %f = vector.transfer_read %A[%base], %f7
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
memref<?xf32, 3>, vector<17xf32> memref<?xf32, 3>, vector<17xf32>
vector.transfer_write %f, %A[%base] vector.transfer_write %f, %A[%base]
{permutation_map = affine_map<(d0) -> (d0)>} : {permutation_map = affine_map<(d0) -> (d0)>} :
vector<17xf32>, memref<?xf32, 3> vector<17xf32>, memref<?xf32, 3>
return %f: vector<17xf32> return %f: vector<17xf32>
} }
// CHECK-LABEL: func @transfer_read_1d_non_zero_addrspace // CHECK-LABEL: func @transfer_read_1d_non_zero_addrspace
// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm.vec<17 x float> // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: i64) -> !llvm.vec<17 x float>
// //
// 1. Check address space for GEP is correct. // 1. Check address space for GEP is correct.
// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
// CHECK-SAME: (!llvm.ptr<float, 3>, !llvm.i64) -> !llvm.ptr<float, 3> // CHECK-SAME: (!llvm.ptr<float, 3>, i64) -> !llvm.ptr<float, 3>
// CHECK: %[[vecPtr:.*]] = llvm.addrspacecast %[[gep]] : // CHECK: %[[vecPtr:.*]] = llvm.addrspacecast %[[gep]] :
// CHECK-SAME: !llvm.ptr<float, 3> to !llvm.ptr<vec<17 x float>> // CHECK-SAME: !llvm.ptr<float, 3> to !llvm.ptr<vec<17 x float>>
// //
// 2. Check address space of the memref is correct. // 2. Check address space of the memref is correct.
// CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] : // CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] :
// CHECK-SAME: !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-SAME: !llvm.struct<(ptr<float, 3>, ptr<float, 3>, i64, array<1 x i64>, array<1 x i64>)>
// //
// 3. Check address apce for GEP is correct. // 3. Check address apce for GEP is correct.
// CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} : // CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} :
// CHECK-SAME: (!llvm.ptr<float, 3>, !llvm.i64) -> !llvm.ptr<float, 3> // CHECK-SAME: (!llvm.ptr<float, 3>, i64) -> !llvm.ptr<float, 3>
// CHECK: %[[vecPtr_b:.*]] = llvm.addrspacecast %[[gep_b]] : // CHECK: %[[vecPtr_b:.*]] = llvm.addrspacecast %[[gep_b]] :
// CHECK-SAME: !llvm.ptr<float, 3> to !llvm.ptr<vec<17 x float>> // CHECK-SAME: !llvm.ptr<float, 3> to !llvm.ptr<vec<17 x float>>
func @transfer_read_1d_not_masked(%A : memref<?xf32>, %base: index) -> vector<17xf32> { func @transfer_read_1d_not_masked(%A : memref<?xf32>, %base: index) -> vector<17xf32> {
%f7 = constant 7.0: f32 %f7 = constant 7.0: f32
%f = vector.transfer_read %A[%base], %f7 {masked = [false]} : %f = vector.transfer_read %A[%base], %f7 {masked = [false]} :
memref<?xf32>, vector<17xf32> memref<?xf32>, vector<17xf32>
return %f: vector<17xf32> return %f: vector<17xf32>
} }
// CHECK-LABEL: func @transfer_read_1d_not_masked // CHECK-LABEL: func @transfer_read_1d_not_masked
// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm.vec<17 x float> // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: i64) -> !llvm.vec<17 x float>
// //
// 1. Bitcast to vector form. // 1. Bitcast to vector form.
// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
// CHECK-SAME: (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> // CHECK-SAME: (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : // CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
// CHECK-SAME: !llvm.ptr<float> to !llvm.ptr<vec<17 x float>> // CHECK-SAME: !llvm.ptr<float> to !llvm.ptr<vec<17 x float>>
// //
// 2. Rewrite as a load. // 2. Rewrite as a load.
// CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vec<17 x float>> // CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vec<17 x float>>
func @transfer_read_1d_cast(%A : memref<?xi32>, %base: index) -> vector<12xi8> { func @transfer_read_1d_cast(%A : memref<?xi32>, %base: index) -> vector<12xi8> {
%c0 = constant 0: i32 %c0 = constant 0: i32
%v = vector.transfer_read %A[%base], %c0 {masked = [false]} : %v = vector.transfer_read %A[%base], %c0 {masked = [false]} :
memref<?xi32>, vector<12xi8> memref<?xi32>, vector<12xi8>
return %v: vector<12xi8> return %v: vector<12xi8>
} }
// CHECK-LABEL: func @transfer_read_1d_cast // CHECK-LABEL: func @transfer_read_1d_cast
// CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm.vec<12 x i8> // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: i64) -> !llvm.vec<12 x i8>
// //
// 1. Bitcast to vector form. // 1. Bitcast to vector form.
// CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} : // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
// CHECK-SAME: (!llvm.ptr<i32>, !llvm.i64) -> !llvm.ptr<i32> // CHECK-SAME: (!llvm.ptr<i32>, i64) -> !llvm.ptr<i32>
// CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] : // CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
// CHECK-SAME: !llvm.ptr<i32> to !llvm.ptr<vec<12 x i8>> // CHECK-SAME: !llvm.ptr<i32> to !llvm.ptr<vec<12 x i8>>
// //
// 2. Rewrite as a load. // 2. Rewrite as a load.
// CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vec<12 x i8>> // CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vec<12 x i8>>
func @genbool_1d() -> vector<8xi1> { func @genbool_1d() -> vector<8xi1> {
%0 = vector.constant_mask [4] : vector<8xi1> %0 = vector.constant_mask [4] : vector<8xi1>
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

mlir/test/Dialect/GPU/outlining.mlir

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Lines gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %c1, %grid_y = %c1,
"use3"(%arg0) : (memref<*xf32>) -> () "use3"(%arg0) : (memref<*xf32>) -> ()
gpu.terminator gpu.terminator
} }
return return
} }
// ----- // -----
llvm.mlir.global internal @global(42 : i64) : !llvm.i64 llvm.mlir.global internal @global(42 : i64) : i64
//CHECK-LABEL: @function_call //CHECK-LABEL: @function_call
func @function_call(%arg0 : memref<?xf32>) { func @function_call(%arg0 : memref<?xf32>) {
%cst = constant 8 : index %cst = constant 8 : index
gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %cst, %grid_y = %cst, gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %cst, %grid_y = %cst,
%grid_z = %cst) %grid_z = %cst)
threads(%tx, %ty, %tz) in (%block_x = %cst, %block_y = %cst, threads(%tx, %ty, %tz) in (%block_x = %cst, %block_y = %cst,
%block_z = %cst) { %block_z = %cst) {
Show All 17 Lines
// CHECK: gpu.module @function_call_kernel { // CHECK: gpu.module @function_call_kernel {
// CHECK: gpu.func @function_call_kernel() // CHECK: gpu.func @function_call_kernel()
// CHECK: call @device_function() : () -> () // CHECK: call @device_function() : () -> ()
// CHECK: call @device_function() : () -> () // CHECK: call @device_function() : () -> ()
// CHECK: llvm.mlir.addressof @global : !llvm.ptr<i64> // CHECK: llvm.mlir.addressof @global : !llvm.ptr<i64>
// CHECK: gpu.return // CHECK: gpu.return
// //
// CHECK: llvm.mlir.global internal @global(42 : i64) : !llvm.i64 // CHECK: llvm.mlir.global internal @global(42 : i64) : i64
// //
// CHECK: func @device_function() // CHECK: func @device_function()
// CHECK: func @recursive_device_function() // CHECK: func @recursive_device_function()
// CHECK-NOT: func @device_function // CHECK-NOT: func @device_function

mlir/test/Dialect/LLVMIR/dialect-cast.mlir

// RUN: mlir-opt -split-input-file -verify-diagnostics %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s
// These are the supported cases, just make sure they don't trigger errors, op // These are the supported cases, just make sure they don't trigger errors, op
// syntax is tested elsewhere. // syntax is tested elsewhere.
func @mlir_dialect_cast(%0: index, %1: i32, %2: bf16, %3: f16, %4: f32, %5: f64, func @mlir_dialect_cast(%0: index, %1: i32, %2: bf16, %3: f16, %4: f32, %5: f64,
%6: vector<42xf32>, %7: memref<42xf32>, %6: vector<42xf32>, %7: memref<42xf32>,
%8: memref<?xf32>, %9: memref<f32>, %8: memref<?xf32>, %9: memref<f32>,
%10: memref<*xf32>) { %10: memref<*xf32>) {
llvm.mlir.cast %0 : index to !llvm.i64 llvm.mlir.cast %0 : index to i64
llvm.mlir.cast %0 : index to !llvm.i32 llvm.mlir.cast %0 : index to i32
llvm.mlir.cast %1 : i32 to !llvm.i32
llvm.mlir.cast %2 : bf16 to !llvm.bfloat llvm.mlir.cast %2 : bf16 to !llvm.bfloat
llvm.mlir.cast %3 : f16 to !llvm.half llvm.mlir.cast %3 : f16 to !llvm.half
llvm.mlir.cast %4 : f32 to !llvm.float llvm.mlir.cast %4 : f32 to !llvm.float
llvm.mlir.cast %5 : f64 to !llvm.double llvm.mlir.cast %5 : f64 to !llvm.double
llvm.mlir.cast %6 : vector<42xf32> to !llvm.vec<42xfloat> llvm.mlir.cast %6 : vector<42xf32> to !llvm.vec<42xfloat>
llvm.mlir.cast %7 : memref<42xf32> to !llvm.ptr<float> llvm.mlir.cast %7 : memref<42xf32> to !llvm.ptr<float>
llvm.mlir.cast %7 : memref<42xf32> to !llvm.struct<(ptr<float>, ptr<float>, i64, array<1xi64>, array<1xi64>)> llvm.mlir.cast %7 : memref<42xf32> to !llvm.struct<(ptr<float>, ptr<float>, i64, array<1xi64>, array<1xi64>)>
llvm.mlir.cast %8 : memref<?xf32> to !llvm.struct<(ptr<float>, ptr<float>, i64, array<1xi64>, array<1xi64>)> llvm.mlir.cast %8 : memref<?xf32> to !llvm.struct<(ptr<float>, ptr<float>, i64, array<1xi64>, array<1xi64>)>
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
func @mlir_dialect_cast_f64(%0 : f64) { func @mlir_dialect_cast_f64(%0 : f64) {
// expected-error@+1 {{invalid cast between f64 and a type other than !llvm.double}} // expected-error@+1 {{invalid cast between f64 and a type other than !llvm.double}}
llvm.mlir.cast %0 : f64 to !llvm.float llvm.mlir.cast %0 : f64 to !llvm.float
} }
// ----- // -----
func @mlir_dialect_cast_integer_non_integer(%0 : i16) { func @mlir_dialect_cast_integer_non_integer(%0 : i16) {
// expected-error@+1 {{invalid cast between integer and non-integer type}} // expected-error@+1 {{unsupported cast}}
llvm.mlir.cast %0 : i16 to !llvm.half llvm.mlir.cast %0 : i16 to !llvm.half
} }
// ----- // -----
func @mlir_dialect_cast_integer_bitwidth_mismatch(%0 : i16) {
// expected-error@+1 {{invalid cast between integers with mismatching bitwidth}}
llvm.mlir.cast %0 : i16 to !llvm.i32
}
// -----
func @mlir_dialect_cast_nd_vector(%0 : vector<2x2xf32>) { func @mlir_dialect_cast_nd_vector(%0 : vector<2x2xf32>) {
// expected-error@+1 {{only 1-d vector is allowed}} // expected-error@+1 {{only 1-d vector is allowed}}
llvm.mlir.cast %0 : vector<2x2xf32> to !llvm.vec<4xfloat> llvm.mlir.cast %0 : vector<2x2xf32> to !llvm.vec<4xfloat>
} }
// ----- // -----
func @mlir_dialect_cast_scalable_vector(%0 : vector<2xf32>) { func @mlir_dialect_cast_scalable_vector(%0 : vector<2xf32>) {
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

mlir/test/Dialect/LLVMIR/func.mlir

// RUN: mlir-opt -split-input-file -verify-diagnostics %s | mlir-opt | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | mlir-opt | FileCheck %s
// RUN: mlir-opt -split-input-file -verify-diagnostics -mlir-print-op-generic %s | FileCheck %s --check-prefix=GENERIC // RUN: mlir-opt -split-input-file -verify-diagnostics -mlir-print-op-generic %s | FileCheck %s --check-prefix=GENERIC
module { module {
// GENERIC: "llvm.func" // GENERIC: "llvm.func"
// GENERIC: sym_name = "foo" // GENERIC: sym_name = "foo"
// GENERIC-SAME: type = !llvm.func<void ()> // GENERIC-SAME: type = !llvm.func<void ()>
// GENERIC-SAME: () -> () // GENERIC-SAME: () -> ()
// CHECK: llvm.func @foo() // CHECK: llvm.func @foo()
"llvm.func"() ({ "llvm.func"() ({
}) {sym_name = "foo", type = !llvm.func<void ()>} : () -> () }) {sym_name = "foo", type = !llvm.func<void ()>} : () -> ()
// GENERIC: "llvm.func" // GENERIC: "llvm.func"
// GENERIC: sym_name = "bar" // GENERIC: sym_name = "bar"
// GENERIC-SAME: type = !llvm.func<i64 (i64, i64)> // GENERIC-SAME: type = !llvm.func<i64 (i64, i64)>
// GENERIC-SAME: () -> () // GENERIC-SAME: () -> ()
// CHECK: llvm.func @bar(!llvm.i64, !llvm.i64) -> !llvm.i64 // CHECK: llvm.func @bar(i64, i64) -> i64
"llvm.func"() ({ "llvm.func"() ({
}) {sym_name = "bar", type = !llvm.func<i64 (i64, i64)>} : () -> () }) {sym_name = "bar", type = !llvm.func<i64 (i64, i64)>} : () -> ()
// GENERIC: "llvm.func" // GENERIC: "llvm.func"
// CHECK: llvm.func @baz(%{{.*}}: !llvm.i64) -> !llvm.i64 // CHECK: llvm.func @baz(%{{.*}}: i64) -> i64
"llvm.func"() ({ "llvm.func"() ({
// GENERIC: ^bb0 // GENERIC: ^bb0
^bb0(%arg0: !llvm.i64): ^bb0(%arg0: i64):
// GENERIC: llvm.return // GENERIC: llvm.return
llvm.return %arg0 : !llvm.i64 llvm.return %arg0 : i64
// GENERIC: sym_name = "baz" // GENERIC: sym_name = "baz"
// GENERIC-SAME: type = !llvm.func<i64 (i64)> // GENERIC-SAME: type = !llvm.func<i64 (i64)>
// GENERIC-SAME: () -> () // GENERIC-SAME: () -> ()
}) {sym_name = "baz", type = !llvm.func<i64 (i64)>} : () -> () }) {sym_name = "baz", type = !llvm.func<i64 (i64)>} : () -> ()
// CHECK: llvm.func @qux(!llvm.ptr<i64> {llvm.noalias = true}, !llvm.i64) // CHECK: llvm.func @qux(!llvm.ptr<i64> {llvm.noalias = true}, i64)
// CHECK: attributes {xxx = {yyy = 42 : i64}} // CHECK: attributes {xxx = {yyy = 42 : i64}}
"llvm.func"() ({ "llvm.func"() ({
}) {sym_name = "qux", type = !llvm.func<void (ptr<i64>, i64)>, }) {sym_name = "qux", type = !llvm.func<void (ptr<i64>, i64)>,
arg0 = {llvm.noalias = true}, xxx = {yyy = 42}} : () -> () arg0 = {llvm.noalias = true}, xxx = {yyy = 42}} : () -> ()
// CHECK: llvm.func @roundtrip1() // CHECK: llvm.func @roundtrip1()
llvm.func @roundtrip1() llvm.func @roundtrip1()
// CHECK: llvm.func @roundtrip2(!llvm.i64, !llvm.float) -> !llvm.double // CHECK: llvm.func @roundtrip2(i64, !llvm.float) -> !llvm.double
llvm.func @roundtrip2(!llvm.i64, !llvm.float) -> !llvm.double llvm.func @roundtrip2(i64, !llvm.float) -> !llvm.double
// CHECK: llvm.func @roundtrip3(!llvm.i32, !llvm.i1) // CHECK: llvm.func @roundtrip3(i32, i1)
llvm.func @roundtrip3(%a: !llvm.i32, %b: !llvm.i1) llvm.func @roundtrip3(%a: i32, %b: i1)
// CHECK: llvm.func @roundtrip4(%{{.*}}: !llvm.i32, %{{.*}}: !llvm.i1) { // CHECK: llvm.func @roundtrip4(%{{.*}}: i32, %{{.*}}: i1) {
llvm.func @roundtrip4(%a: !llvm.i32, %b: !llvm.i1) { llvm.func @roundtrip4(%a: i32, %b: i1) {
llvm.return llvm.return
} }
// CHECK: llvm.func @roundtrip5() // CHECK: llvm.func @roundtrip5()
// CHECK: attributes {baz = 42 : i64, foo = "bar"} // CHECK: attributes {baz = 42 : i64, foo = "bar"}
llvm.func @roundtrip5() attributes {foo = "bar", baz = 42} llvm.func @roundtrip5() attributes {foo = "bar", baz = 42}
// CHECK: llvm.func @roundtrip6() // CHECK: llvm.func @roundtrip6()
// CHECK: attributes {baz = 42 : i64, foo = "bar"} // CHECK: attributes {baz = 42 : i64, foo = "bar"}
llvm.func @roundtrip6() attributes {foo = "bar", baz = 42} { llvm.func @roundtrip6() attributes {foo = "bar", baz = 42} {
llvm.return llvm.return
} }
// CHECK: llvm.func @roundtrip7() { // CHECK: llvm.func @roundtrip7() {
llvm.func @roundtrip7() attributes {} { llvm.func @roundtrip7() attributes {} {
llvm.return llvm.return
} }
// CHECK: llvm.func @roundtrip8() -> !llvm.i32 // CHECK: llvm.func @roundtrip8() -> i32
llvm.func @roundtrip8() -> !llvm.i32 attributes {} llvm.func @roundtrip8() -> i32 attributes {}
// CHECK: llvm.func @roundtrip9(!llvm.ptr<i32> {llvm.noalias = true}) // CHECK: llvm.func @roundtrip9(!llvm.ptr<i32> {llvm.noalias = true})
llvm.func @roundtrip9(!llvm.ptr<i32> {llvm.noalias = true}) llvm.func @roundtrip9(!llvm.ptr<i32> {llvm.noalias = true})
// CHECK: llvm.func @roundtrip10(!llvm.ptr<i32> {llvm.noalias = true}) // CHECK: llvm.func @roundtrip10(!llvm.ptr<i32> {llvm.noalias = true})
llvm.func @roundtrip10(%arg0: !llvm.ptr<i32> {llvm.noalias = true}) llvm.func @roundtrip10(%arg0: !llvm.ptr<i32> {llvm.noalias = true})
// CHECK: llvm.func @roundtrip11(%{{.*}}: !llvm.ptr<i32> {llvm.noalias = true}) { // CHECK: llvm.func @roundtrip11(%{{.*}}: !llvm.ptr<i32> {llvm.noalias = true}) {
llvm.func @roundtrip11(%arg0: !llvm.ptr<i32> {llvm.noalias = true}) { llvm.func @roundtrip11(%arg0: !llvm.ptr<i32> {llvm.noalias = true}) {
llvm.return llvm.return
} }
// CHECK: llvm.func @roundtrip12(%{{.*}}: !llvm.ptr<i32> {llvm.noalias = true}) // CHECK: llvm.func @roundtrip12(%{{.*}}: !llvm.ptr<i32> {llvm.noalias = true})
// CHECK: attributes {foo = 42 : i32} // CHECK: attributes {foo = 42 : i32}
llvm.func @roundtrip12(%arg0: !llvm.ptr<i32> {llvm.noalias = true}) llvm.func @roundtrip12(%arg0: !llvm.ptr<i32> {llvm.noalias = true})
attributes {foo = 42 : i32} { attributes {foo = 42 : i32} {
llvm.return llvm.return
} }
// CHECK: llvm.func @variadic(...) // CHECK: llvm.func @variadic(...)
llvm.func @variadic(...) llvm.func @variadic(...)
// CHECK: llvm.func @variadic_args(!llvm.i32, !llvm.i32, ...) // CHECK: llvm.func @variadic_args(i32, i32, ...)
llvm.func @variadic_args(!llvm.i32, !llvm.i32, ...) llvm.func @variadic_args(i32, i32, ...)
// //
// Check that functions can have linkage attributes. // Check that functions can have linkage attributes.
// //
// CHECK: llvm.func internal // CHECK: llvm.func internal
llvm.func internal @internal_func() { llvm.func internal @internal_func() {
llvm.return llvm.return
Show All 32 Linesmodule {
// expected-error@+1 {{requires 'type' attribute of wrapped LLVM function type}} // expected-error@+1 {{requires 'type' attribute of wrapped LLVM function type}}
"llvm.func"() ({}) {sym_name = "non_llvm_type", type = i64} : () -> () "llvm.func"() ({}) {sym_name = "non_llvm_type", type = i64} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{requires 'type' attribute of wrapped LLVM function type}} // expected-error@+1 {{requires 'type' attribute of wrapped LLVM function type}}
"llvm.func"() ({}) {sym_name = "non_function_type", type = !llvm.i64} : () -> () "llvm.func"() ({}) {sym_name = "non_function_type", type = i64} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{entry block must have 0 arguments}} // expected-error@+1 {{entry block must have 0 arguments}}
"llvm.func"() ({ "llvm.func"() ({
^bb0(%arg0: !llvm.i64): ^bb0(%arg0: i64):
llvm.return llvm.return
}) {sym_name = "wrong_arg_number", type = !llvm.func<void ()>} : () -> () }) {sym_name = "wrong_arg_number", type = !llvm.func<void ()>} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{entry block argument #0 is not of LLVM type}} // expected-error@+1 {{entry block argument #0 is not of LLVM type}}
"llvm.func"() ({ "llvm.func"() ({
^bb0(%arg0: i64): ^bb0(%arg0: tensor<*xf32>):
llvm.return llvm.return
}) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> () }) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{entry block argument #0 does not match the function signature}} // expected-error@+1 {{entry block argument #0 does not match the function signature}}
"llvm.func"() ({ "llvm.func"() ({
^bb0(%arg0: !llvm.i32): ^bb0(%arg0: i32):
llvm.return llvm.return
}) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> () }) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> ()
} }
// ----- // -----
module { module {
// expected-error@+1 {{failed to construct function type: expected LLVM type for function arguments}} // expected-error@+1 {{failed to construct function type: expected LLVM type for function arguments}}
llvm.func @foo(i64) llvm.func @foo(tensor<*xf32>)
} }
// ----- // -----
module { module {
// expected-error@+1 {{failed to construct function type: expected LLVM type for function results}} // expected-error@+1 {{failed to construct function type: expected LLVM type for function results}}
llvm.func @foo() -> i64 llvm.func @foo() -> tensor<*xf32>
} }
// ----- // -----
module { module {
// expected-error@+1 {{failed to construct function type: expected zero or one function result}} // expected-error@+1 {{failed to construct function type: expected zero or one function result}}
llvm.func @foo() -> (!llvm.i64, !llvm.i64) llvm.func @foo() -> (i64, i64)
} }
// ----- // -----
module { module {
// expected-error@+1 {{only external functions can be variadic}} // expected-error@+1 {{only external functions can be variadic}}
llvm.func @variadic_def(...) { llvm.func @variadic_def(...) {
llvm.return llvm.return
} }
} }
// ----- // -----
module { module {
// expected-error@+1 {{variadic arguments must be in the end of the argument list}} // expected-error@+1 {{variadic arguments must be in the end of the argument list}}
llvm.func @variadic_inside(%arg0: !llvm.i32, ..., %arg1: !llvm.i32) llvm.func @variadic_inside(%arg0: i32, ..., %arg1: i32)
} }
// ----- // -----
module { module {
// expected-error@+1 {{external functions must have 'external' or 'extern_weak' linkage}} // expected-error@+1 {{external functions must have 'external' or 'extern_weak' linkage}}
llvm.func internal @internal_external_func() llvm.func internal @internal_external_func()
} }
// ----- // -----
module { module {
// expected-error@+1 {{functions cannot have 'common' linkage}} // expected-error@+1 {{functions cannot have 'common' linkage}}
llvm.func common @common_linkage_func() llvm.func common @common_linkage_func()
} }

mlir/test/Dialect/LLVMIR/global.mlir

// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
// CHECK: llvm.mlir.global external @default_external // CHECK: llvm.mlir.global external @default_external
llvm.mlir.global @default_external() : !llvm.i64 llvm.mlir.global @default_external() : i64
// CHECK: llvm.mlir.global external constant @default_external_constant // CHECK: llvm.mlir.global external constant @default_external_constant
llvm.mlir.global constant @default_external_constant(42) : !llvm.i64 llvm.mlir.global constant @default_external_constant(42) : i64
// CHECK: llvm.mlir.global internal @global(42 : i64) : !llvm.i64 // CHECK: llvm.mlir.global internal @global(42 : i64) : i64
llvm.mlir.global internal @global(42 : i64) : !llvm.i64 llvm.mlir.global internal @global(42 : i64) : i64
// CHECK: llvm.mlir.global internal constant @constant(3.700000e+01 : f64) : !llvm.float // CHECK: llvm.mlir.global internal constant @constant(3.700000e+01 : f64) : !llvm.float
llvm.mlir.global internal constant @constant(37.0) : !llvm.float llvm.mlir.global internal constant @constant(37.0) : !llvm.float
// CHECK: llvm.mlir.global internal constant @".string"("foobar") // CHECK: llvm.mlir.global internal constant @".string"("foobar")
llvm.mlir.global internal constant @".string"("foobar") : !llvm.array<6 x i8> llvm.mlir.global internal constant @".string"("foobar") : !llvm.array<6 x i8>
// CHECK: llvm.mlir.global internal @string_notype("1234567") // CHECK: llvm.mlir.global internal @string_notype("1234567")
llvm.mlir.global internal @string_notype("1234567") llvm.mlir.global internal @string_notype("1234567")
// CHECK: llvm.mlir.global internal @global_undef() // CHECK: llvm.mlir.global internal @global_undef()
llvm.mlir.global internal @global_undef() : !llvm.i64 llvm.mlir.global internal @global_undef() : i64
// CHECK: llvm.mlir.global internal @global_mega_initializer() : !llvm.i64 { // CHECK: llvm.mlir.global internal @global_mega_initializer() : i64 {
// CHECK-NEXT: %[[c:[0-9]+]] = llvm.mlir.constant(42 : i64) : !llvm.i64 // CHECK-NEXT: %[[c:[0-9]+]] = llvm.mlir.constant(42 : i64) : i64
// CHECK-NEXT: llvm.return %[[c]] : !llvm.i64 // CHECK-NEXT: llvm.return %[[c]] : i64
// CHECK-NEXT: } // CHECK-NEXT: }
llvm.mlir.global internal @global_mega_initializer() : !llvm.i64 { llvm.mlir.global internal @global_mega_initializer() : i64 {
%c = llvm.mlir.constant(42 : i64) : !llvm.i64 %c = llvm.mlir.constant(42 : i64) : i64
llvm.return %c : !llvm.i64 llvm.return %c : i64
} }
// Check different linkage types. // Check different linkage types.
// CHECK: llvm.mlir.global private // CHECK: llvm.mlir.global private
llvm.mlir.global private @private() : !llvm.i64 llvm.mlir.global private @private() : i64
// CHECK: llvm.mlir.global internal // CHECK: llvm.mlir.global internal
llvm.mlir.global internal @internal() : !llvm.i64 llvm.mlir.global internal @internal() : i64
// CHECK: llvm.mlir.global available_externally // CHECK: llvm.mlir.global available_externally
llvm.mlir.global available_externally @available_externally() : !llvm.i64 llvm.mlir.global available_externally @available_externally() : i64
// CHECK: llvm.mlir.global linkonce // CHECK: llvm.mlir.global linkonce
llvm.mlir.global linkonce @linkonce() : !llvm.i64 llvm.mlir.global linkonce @linkonce() : i64
// CHECK: llvm.mlir.global weak // CHECK: llvm.mlir.global weak
llvm.mlir.global weak @weak() : !llvm.i64 llvm.mlir.global weak @weak() : i64
// CHECK: llvm.mlir.global common // CHECK: llvm.mlir.global common
llvm.mlir.global common @common() : !llvm.i64 llvm.mlir.global common @common() : i64
// CHECK: llvm.mlir.global appending // CHECK: llvm.mlir.global appending
llvm.mlir.global appending @appending() : !llvm.i64 llvm.mlir.global appending @appending() : i64
// CHECK: llvm.mlir.global extern_weak // CHECK: llvm.mlir.global extern_weak
llvm.mlir.global extern_weak @extern_weak() : !llvm.i64 llvm.mlir.global extern_weak @extern_weak() : i64
// CHECK: llvm.mlir.global linkonce_odr // CHECK: llvm.mlir.global linkonce_odr
llvm.mlir.global linkonce_odr @linkonce_odr() : !llvm.i64 llvm.mlir.global linkonce_odr @linkonce_odr() : i64
// CHECK: llvm.mlir.global weak_odr // CHECK: llvm.mlir.global weak_odr
llvm.mlir.global weak_odr @weak_odr() : !llvm.i64 llvm.mlir.global weak_odr @weak_odr() : i64
// CHECK-LABEL: references // CHECK-LABEL: references
func @references() { func @references() {
// CHECK: llvm.mlir.addressof @global : !llvm.ptr<i64> // CHECK: llvm.mlir.addressof @global : !llvm.ptr<i64>
%0 = llvm.mlir.addressof @global : !llvm.ptr<i64> %0 = llvm.mlir.addressof @global : !llvm.ptr<i64>
// CHECK: llvm.mlir.addressof @".string" : !llvm.ptr<array<6 x i8>> // CHECK: llvm.mlir.addressof @".string" : !llvm.ptr<array<6 x i8>>
%1 = llvm.mlir.addressof @".string" : !llvm.ptr<array<6 x i8>> %1 = llvm.mlir.addressof @".string" : !llvm.ptr<array<6 x i8>>
llvm.return llvm.return
} }
// ----- // -----
// expected-error @+1 {{requires string attribute 'sym_name'}} // expected-error @+1 {{requires string attribute 'sym_name'}}
"llvm.mlir.global"() ({}) {type = !llvm.i64, constant, value = 42 : i64} : () -> () "llvm.mlir.global"() ({}) {type = i64, constant, value = 42 : i64} : () -> ()
// ----- // -----
// expected-error @+1 {{requires attribute 'type'}} // expected-error @+1 {{requires attribute 'type'}}
"llvm.mlir.global"() ({}) {sym_name = "foo", constant, value = 42 : i64} : () -> () "llvm.mlir.global"() ({}) {sym_name = "foo", constant, value = 42 : i64} : () -> ()
// ----- // -----
// expected-error @+1 {{expects type to be a valid element type for an LLVM pointer}} // expected-error @+1 {{expects type to be a valid element type for an LLVM pointer}}
llvm.mlir.global internal constant @constant(37.0) : !llvm.label llvm.mlir.global internal constant @constant(37.0) : !llvm.label
// ----- // -----
// expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}} // expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
"llvm.mlir.global"() ({}) {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = -1 : i32, linkage = 0} : () -> () "llvm.mlir.global"() ({}) {sym_name = "foo", type = i64, value = 42 : i64, addr_space = -1 : i32, linkage = 0} : () -> ()
// ----- // -----
// expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}} // expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
"llvm.mlir.global"() ({}) {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = 1.0 : f32, linkage = 0} : () -> () "llvm.mlir.global"() ({}) {sym_name = "foo", type = i64, value = 42 : i64, addr_space = 1.0 : f32, linkage = 0} : () -> ()
// ----- // -----
func @foo() { func @foo() {
// expected-error @+1 {{must appear at the module level}} // expected-error @+1 {{must appear at the module level}}
llvm.mlir.global internal @bar(42) : !llvm.i32 llvm.mlir.global internal @bar(42) : i32
} }
// ----- // -----
// expected-error @+1 {{requires an i8 array type of the length equal to that of the string}} // expected-error @+1 {{requires an i8 array type of the length equal to that of the string}}
llvm.mlir.global internal constant @string("foobar") : !llvm.array<42 x i8> llvm.mlir.global internal constant @string("foobar") : !llvm.array<42 x i8>
// ----- // -----
// expected-error @+1 {{type can only be omitted for string globals}} // expected-error @+1 {{type can only be omitted for string globals}}
llvm.mlir.global internal @i64_needs_type(0: i64) llvm.mlir.global internal @i64_needs_type(0: i64)
// ----- // -----
// expected-error @+1 {{expected zero or one type}} // expected-error @+1 {{expected zero or one type}}
llvm.mlir.global internal @more_than_one_type(0) : !llvm.i64, !llvm.i32 llvm.mlir.global internal @more_than_one_type(0) : i64, i32
// ----- // -----
llvm.mlir.global internal @foo(0: i32) : !llvm.i32 llvm.mlir.global internal @foo(0: i32) : i32
func @bar() { func @bar() {
// expected-error @+2{{expected ':'}} // expected-error @+2{{expected ':'}}
llvm.mlir.addressof @foo llvm.mlir.addressof @foo
} }
// ----- // -----
func @foo() { func @foo() {
// The attribute parser will consume the first colon-type, so we put two of // The attribute parser will consume the first colon-type, so we put two of
// them to trigger the attribute type mismatch error. // them to trigger the attribute type mismatch error.
// expected-error @+1 {{invalid kind of attribute specified}} // expected-error @+1 {{invalid kind of attribute specified}}
llvm.mlir.addressof "foo" : i64 : !llvm.ptr<func<void ()>> llvm.mlir.addressof "foo" : i64 : !llvm.ptr<func<void ()>>
} }
// ----- // -----
func @foo() { func @foo() {
// expected-error @+1 {{must reference a global defined by 'llvm.mlir.global'}} // expected-error @+1 {{must reference a global defined by 'llvm.mlir.global'}}
llvm.mlir.addressof @foo : !llvm.ptr<func<void ()>> llvm.mlir.addressof @foo : !llvm.ptr<func<void ()>>
} }
// ----- // -----
llvm.mlir.global internal @foo(0: i32) : !llvm.i32 llvm.mlir.global internal @foo(0: i32) : i32
func @bar() { func @bar() {
// expected-error @+1 {{the type must be a pointer to the type of the referenced global}} // expected-error @+1 {{the type must be a pointer to the type of the referenced global}}
llvm.mlir.addressof @foo : !llvm.ptr<i64> llvm.mlir.addressof @foo : !llvm.ptr<i64>
} }
// ----- // -----
llvm.func @foo() llvm.func @foo()
llvm.func @bar() { llvm.func @bar() {
// expected-error @+1 {{the type must be a pointer to the type of the referenced function}} // expected-error @+1 {{the type must be a pointer to the type of the referenced function}}
llvm.mlir.addressof @foo : !llvm.ptr<i8> llvm.mlir.addressof @foo : !llvm.ptr<i8>
} }
// ----- // -----
// expected-error @+2 {{'llvm.mlir.global' op expects regions to end with 'llvm.return', found 'llvm.mlir.constant'}} // expected-error @+2 {{'llvm.mlir.global' op expects regions to end with 'llvm.return', found 'llvm.mlir.constant'}}
// expected-note @+1 {{in custom textual format, the absence of terminator implies 'llvm.return'}} // expected-note @+1 {{in custom textual format, the absence of terminator implies 'llvm.return'}}
llvm.mlir.global internal @g() : !llvm.i64 { llvm.mlir.global internal @g() : i64 {
%c = llvm.mlir.constant(42 : i64) : !llvm.i64 %c = llvm.mlir.constant(42 : i64) : i64
} }
// ----- // -----
// expected-error @+1 {{'llvm.mlir.global' op initializer region type '!llvm.i64' does not match global type '!llvm.i32'}} // expected-error @+1 {{'llvm.mlir.global' op initializer region type 'i64' does not match global type 'i32'}}
llvm.mlir.global internal @g() : !llvm.i32 { llvm.mlir.global internal @g() : i32 {
%c = llvm.mlir.constant(42 : i64) : !llvm.i64 %c = llvm.mlir.constant(42 : i64) : i64
llvm.return %c : !llvm.i64 llvm.return %c : i64
} }
// ----- // -----
// expected-error @+1 {{'llvm.mlir.global' op cannot have both initializer value and region}} // expected-error @+1 {{'llvm.mlir.global' op cannot have both initializer value and region}}
llvm.mlir.global internal @g(43 : i64) : !llvm.i64 { llvm.mlir.global internal @g(43 : i64) : i64 {
%c = llvm.mlir.constant(42 : i64) : !llvm.i64 %c = llvm.mlir.constant(42 : i64) : i64
llvm.return %c : !llvm.i64 llvm.return %c : i64
} }
// ----- // -----
llvm.mlir.global internal @g(32 : i64) {addr_space = 3: i32} : !llvm.i64 llvm.mlir.global internal @g(32 : i64) {addr_space = 3: i32} : i64
func @mismatch_addr_space_implicit_global() { func @mismatch_addr_space_implicit_global() {
// expected-error @+1 {{op the type must be a pointer to the type of the referenced global}} // expected-error @+1 {{op the type must be a pointer to the type of the referenced global}}
llvm.mlir.addressof @g : !llvm.ptr<i64> llvm.mlir.addressof @g : !llvm.ptr<i64>
} }
// ----- // -----
llvm.mlir.global internal @g(32 : i64) {addr_space = 3: i32} : !llvm.i64 llvm.mlir.global internal @g(32 : i64) {addr_space = 3: i32} : i64
func @mismatch_addr_space() { func @mismatch_addr_space() {
// expected-error @+1 {{op the type must be a pointer to the type of the referenced global}} // expected-error @+1 {{op the type must be a pointer to the type of the referenced global}}
llvm.mlir.addressof @g : !llvm.ptr<i64, 4> llvm.mlir.addressof @g : !llvm.ptr<i64, 4>
} }

mlir/test/Dialect/LLVMIR/invalid.mlir

// RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics
// expected-error@+1{{llvm.noalias argument attribute of non boolean type}} // expected-error@+1{{llvm.noalias argument attribute of non boolean type}}
func @invalid_noalias(%arg0: !llvm.i32 {llvm.noalias = 3}) { func @invalid_noalias(%arg0: i32 {llvm.noalias = 3}) {
"llvm.return"() : () -> () "llvm.return"() : () -> ()
} }
// ----- // -----
// expected-error@+1{{llvm.align argument attribute of non integer type}} // expected-error@+1{{llvm.align argument attribute of non integer type}}
func @invalid_align(%arg0: !llvm.i32 {llvm.align = "foo"}) { func @invalid_align(%arg0: i32 {llvm.align = "foo"}) {
"llvm.return"() : () -> () "llvm.return"() : () -> ()
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Check that parser errors are properly produced and do not crash the compiler. // Check that parser errors are properly produced and do not crash the compiler.
// ----- // -----
func @icmp_non_string(%arg0 : !llvm.i32, %arg1 : !llvm.i16) { func @icmp_non_string(%arg0 : i32, %arg1 : i16) {
// expected-error@+1 {{invalid kind of attribute specified}} // expected-error@+1 {{invalid kind of attribute specified}}
llvm.icmp 42 %arg0, %arg0 : !llvm.i32 llvm.icmp 42 %arg0, %arg0 : i32
return return
} }
// ----- // -----
func @icmp_wrong_string(%arg0 : !llvm.i32, %arg1 : !llvm.i16) { func @icmp_wrong_string(%arg0 : i32, %arg1 : i16) {
// expected-error@+1 {{'foo' is an incorrect value of the 'predicate' attribute}} // expected-error@+1 {{'foo' is an incorrect value of the 'predicate' attribute}}
llvm.icmp "foo" %arg0, %arg0 : !llvm.i32 llvm.icmp "foo" %arg0, %arg0 : i32
return return
} }
// ----- // -----
func @alloca_missing_input_result_type(%size : !llvm.i64) { func @alloca_missing_input_result_type(%size : i64) {
// expected-error@+1 {{expected trailing function type with one argument and one result}} // expected-error@+1 {{expected trailing function type with one argument and one result}}
llvm.alloca %size x !llvm.i32 : () -> () llvm.alloca %size x i32 : () -> ()
} }
// ----- // -----
func @alloca_missing_input_type() { func @alloca_missing_input_type() {
// expected-error@+1 {{expected trailing function type with one argument and one result}} // expected-error@+1 {{expected trailing function type with one argument and one result}}
llvm.alloca %size x !llvm.i32 : () -> (!llvm.ptr<i32>) llvm.alloca %size x i32 : () -> (!llvm.ptr<i32>)
} }
// ----- // -----
func @alloca_missing_result_type() { func @alloca_missing_result_type() {
// expected-error@+1 {{expected trailing function type with one argument and one result}} // expected-error@+1 {{expected trailing function type with one argument and one result}}
llvm.alloca %size x !llvm.i32 : (!llvm.i64) -> () llvm.alloca %size x i32 : (i64) -> ()
} }
// ----- // -----
func @alloca_non_function_type() { func @alloca_non_function_type() {
// expected-error@+1 {{expected trailing function type with one argument and one result}} // expected-error@+1 {{expected trailing function type with one argument and one result}}
llvm.alloca %size x !llvm.i32 : !llvm.ptr<i32> llvm.alloca %size x i32 : !llvm.ptr<i32>
} }
// ----- // -----
func @alloca_non_integer_alignment() { func @alloca_non_integer_alignment() {
// expected-error@+1 {{expected integer alignment}} // expected-error@+1 {{expected integer alignment}}
llvm.alloca %size x !llvm.i32 {alignment = 3.0} : !llvm.ptr<i32> llvm.alloca %size x i32 {alignment = 3.0} : !llvm.ptr<i32>
} }
// ----- // -----
func @gep_missing_input_result_type(%pos : !llvm.i64, %base : !llvm.ptr<float>) { func @gep_missing_input_result_type(%pos : i64, %base : !llvm.ptr<float>) {
// expected-error@+1 {{2 operands present, but expected 0}} // expected-error@+1 {{2 operands present, but expected 0}}
llvm.getelementptr %base[%pos] : () -> () llvm.getelementptr %base[%pos] : () -> ()
} }
// ----- // -----
func @gep_missing_input_type(%pos : !llvm.i64, %base : !llvm.ptr<float>) { func @gep_missing_input_type(%pos : i64, %base : !llvm.ptr<float>) {
// expected-error@+1 {{2 operands present, but expected 0}} // expected-error@+1 {{2 operands present, but expected 0}}
llvm.getelementptr %base[%pos] : () -> (!llvm.ptr<float>) llvm.getelementptr %base[%pos] : () -> (!llvm.ptr<float>)
} }
// ----- // -----
func @gep_missing_result_type(%pos : !llvm.i64, %base : !llvm.ptr<float>) { func @gep_missing_result_type(%pos : i64, %base : !llvm.ptr<float>) {
// expected-error@+1 {{op requires one result}} // expected-error@+1 {{op requires one result}}
llvm.getelementptr %base[%pos] : (!llvm.ptr<float>, !llvm.i64) -> () llvm.getelementptr %base[%pos] : (!llvm.ptr<float>, i64) -> ()
} }
// ----- // -----
func @gep_non_function_type(%pos : !llvm.i64, %base : !llvm.ptr<float>) { func @gep_non_function_type(%pos : i64, %base : !llvm.ptr<float>) {
// expected-error@+1 {{invalid kind of type specified}} // expected-error@+1 {{invalid kind of type specified}}
llvm.getelementptr %base[%pos] : !llvm.ptr<float> llvm.getelementptr %base[%pos] : !llvm.ptr<float>
} }
// ----- // -----
func @load_non_llvm_type(%foo : memref<f32>) { func @load_non_llvm_type(%foo : memref<f32>) {
// expected-error@+1 {{expected LLVM pointer type}} // expected-error@+1 {{expected LLVM pointer type}}
Show All 18 Lines
func @store_non_ptr_type(%foo : !llvm.float, %bar : !llvm.float) { func @store_non_ptr_type(%foo : !llvm.float, %bar : !llvm.float) {
// expected-error@+1 {{expected LLVM pointer type}} // expected-error@+1 {{expected LLVM pointer type}}
llvm.store %bar, %foo : !llvm.float llvm.store %bar, %foo : !llvm.float
} }
// ----- // -----
func @call_non_function_type(%callee : !llvm.func<i8 (i8)>, %arg : !llvm.i8) { func @call_non_function_type(%callee : !llvm.func<i8 (i8)>, %arg : i8) {
// expected-error@+1 {{expected function type}} // expected-error@+1 {{expected function type}}
llvm.call %callee(%arg) : !llvm.func<i8 (i8)> llvm.call %callee(%arg) : !llvm.func<i8 (i8)>
} }
// ----- // -----
func @invalid_call() { func @invalid_call() {
// expected-error@+1 {{'llvm.call' op must have either a `callee` attribute or at least an operand}} // expected-error@+1 {{'llvm.call' op must have either a `callee` attribute or at least an operand}}
"llvm.call"() : () -> () "llvm.call"() : () -> ()
} }
// ----- // -----
func @call_non_function_type(%callee : !llvm.func<i8 (i8)>, %arg : !llvm.i8) { func @call_non_function_type(%callee : !llvm.func<i8 (i8)>, %arg : i8) {
// expected-error@+1 {{expected function type}} // expected-error@+1 {{expected function type}}
llvm.call %callee(%arg) : !llvm.func<i8 (i8)> llvm.call %callee(%arg) : !llvm.func<i8 (i8)>
} }
// ----- // -----
func @call_unknown_symbol() { func @call_unknown_symbol() {
// expected-error@+1 {{'llvm.call' op 'missing_callee' does not reference a symbol in the current scope}} // expected-error@+1 {{'llvm.call' op 'missing_callee' does not reference a symbol in the current scope}}
llvm.call @missing_callee() : () -> () llvm.call @missing_callee() : () -> ()
} }
// ----- // -----
func private @standard_func_callee() func private @standard_func_callee()
func @call_non_llvm() { func @call_non_llvm() {
// expected-error@+1 {{'llvm.call' op 'standard_func_callee' does not reference a valid LLVM function}} // expected-error@+1 {{'llvm.call' op 'standard_func_callee' does not reference a valid LLVM function}}
llvm.call @standard_func_callee() : () -> () llvm.call @standard_func_callee() : () -> ()
} }
// ----- // -----
func @call_non_llvm_indirect(%arg0 : i32) { func @call_non_llvm_indirect(%arg0 : tensor<*xi32>) {
// expected-error@+1 {{'llvm.call' op operand #0 must be LLVM dialect-compatible type, but got 'i32'}} // expected-error@+1 {{'llvm.call' op operand #0 must be LLVM dialect-compatible type}}
"llvm.call"(%arg0) : (i32) -> () "llvm.call"(%arg0) : (tensor<*xi32>) -> ()
} }
// ----- // -----
llvm.func @callee_func(!llvm.i8) -> () llvm.func @callee_func(i8) -> ()
func @callee_arg_mismatch(%arg0 : !llvm.i32) { func @callee_arg_mismatch(%arg0 : i32) {
// expected-error@+1 {{'llvm.call' op operand type mismatch for operand 0: '!llvm.i32' != '!llvm.i8'}} // expected-error@+1 {{'llvm.call' op operand type mismatch for operand 0: 'i32' != 'i8'}}
llvm.call @callee_func(%arg0) : (!llvm.i32) -> () llvm.call @callee_func(%arg0) : (i32) -> ()
} }
// ----- // -----
func @indirect_callee_arg_mismatch(%arg0 : !llvm.i32, %callee : !llvm.ptr<func<void(i8)>>) { func @indirect_callee_arg_mismatch(%arg0 : i32, %callee : !llvm.ptr<func<void(i8)>>) {
// expected-error@+1 {{'llvm.call' op operand type mismatch for operand 0: '!llvm.i32' != '!llvm.i8'}} // expected-error@+1 {{'llvm.call' op operand type mismatch for operand 0: 'i32' != 'i8'}}
"llvm.call"(%callee, %arg0) : (!llvm.ptr<func<void(i8)>>, !llvm.i32) -> () "llvm.call"(%callee, %arg0) : (!llvm.ptr<func<void(i8)>>, i32) -> ()
} }
// ----- // -----
llvm.func @callee_func() -> (!llvm.i8) llvm.func @callee_func() -> (i8)
func @callee_return_mismatch() { func @callee_return_mismatch() {
// expected-error@+1 {{'llvm.call' op result type mismatch: '!llvm.i32' != '!llvm.i8'}} // expected-error@+1 {{'llvm.call' op result type mismatch: 'i32' != 'i8'}}
%res = llvm.call @callee_func() : () -> (!llvm.i32) %res = llvm.call @callee_func() : () -> (i32)
} }
// ----- // -----
func @indirect_callee_return_mismatch(%callee : !llvm.ptr<func<i8()>>) { func @indirect_callee_return_mismatch(%callee : !llvm.ptr<func<i8()>>) {
// expected-error@+1 {{'llvm.call' op result type mismatch: '!llvm.i32' != '!llvm.i8'}} // expected-error@+1 {{'llvm.call' op result type mismatch: 'i32' != 'i8'}}
"llvm.call"(%callee) : (!llvm.ptr<func<i8()>>) -> (!llvm.i32) "llvm.call"(%callee) : (!llvm.ptr<func<i8()>>) -> (i32)
} }
// ----- // -----
func @call_too_many_results(%callee : () -> (i32,i32)) { func @call_too_many_results(%callee : () -> (i32,i32)) {
// expected-error@+1 {{expected function with 0 or 1 result}} // expected-error@+1 {{expected function with 0 or 1 result}}
llvm.call %callee() : () -> (i32, i32) llvm.call %callee() : () -> (i32, i32)
} }
// ----- // -----
func @call_non_llvm_result(%callee : () -> (i32)) { func @call_non_llvm_result(%callee : () -> (tensor<*xi32>)) {
// expected-error@+1 {{expected result to have LLVM type}} // expected-error@+1 {{expected result to have LLVM type}}
llvm.call %callee() : () -> (i32) llvm.call %callee() : () -> (tensor<*xi32>)
} }
// ----- // -----
func @call_non_llvm_input(%callee : (i32) -> (), %arg : i32) { func @call_non_llvm_input(%callee : (tensor<*xi32>) -> (), %arg : tensor<*xi32>) {
// expected-error@+1 {{expected LLVM types as inputs}} // expected-error@+1 {{expected LLVM types as inputs}}
llvm.call %callee(%arg) : (i32) -> () llvm.call %callee(%arg) : (tensor<*xi32>) -> ()
} }
// ----- // -----
func @constant_wrong_type() { func @constant_wrong_type() {
// expected-error@+1 {{only supports integer, float, string or elements attributes}} // expected-error@+1 {{only supports integer, float, string or elements attributes}}
llvm.mlir.constant(@constant_wrong_type) : !llvm.ptr<func<void ()>> llvm.mlir.constant(@constant_wrong_type) : !llvm.ptr<func<void ()>>
} }
// ----- // -----
func @insertvalue_non_llvm_type(%a : i32, %b : i32) { func @insertvalue_non_llvm_type(%a : i32, %b : i32) {
// expected-error@+1 {{expected LLVM IR Dialect type}} // expected-error@+1 {{expected LLVM IR Dialect type}}
llvm.insertvalue %a, %b[0] : i32 llvm.insertvalue %a, %b[0] : tensor<*xi32>
} }
// ----- // -----
func @insertvalue_non_array_position() { func @insertvalue_non_array_position() {
// Note the double-type, otherwise attribute parsing consumes the trailing // Note the double-type, otherwise attribute parsing consumes the trailing
// type of the op as the (wrong) attribute type. // type of the op as the (wrong) attribute type.
// expected-error@+1 {{invalid kind of attribute specified}} // expected-error@+1 {{invalid kind of attribute specified}}
Show All 25 Lines
func @insertvalue_wrong_nesting() { func @insertvalue_wrong_nesting() {
// expected-error@+1 {{expected LLVM IR structure/array type}} // expected-error@+1 {{expected LLVM IR structure/array type}}
llvm.insertvalue %a, %b[0,0] : !llvm.struct<(i32)> llvm.insertvalue %a, %b[0,0] : !llvm.struct<(i32)>
} }
// ----- // -----
func @extractvalue_non_llvm_type(%a : i32, %b : i32) { func @extractvalue_non_llvm_type(%a : i32, %b : tensor<*xi32>) {
// expected-error@+1 {{expected LLVM IR Dialect type}} // expected-error@+1 {{expected LLVM IR Dialect type}}
llvm.extractvalue %b[0] : i32 llvm.extractvalue %b[0] : tensor<*xi32>
} }
// ----- // -----
func @extractvalue_non_array_position() { func @extractvalue_non_array_position() {
// Note the double-type, otherwise attribute parsing consumes the trailing // Note the double-type, otherwise attribute parsing consumes the trailing
// type of the op as the (wrong) attribute type. // type of the op as the (wrong) attribute type.
// expected-error@+1 {{invalid kind of attribute specified}} // expected-error@+1 {{invalid kind of attribute specified}}
Show All 25 Lines
func @extractvalue_wrong_nesting() { func @extractvalue_wrong_nesting() {
// expected-error@+1 {{expected LLVM IR structure/array type}} // expected-error@+1 {{expected LLVM IR structure/array type}}
llvm.extractvalue %b[0,0] : !llvm.struct<(i32)> llvm.extractvalue %b[0,0] : !llvm.struct<(i32)>
} }
// ----- // -----
func @invalid_vector_type_1(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i32, %arg2: !llvm.float) { func @invalid_vector_type_1(%arg0: !llvm.vec<4 x float>, %arg1: i32, %arg2: !llvm.float) {
// expected-error@+1 {{expected LLVM IR dialect vector type for operand #1}} // expected-error@+1 {{expected LLVM IR dialect vector type for operand #1}}
%0 = llvm.extractelement %arg2[%arg1 : !llvm.i32] : !llvm.float %0 = llvm.extractelement %arg2[%arg1 : i32] : !llvm.float
} }
// ----- // -----
func @invalid_vector_type_2(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i32, %arg2: !llvm.float) { func @invalid_vector_type_2(%arg0: !llvm.vec<4 x float>, %arg1: i32, %arg2: !llvm.float) {
// expected-error@+1 {{expected LLVM IR dialect vector type for operand #1}} // expected-error@+1 {{expected LLVM IR dialect vector type for operand #1}}
%0 = llvm.insertelement %arg2, %arg2[%arg1 : !llvm.i32] : !llvm.float %0 = llvm.insertelement %arg2, %arg2[%arg1 : i32] : !llvm.float
} }
// ----- // -----
func @invalid_vector_type_3(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i32, %arg2: !llvm.float) { func @invalid_vector_type_3(%arg0: !llvm.vec<4 x float>, %arg1: i32, %arg2: !llvm.float) {
// expected-error@+1 {{expected LLVM IR dialect vector type for operand #1}} // expected-error@+1 {{expected LLVM IR dialect vector type for operand #1}}
%0 = llvm.shufflevector %arg2, %arg2 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.float, !llvm.float %0 = llvm.shufflevector %arg2, %arg2 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.float, !llvm.float
} }
// ----- // -----
func @null_non_llvm_type() { func @null_non_llvm_type() {
// expected-error@+1 {{must be LLVM pointer type, but got '!llvm.i32'}} // expected-error@+1 {{must be LLVM pointer type, but got 'i32'}}
llvm.mlir.null : !llvm.i32 llvm.mlir.null : i32
} }
// ----- // -----
func @nvvm_invalid_shfl_pred_1(%arg0 : !llvm.i32, %arg1 : !llvm.i32, %arg2 : !llvm.i32, %arg3 : !llvm.i32) { func @nvvm_invalid_shfl_pred_1(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i32) {
// expected-error@+1 {{expected return type to be a two-element struct with i1 as the second element}} // expected-error@+1 {{expected return type to be a two-element struct with i1 as the second element}}
%0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.i32 %0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : i32
} }
// ----- // -----
func @nvvm_invalid_shfl_pred_2(%arg0 : !llvm.i32, %arg1 : !llvm.i32, %arg2 : !llvm.i32, %arg3 : !llvm.i32) { func @nvvm_invalid_shfl_pred_2(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i32) {
// expected-error@+1 {{expected return type to be a two-element struct with i1 as the second element}} // expected-error@+1 {{expected return type to be a two-element struct with i1 as the second element}}
%0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(i32)> %0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(i32)>
} }
// ----- // -----
func @nvvm_invalid_shfl_pred_3(%arg0 : !llvm.i32, %arg1 : !llvm.i32, %arg2 : !llvm.i32, %arg3 : !llvm.i32) { func @nvvm_invalid_shfl_pred_3(%arg0 : i32, %arg1 : i32, %arg2 : i32, %arg3 : i32) {
// expected-error@+1 {{expected return type to be a two-element struct with i1 as the second element}} // expected-error@+1 {{expected return type to be a two-element struct with i1 as the second element}}
%0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(i32, i32)> %0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(i32, i32)>
} }
// ----- // -----
func @nvvm_invalid_mma_0(%a0 : !llvm.half, %a1 : !llvm.vec<2 x half>, func @nvvm_invalid_mma_0(%a0 : !llvm.half, %a1 : !llvm.vec<2 x half>,
%b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>, %b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>,
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
// ----- // -----
func @nvvm_invalid_mma_7(%a0 : !llvm.vec<2 x half>, %a1 : !llvm.vec<2 x half>, func @nvvm_invalid_mma_7(%a0 : !llvm.vec<2 x half>, %a1 : !llvm.vec<2 x half>,
%b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>, %b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>,
%c0 : !llvm.float, %c1 : !llvm.float, %c2 : !llvm.float, %c3 : !llvm.float, %c0 : !llvm.float, %c1 : !llvm.float, %c2 : !llvm.float, %c3 : !llvm.float,
%c4 : !llvm.float, %c5 : !llvm.float, %c6 : !llvm.float, %c7 : !llvm.float) { %c4 : !llvm.float, %c5 : !llvm.float, %c6 : !llvm.float, %c7 : !llvm.float) {
// expected-error@+1 {{op requires one result}} // expected-error@+1 {{op requires one result}}
%0:2 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="col", blayout="row"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> (!llvm.struct<(float, float, float, float, float, float, float, float)>, !llvm.i32) %0:2 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="col", blayout="row"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> (!llvm.struct<(float, float, float, float, float, float, float, float)>, i32)
llvm.return %0#0 : !llvm.struct<(float, float, float, float, float, float, float, float)> llvm.return %0#0 : !llvm.struct<(float, float, float, float, float, float, float, float)>
} }
// ----- // -----
func @atomicrmw_expected_ptr(%f32 : !llvm.float) { func @atomicrmw_expected_ptr(%f32 : !llvm.float) {
// expected-error@+1 {{operand #0 must be LLVM pointer to floating point LLVM type or LLVM integer type}} // expected-error@+1 {{operand #0 must be LLVM pointer to floating point LLVM type or LLVM integer type}}
%0 = "llvm.atomicrmw"(%f32, %f32) {bin_op=11, ordering=1} : (!llvm.float, !llvm.float) -> !llvm.float %0 = "llvm.atomicrmw"(%f32, %f32) {bin_op=11, ordering=1} : (!llvm.float, !llvm.float) -> !llvm.float
llvm.return llvm.return
} }
// ----- // -----
func @atomicrmw_mismatched_operands(%f32_ptr : !llvm.ptr<float>, %i32 : !llvm.i32) { func @atomicrmw_mismatched_operands(%f32_ptr : !llvm.ptr<float>, %i32 : i32) {
// expected-error@+1 {{expected LLVM IR element type for operand #0 to match type for operand #1}} // expected-error@+1 {{expected LLVM IR element type for operand #0 to match type for operand #1}}
%0 = "llvm.atomicrmw"(%f32_ptr, %i32) {bin_op=11, ordering=1} : (!llvm.ptr<float>, !llvm.i32) -> !llvm.float %0 = "llvm.atomicrmw"(%f32_ptr, %i32) {bin_op=11, ordering=1} : (!llvm.ptr<float>, i32) -> !llvm.float
llvm.return llvm.return
} }
// ----- // -----
func @atomicrmw_mismatched_operands(%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float) { func @atomicrmw_mismatched_operands(%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float) {
// expected-error@+1 {{expected LLVM IR result type to match type for operand #1}} // expected-error@+1 {{expected LLVM IR result type to match type for operand #1}}
%0 = "llvm.atomicrmw"(%f32_ptr, %f32) {bin_op=11, ordering=1} : (!llvm.ptr<float>, !llvm.float) -> !llvm.i32 %0 = "llvm.atomicrmw"(%f32_ptr, %f32) {bin_op=11, ordering=1} : (!llvm.ptr<float>, !llvm.float) -> i32
llvm.return llvm.return
} }
// ----- // -----
func @atomicrmw_expected_float(%i32_ptr : !llvm.ptr<i32>, %i32 : !llvm.i32) { func @atomicrmw_expected_float(%i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
// expected-error@+1 {{expected LLVM IR floating point type}} // expected-error@+1 {{expected LLVM IR floating point type}}
%0 = llvm.atomicrmw fadd %i32_ptr, %i32 unordered : !llvm.i32 %0 = llvm.atomicrmw fadd %i32_ptr, %i32 unordered : i32
llvm.return llvm.return
} }
// ----- // -----
func @atomicrmw_unexpected_xchg_type(%i1_ptr : !llvm.ptr<i1>, %i1 : !llvm.i1) { func @atomicrmw_unexpected_xchg_type(%i1_ptr : !llvm.ptr<i1>, %i1 : i1) {
// expected-error@+1 {{unexpected LLVM IR type for 'xchg' bin_op}} // expected-error@+1 {{unexpected LLVM IR type for 'xchg' bin_op}}
%0 = llvm.atomicrmw xchg %i1_ptr, %i1 unordered : !llvm.i1 %0 = llvm.atomicrmw xchg %i1_ptr, %i1 unordered : i1
llvm.return llvm.return
} }
// ----- // -----
func @atomicrmw_expected_int(%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float) { func @atomicrmw_expected_int(%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float) {
// expected-error@+1 {{expected LLVM IR integer type}} // expected-error@+1 {{expected LLVM IR integer type}}
%0 = llvm.atomicrmw max %f32_ptr, %f32 unordered : !llvm.float %0 = llvm.atomicrmw max %f32_ptr, %f32 unordered : !llvm.float
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_expected_ptr(%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float) { func @cmpxchg_expected_ptr(%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float) {
// expected-error@+1 {{op operand #0 must be LLVM pointer to LLVM integer type or LLVM pointer type}} // expected-error@+1 {{op operand #0 must be LLVM pointer to LLVM integer type or LLVM pointer type}}
%0 = "llvm.cmpxchg"(%f32, %f32, %f32) {success_ordering=2,failure_ordering=2} : (!llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, i1)> %0 = "llvm.cmpxchg"(%f32, %f32, %f32) {success_ordering=2,failure_ordering=2} : (!llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, i1)>
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_mismatched_operands(%i64_ptr : !llvm.ptr<i64>, %i32 : !llvm.i32) { func @cmpxchg_mismatched_operands(%i64_ptr : !llvm.ptr<i64>, %i32 : i32) {
// expected-error@+1 {{expected LLVM IR element type for operand #0 to match type for all other operands}} // expected-error@+1 {{expected LLVM IR element type for operand #0 to match type for all other operands}}
%0 = "llvm.cmpxchg"(%i64_ptr, %i32, %i32) {success_ordering=2,failure_ordering=2} : (!llvm.ptr<i64>, !llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> %0 = "llvm.cmpxchg"(%i64_ptr, %i32, %i32) {success_ordering=2,failure_ordering=2} : (!llvm.ptr<i64>, i32, i32) -> !llvm.struct<(i32, i1)>
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_unexpected_type(%i1_ptr : !llvm.ptr<i1>, %i1 : !llvm.i1) { func @cmpxchg_unexpected_type(%i1_ptr : !llvm.ptr<i1>, %i1 : i1) {
// expected-error@+1 {{unexpected LLVM IR type}} // expected-error@+1 {{unexpected LLVM IR type}}
%0 = llvm.cmpxchg %i1_ptr, %i1, %i1 monotonic monotonic : !llvm.i1 %0 = llvm.cmpxchg %i1_ptr, %i1, %i1 monotonic monotonic : i1
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_at_least_monotonic_success(%i32_ptr : !llvm.ptr<i32>, %i32 : !llvm.i32) { func @cmpxchg_at_least_monotonic_success(%i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
// expected-error@+1 {{ordering must be at least 'monotonic'}} // expected-error@+1 {{ordering must be at least 'monotonic'}}
%0 = llvm.cmpxchg %i32_ptr, %i32, %i32 unordered monotonic : !llvm.i32 %0 = llvm.cmpxchg %i32_ptr, %i32, %i32 unordered monotonic : i32
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_at_least_monotonic_failure(%i32_ptr : !llvm.ptr<i32>, %i32 : !llvm.i32) { func @cmpxchg_at_least_monotonic_failure(%i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
// expected-error@+1 {{ordering must be at least 'monotonic'}} // expected-error@+1 {{ordering must be at least 'monotonic'}}
%0 = llvm.cmpxchg %i32_ptr, %i32, %i32 monotonic unordered : !llvm.i32 %0 = llvm.cmpxchg %i32_ptr, %i32, %i32 monotonic unordered : i32
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_failure_release(%i32_ptr : !llvm.ptr<i32>, %i32 : !llvm.i32) { func @cmpxchg_failure_release(%i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
// expected-error@+1 {{failure ordering cannot be 'release' or 'acq_rel'}} // expected-error@+1 {{failure ordering cannot be 'release' or 'acq_rel'}}
%0 = llvm.cmpxchg %i32_ptr, %i32, %i32 acq_rel release : !llvm.i32 %0 = llvm.cmpxchg %i32_ptr, %i32, %i32 acq_rel release : i32
llvm.return llvm.return
} }
// ----- // -----
func @cmpxchg_failure_acq_rel(%i32_ptr : !llvm.ptr<i32>, %i32 : !llvm.i32) { func @cmpxchg_failure_acq_rel(%i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
// expected-error@+1 {{failure ordering cannot be 'release' or 'acq_rel'}} // expected-error@+1 {{failure ordering cannot be 'release' or 'acq_rel'}}
%0 = llvm.cmpxchg %i32_ptr, %i32, %i32 acq_rel acq_rel : !llvm.i32 %0 = llvm.cmpxchg %i32_ptr, %i32, %i32 acq_rel acq_rel : i32
llvm.return llvm.return
} }
// ----- // -----
llvm.func @foo(!llvm.i32) -> !llvm.i32 llvm.func @foo(i32) -> i32
llvm.func @__gxx_personality_v0(...) -> !llvm.i32 llvm.func @__gxx_personality_v0(...) -> i32
llvm.func @bad_landingpad(%arg0: !llvm.ptr<ptr<i8>>) attributes { personality = @__gxx_personality_v0} { llvm.func @bad_landingpad(%arg0: !llvm.ptr<ptr<i8>>) attributes { personality = @__gxx_personality_v0} {
%0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %0 = llvm.mlir.constant(3 : i32) : i32
%1 = llvm.mlir.constant(2 : i32) : !llvm.i32 %1 = llvm.mlir.constant(2 : i32) : i32
%2 = llvm.invoke @foo(%1) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 %2 = llvm.invoke @foo(%1) to ^bb1 unwind ^bb2 : (i32) -> i32
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %1 : !llvm.i32 llvm.return %1 : i32
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
// expected-error@+1 {{clause #0 is not a known constant - null, addressof, bitcast}} // expected-error@+1 {{clause #0 is not a known constant - null, addressof, bitcast}}
%3 = llvm.landingpad cleanup (catch %1 : !llvm.i32) (catch %arg0 : !llvm.ptr<ptr<i8>>) : !llvm.struct<(ptr<i8>, i32)> %3 = llvm.landingpad cleanup (catch %1 : i32) (catch %arg0 : !llvm.ptr<ptr<i8>>) : !llvm.struct<(ptr<i8>, i32)>
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
// ----- // -----
llvm.func @foo(!llvm.i32) -> !llvm.i32 llvm.func @foo(i32) -> i32
llvm.func @__gxx_personality_v0(...) -> !llvm.i32 llvm.func @__gxx_personality_v0(...) -> i32
llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0} { llvm.func @caller(%arg0: i32) -> i32 attributes { personality = @__gxx_personality_v0} {
%0 = llvm.mlir.constant(1 : i32) : !llvm.i32 %0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.alloca %0 x !llvm.ptr<i8> : (!llvm.i32) -> !llvm.ptr<ptr<i8>> %1 = llvm.alloca %0 x !llvm.ptr<i8> : (i32) -> !llvm.ptr<ptr<i8>>
// expected-note@+1 {{global addresses expected as operand to bitcast used in clauses for landingpad}} // expected-note@+1 {{global addresses expected as operand to bitcast used in clauses for landingpad}}
%2 = llvm.bitcast %1 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8> %2 = llvm.bitcast %1 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
%3 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 %3 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (i32) -> i32
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
// expected-error@+1 {{constant clauses expected}} // expected-error@+1 {{constant clauses expected}}
%5 = llvm.landingpad (catch %2 : !llvm.ptr<i8>) : !llvm.struct<(ptr<i8>, i32)> %5 = llvm.landingpad (catch %2 : !llvm.ptr<i8>) : !llvm.struct<(ptr<i8>, i32)>
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
// ----- // -----
llvm.func @foo(!llvm.i32) -> !llvm.i32 llvm.func @foo(i32) -> i32
llvm.func @__gxx_personality_v0(...) -> !llvm.i32 llvm.func @__gxx_personality_v0(...) -> i32
llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0} { llvm.func @caller(%arg0: i32) -> i32 attributes { personality = @__gxx_personality_v0} {
%0 = llvm.mlir.constant(1 : i32) : !llvm.i32 %0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (i32) -> i32
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
// expected-error@+1 {{landingpad instruction expects at least one clause or cleanup attribute}} // expected-error@+1 {{landingpad instruction expects at least one clause or cleanup attribute}}
%2 = llvm.landingpad : !llvm.struct<(ptr<i8>, i32)> %2 = llvm.landingpad : !llvm.struct<(ptr<i8>, i32)>
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
// ----- // -----
llvm.func @foo(!llvm.i32) -> !llvm.i32 llvm.func @foo(i32) -> i32
llvm.func @__gxx_personality_v0(...) -> !llvm.i32 llvm.func @__gxx_personality_v0(...) -> i32
llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } { llvm.func @caller(%arg0: i32) -> i32 attributes { personality = @__gxx_personality_v0 } {
%0 = llvm.mlir.constant(1 : i32) : !llvm.i32 %0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (i32) -> i32
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
%2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)> %2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)>
// expected-error@+1 {{'llvm.resume' op expects landingpad value as operand}} // expected-error@+1 {{'llvm.resume' op expects landingpad value as operand}}
llvm.resume %0 : !llvm.i32 llvm.resume %0 : i32
} }
// ----- // -----
llvm.func @foo(!llvm.i32) -> !llvm.i32 llvm.func @foo(i32) -> i32
llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { llvm.func @caller(%arg0: i32) -> i32 {
%0 = llvm.mlir.constant(1 : i32) : !llvm.i32 %0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 %1 = llvm.invoke @foo(%0) to ^bb1 unwind ^bb2 : (i32) -> i32
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
// expected-error@+1 {{llvm.landingpad needs to be in a function with a personality}} // expected-error@+1 {{llvm.landingpad needs to be in a function with a personality}}
%2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)> %2 = llvm.landingpad cleanup : !llvm.struct<(ptr<i8>, i32)>
llvm.resume %2 : !llvm.struct<(ptr<i8>, i32)> llvm.resume %2 : !llvm.struct<(ptr<i8>, i32)>
} }
// ----- // -----
func @invalid_ordering_in_fence() { func @invalid_ordering_in_fence() {
// expected-error @+1 {{can be given only acquire, release, acq_rel, and seq_cst orderings}} // expected-error @+1 {{can be given only acquire, release, acq_rel, and seq_cst orderings}}
llvm.fence syncscope("agent") monotonic llvm.fence syncscope("agent") monotonic
} }
// ----- // -----
// expected-error @+1 {{invalid data layout descriptor}} // expected-error @+1 {{invalid data layout descriptor}}
module attributes {llvm.data_layout = "#vjkr32"} { module attributes {llvm.data_layout = "#vjkr32"} {
func @invalid_data_layout() func @invalid_data_layout()
} }
// ----- // -----
func @switch_wrong_number_of_weights(%arg0 : !llvm.i32) { func @switch_wrong_number_of_weights(%arg0 : i32) {
// expected-error@+1 {{expects number of branch weights to match number of successors: 3 vs 2}} // expected-error@+1 {{expects number of branch weights to match number of successors: 3 vs 2}}
llvm.switch %arg0, ^bb1 [ llvm.switch %arg0, ^bb1 [
42: ^bb2(%arg0, %arg0 : !llvm.i32, !llvm.i32) 42: ^bb2(%arg0, %arg0 : i32, i32)
] {branch_weights = dense<[13, 17, 19]> : vector<3xi32>} ] {branch_weights = dense<[13, 17, 19]> : vector<3xi32>}
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return llvm.return
^bb2(%1: !llvm.i32, %2: !llvm.i32): // pred: ^bb0 ^bb2(%1: i32, %2: i32): // pred: ^bb0
llvm.return llvm.return
} }

mlir/test/Dialect/LLVMIR/legalize-for-export.mlir

// RUN: mlir-opt -llvm-legalize-for-export %s | FileCheck %s // RUN: mlir-opt -llvm-legalize-for-export %s | FileCheck %s
// Verifies that duplicate successor with different arguments are deduplicated // Verifies that duplicate successor with different arguments are deduplicated
// by introducing a new block that forwards its arguments to the original // by introducing a new block that forwards its arguments to the original
// successor through an unconditional branch. // successor through an unconditional branch.
// CHECK-LABEL: @repeated_successor_different_args // CHECK-LABEL: @repeated_successor_different_args
llvm.func @repeated_successor_different_args(%arg0: !llvm.i1, %arg1: !llvm.i32, %arg2: !llvm.i32) { llvm.func @repeated_successor_different_args(%arg0: i1, %arg1: i32, %arg2: i32) {
// CHECK: llvm.cond_br %{{.*}}, ^[[BB1:.*]]({{.*}}), ^[[BB2:.*]]({{.*}}) // CHECK: llvm.cond_br %{{.*}}, ^[[BB1:.*]]({{.*}}), ^[[BB2:.*]]({{.*}})
llvm.cond_br %arg0, ^bb1(%arg1: !llvm.i32), ^bb1(%arg2: !llvm.i32) llvm.cond_br %arg0, ^bb1(%arg1: i32), ^bb1(%arg2: i32)
// CHECK: ^[[BB1]]({{.*}}): // CHECK: ^[[BB1]]({{.*}}):
^bb1(%arg3: !llvm.i32): ^bb1(%arg3: i32):
llvm.return llvm.return
// CHECK: ^[[BB2]](%[[ARG:.*]]: !llvm.i32): // CHECK: ^[[BB2]](%[[ARG:.*]]: i32):
// CHECK: llvm.br ^[[BB1]](%[[ARG]] : !llvm.i32) // CHECK: llvm.br ^[[BB1]](%[[ARG]] : i32)
} }
// Verifies that duplicate successors without arguments do not lead to the // Verifies that duplicate successors without arguments do not lead to the
// introduction of new blocks during legalization. // introduction of new blocks during legalization.
// CHECK-LABEL: @repeated_successor_no_args // CHECK-LABEL: @repeated_successor_no_args
llvm.func @repeated_successor_no_args(%arg0: !llvm.i1) { llvm.func @repeated_successor_no_args(%arg0: i1) {
// CHECK: llvm.cond_br // CHECK: llvm.cond_br
llvm.cond_br %arg0, ^bb1, ^bb1 llvm.cond_br %arg0, ^bb1, ^bb1
// CHECK: ^{{.*}}: // CHECK: ^{{.*}}:
^bb1: ^bb1:
llvm.return llvm.return
// CHECK-NOT: ^{{.*}}: // CHECK-NOT: ^{{.*}}:
} }

mlir/test/Dialect/LLVMIR/nvvm.mlir

// RUN: mlir-opt %s | FileCheck %s // RUN: mlir-opt %s | FileCheck %s
func @nvvm_special_regs() -> !llvm.i32 { func @nvvm_special_regs() -> i32 {
// CHECK: nvvm.read.ptx.sreg.tid.x : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.tid.x : i32
%0 = nvvm.read.ptx.sreg.tid.x : !llvm.i32 %0 = nvvm.read.ptx.sreg.tid.x : i32
// CHECK: nvvm.read.ptx.sreg.tid.y : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.tid.y : i32
%1 = nvvm.read.ptx.sreg.tid.y : !llvm.i32 %1 = nvvm.read.ptx.sreg.tid.y : i32
// CHECK: nvvm.read.ptx.sreg.tid.z : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.tid.z : i32
%2 = nvvm.read.ptx.sreg.tid.z : !llvm.i32 %2 = nvvm.read.ptx.sreg.tid.z : i32
// CHECK: nvvm.read.ptx.sreg.ntid.x : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.ntid.x : i32
%3 = nvvm.read.ptx.sreg.ntid.x : !llvm.i32 %3 = nvvm.read.ptx.sreg.ntid.x : i32
// CHECK: nvvm.read.ptx.sreg.ntid.y : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.ntid.y : i32
%4 = nvvm.read.ptx.sreg.ntid.y : !llvm.i32 %4 = nvvm.read.ptx.sreg.ntid.y : i32
// CHECK: nvvm.read.ptx.sreg.ntid.z : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.ntid.z : i32
%5 = nvvm.read.ptx.sreg.ntid.z : !llvm.i32 %5 = nvvm.read.ptx.sreg.ntid.z : i32
// CHECK: nvvm.read.ptx.sreg.ctaid.x : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.ctaid.x : i32
%6 = nvvm.read.ptx.sreg.ctaid.x : !llvm.i32 %6 = nvvm.read.ptx.sreg.ctaid.x : i32
// CHECK: nvvm.read.ptx.sreg.ctaid.y : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.ctaid.y : i32
%7 = nvvm.read.ptx.sreg.ctaid.y : !llvm.i32 %7 = nvvm.read.ptx.sreg.ctaid.y : i32
// CHECK: nvvm.read.ptx.sreg.ctaid.z : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.ctaid.z : i32
%8 = nvvm.read.ptx.sreg.ctaid.z : !llvm.i32 %8 = nvvm.read.ptx.sreg.ctaid.z : i32
// CHECK: nvvm.read.ptx.sreg.nctaid.x : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.nctaid.x : i32
%9 = nvvm.read.ptx.sreg.nctaid.x : !llvm.i32 %9 = nvvm.read.ptx.sreg.nctaid.x : i32
// CHECK: nvvm.read.ptx.sreg.nctaid.y : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.nctaid.y : i32
%10 = nvvm.read.ptx.sreg.nctaid.y : !llvm.i32 %10 = nvvm.read.ptx.sreg.nctaid.y : i32
// CHECK: nvvm.read.ptx.sreg.nctaid.z : !llvm.i32 // CHECK: nvvm.read.ptx.sreg.nctaid.z : i32
%11 = nvvm.read.ptx.sreg.nctaid.z : !llvm.i32 %11 = nvvm.read.ptx.sreg.nctaid.z : i32
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
func @llvm.nvvm.barrier0() { func @llvm.nvvm.barrier0() {
// CHECK: nvvm.barrier0 // CHECK: nvvm.barrier0
nvvm.barrier0 nvvm.barrier0
llvm.return llvm.return
} }
func @nvvm_shfl( func @nvvm_shfl(
%arg0 : !llvm.i32, %arg1 : !llvm.i32, %arg2 : !llvm.i32, %arg0 : i32, %arg1 : i32, %arg2 : i32,
%arg3 : !llvm.i32, %arg4 : !llvm.float) -> !llvm.i32 { %arg3 : i32, %arg4 : !llvm.float) -> i32 {
// CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : i32
%0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 : !llvm.i32 %0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 : i32
// CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.float // CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.float
%1 = nvvm.shfl.sync.bfly %arg0, %arg4, %arg1, %arg2 : !llvm.float %1 = nvvm.shfl.sync.bfly %arg0, %arg4, %arg1, %arg2 : !llvm.float
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
func @nvvm_shfl_pred( func @nvvm_shfl_pred(
%arg0 : !llvm.i32, %arg1 : !llvm.i32, %arg2 : !llvm.i32, %arg0 : i32, %arg1 : i32, %arg2 : i32,
%arg3 : !llvm.i32, %arg4 : !llvm.float) -> !llvm.struct<(i32, i1)> { %arg3 : i32, %arg4 : !llvm.float) -> !llvm.struct<(i32, i1)> {
// CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.struct<(i32, i1)> // CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.struct<(i32, i1)>
%0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(i32, i1)> %0 = nvvm.shfl.sync.bfly %arg0, %arg3, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(i32, i1)>
// CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.struct<(float, i1)> // CHECK: nvvm.shfl.sync.bfly %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : !llvm.struct<(float, i1)>
%1 = nvvm.shfl.sync.bfly %arg0, %arg4, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(float, i1)> %1 = nvvm.shfl.sync.bfly %arg0, %arg4, %arg1, %arg2 {return_value_and_is_valid} : !llvm.struct<(float, i1)>
llvm.return %0 : !llvm.struct<(i32, i1)> llvm.return %0 : !llvm.struct<(i32, i1)>
} }
func @nvvm_vote(%arg0 : !llvm.i32, %arg1 : !llvm.i1) -> !llvm.i32 { func @nvvm_vote(%arg0 : i32, %arg1 : i1) -> i32 {
// CHECK: nvvm.vote.ballot.sync %{{.*}}, %{{.*}} : !llvm.i32 // CHECK: nvvm.vote.ballot.sync %{{.*}}, %{{.*}} : i32
%0 = nvvm.vote.ballot.sync %arg0, %arg1 : !llvm.i32 %0 = nvvm.vote.ballot.sync %arg0, %arg1 : i32
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
func @nvvm_mma(%a0 : !llvm.vec<2 x half>, %a1 : !llvm.vec<2 x half>, func @nvvm_mma(%a0 : !llvm.vec<2 x half>, %a1 : !llvm.vec<2 x half>,
%b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>, %b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>,
%c0 : !llvm.float, %c1 : !llvm.float, %c2 : !llvm.float, %c3 : !llvm.float, %c0 : !llvm.float, %c1 : !llvm.float, %c2 : !llvm.float, %c3 : !llvm.float,
%c4 : !llvm.float, %c5 : !llvm.float, %c6 : !llvm.float, %c7 : !llvm.float) { %c4 : !llvm.float, %c5 : !llvm.float, %c6 : !llvm.float, %c7 : !llvm.float) {
// CHECK: nvvm.mma.sync {{.*}} {alayout = "row", blayout = "col"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, float, float, float, float, float, float, float)> // CHECK: nvvm.mma.sync {{.*}} {alayout = "row", blayout = "col"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, float, float, float, float, float, float, float)>
%0 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="row", blayout="col"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, float, float, float, float, float, float, float)> %0 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="row", blayout="col"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, float, float, float, float, float, float, float)>
llvm.return %0 : !llvm.struct<(float, float, float, float, float, float, float, float)> llvm.return %0 : !llvm.struct<(float, float, float, float, float, float, float, float)>
} }

mlir/test/Dialect/LLVMIR/rocdl.mlir

// RUN: mlir-opt %s | FileCheck %s // RUN: mlir-opt %s | FileCheck %s
func @rocdl_special_regs() -> !llvm.i32 { func @rocdl_special_regs() -> i32 {
// CHECK-LABEL: rocdl_special_regs // CHECK-LABEL: rocdl_special_regs
// CHECK: rocdl.workitem.id.x : !llvm.i32 // CHECK: rocdl.workitem.id.x : i32
%0 = rocdl.workitem.id.x : !llvm.i32 %0 = rocdl.workitem.id.x : i32
// CHECK: rocdl.workitem.id.y : !llvm.i32 // CHECK: rocdl.workitem.id.y : i32
%1 = rocdl.workitem.id.y : !llvm.i32 %1 = rocdl.workitem.id.y : i32
// CHECK: rocdl.workitem.id.z : !llvm.i32 // CHECK: rocdl.workitem.id.z : i32
%2 = rocdl.workitem.id.z : !llvm.i32 %2 = rocdl.workitem.id.z : i32
// CHECK: rocdl.workgroup.id.x : !llvm.i32 // CHECK: rocdl.workgroup.id.x : i32
%3 = rocdl.workgroup.id.x : !llvm.i32 %3 = rocdl.workgroup.id.x : i32
// CHECK: rocdl.workgroup.id.y : !llvm.i32 // CHECK: rocdl.workgroup.id.y : i32
%4 = rocdl.workgroup.id.y : !llvm.i32 %4 = rocdl.workgroup.id.y : i32
// CHECK: rocdl.workgroup.id.z : !llvm.i32 // CHECK: rocdl.workgroup.id.z : i32
%5 = rocdl.workgroup.id.z : !llvm.i32 %5 = rocdl.workgroup.id.z : i32
// CHECK: rocdl.workgroup.dim.x : !llvm.i32 // CHECK: rocdl.workgroup.dim.x : i32
%6 = rocdl.workgroup.dim.x : !llvm.i32 %6 = rocdl.workgroup.dim.x : i32
// CHECK: rocdl.workgroup.dim.y : !llvm.i32 // CHECK: rocdl.workgroup.dim.y : i32
%7 = rocdl.workgroup.dim.y : !llvm.i32 %7 = rocdl.workgroup.dim.y : i32
// CHECK: rocdl.workgroup.dim.z : !llvm.i32 // CHECK: rocdl.workgroup.dim.z : i32
%8 = rocdl.workgroup.dim.z : !llvm.i32 %8 = rocdl.workgroup.dim.z : i32
// CHECK: rocdl.grid.dim.x : !llvm.i32 // CHECK: rocdl.grid.dim.x : i32
%9 = rocdl.grid.dim.x : !llvm.i32 %9 = rocdl.grid.dim.x : i32
// CHECK: rocdl.grid.dim.y : !llvm.i32 // CHECK: rocdl.grid.dim.y : i32
%10 = rocdl.grid.dim.y : !llvm.i32 %10 = rocdl.grid.dim.y : i32
// CHECK: rocdl.grid.dim.z : !llvm.i32 // CHECK: rocdl.grid.dim.z : i32
%11 = rocdl.grid.dim.z : !llvm.i32 %11 = rocdl.grid.dim.z : i32
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
func @rocdl.barrier() { func @rocdl.barrier() {
// CHECK: rocdl.barrier // CHECK: rocdl.barrier
rocdl.barrier rocdl.barrier
llvm.return llvm.return
} }
func @rocdl.xdlops(%arg0 : !llvm.float, %arg1 : !llvm.float, func @rocdl.xdlops(%arg0 : !llvm.float, %arg1 : !llvm.float,
%arg2 : !llvm.vec<32 x float>, %arg3 : !llvm.i32, %arg2 : !llvm.vec<32 x float>, %arg3 : i32,
%arg4 : !llvm.vec<16 x float>, %arg5 : !llvm.vec<4 x float>, %arg4 : !llvm.vec<16 x float>, %arg5 : !llvm.vec<4 x float>,
%arg6 : !llvm.vec<4 x half>, %arg7 : !llvm.vec<32 x i32>, %arg6 : !llvm.vec<4 x half>, %arg7 : !llvm.vec<32 x i32>,
%arg8 : !llvm.vec<16 x i32>, %arg9 : !llvm.vec<4 x i32>, %arg8 : !llvm.vec<16 x i32>, %arg9 : !llvm.vec<4 x i32>,
%arg10 : !llvm.vec<2 x i16>) -> !llvm.vec<32 x float> { %arg10 : !llvm.vec<2 x i16>) -> !llvm.vec<32 x float> {
// CHECK-LABEL: rocdl.xdlops // CHECK-LABEL: rocdl.xdlops
// CHECK: rocdl.mfma.f32.32x32x1f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<32 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> // CHECK: rocdl.mfma.f32.32x32x1f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<32 x float>, i32, i32, i32) -> !llvm.vec<32 x float>
%r0 = rocdl.mfma.f32.32x32x1f32 %arg0, %arg1, %arg2, %arg3, %arg3, %arg3 : %r0 = rocdl.mfma.f32.32x32x1f32 %arg0, %arg1, %arg2, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<32 x float>, (!llvm.float, !llvm.float, !llvm.vec<32 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> i32, i32, i32) -> !llvm.vec<32 x float>
// CHECK: rocdl.mfma.f32.16x16x1f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<16 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> // CHECK: rocdl.mfma.f32.16x16x1f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<16 x float>, i32, i32, i32) -> !llvm.vec<16 x float>
%r1 = rocdl.mfma.f32.16x16x1f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 : %r1 = rocdl.mfma.f32.16x16x1f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<16 x float>, (!llvm.float, !llvm.float, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: rocdl.mfma.f32.16x16x4f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<4 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> // CHECK: rocdl.mfma.f32.16x16x4f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<4 x float>, i32, i32, i32) -> !llvm.vec<4 x float>
%r2 = rocdl.mfma.f32.16x16x4f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 : %r2 = rocdl.mfma.f32.16x16x4f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<4 x float>, (!llvm.float, !llvm.float, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: rocdl.mfma.f32.4x4x1f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<4 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> // CHECK: rocdl.mfma.f32.4x4x1f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<4 x float>, i32, i32, i32) -> !llvm.vec<4 x float>
%r3 = rocdl.mfma.f32.4x4x1f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 : %r3 = rocdl.mfma.f32.4x4x1f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<4 x float>, (!llvm.float, !llvm.float, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: rocdl.mfma.f32.32x32x2f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<16 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> // CHECK: rocdl.mfma.f32.32x32x2f32 {{.*}} : (!llvm.float, !llvm.float, !llvm.vec<16 x float>, i32, i32, i32) -> !llvm.vec<16 x float>
%r4= rocdl.mfma.f32.32x32x2f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 : %r4= rocdl.mfma.f32.32x32x2f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<16 x float>, (!llvm.float, !llvm.float, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: rocdl.mfma.f32.32x32x4f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<32 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> // CHECK: rocdl.mfma.f32.32x32x4f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<32 x float>, i32, i32, i32) -> !llvm.vec<32 x float>
%r5 = rocdl.mfma.f32.32x32x4f16 %arg6, %arg6, %arg2, %arg3, %arg3, %arg3 : %r5 = rocdl.mfma.f32.32x32x4f16 %arg6, %arg6, %arg2, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<32 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<32 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> i32, i32, i32) -> !llvm.vec<32 x float>
// CHECK: rocdl.mfma.f32.16x16x4f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> // CHECK: rocdl.mfma.f32.16x16x4f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, i32, i32, i32) -> !llvm.vec<16 x float>
%r6 = rocdl.mfma.f32.16x16x4f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 : %r6 = rocdl.mfma.f32.16x16x4f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: rocdl.mfma.f32.4x4x4f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> // CHECK: rocdl.mfma.f32.4x4x4f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, i32, i32, i32) -> !llvm.vec<4 x float>
%r7 = rocdl.mfma.f32.4x4x4f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 : %r7 = rocdl.mfma.f32.4x4x4f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: rocdl.mfma.f32.32x32x8f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> // CHECK: rocdl.mfma.f32.32x32x8f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, i32, i32, i32) -> !llvm.vec<16 x float>
%r8 = rocdl.mfma.f32.32x32x8f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 : %r8 = rocdl.mfma.f32.32x32x8f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: rocdl.mfma.f32.16x16x16f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> // CHECK: rocdl.mfma.f32.16x16x16f16 {{.*}} : (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, i32, i32, i32) -> !llvm.vec<4 x float>
%r9 = rocdl.mfma.f32.16x16x16f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 : %r9 = rocdl.mfma.f32.16x16x16f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: rocdl.mfma.i32.32x32x4i8 {{.*}} : (!llvm.i32, !llvm.i32, !llvm.vec<32 x i32>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x i32> // CHECK: rocdl.mfma.i32.32x32x4i8 {{.*}} : (i32, i32, !llvm.vec<32 x i32>, i32, i32, i32) -> !llvm.vec<32 x i32>
%r10 = rocdl.mfma.i32.32x32x4i8 %arg3, %arg3, %arg7, %arg3, %arg3, %arg3 : %r10 = rocdl.mfma.i32.32x32x4i8 %arg3, %arg3, %arg7, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<32 x i32>, (i32, i32, !llvm.vec<32 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x i32> i32, i32, i32) -> !llvm.vec<32 x i32>
// CHECK: rocdl.mfma.i32.16x16x4i8 {{.*}} : (!llvm.i32, !llvm.i32, !llvm.vec<16 x i32>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x i32> // CHECK: rocdl.mfma.i32.16x16x4i8 {{.*}} : (i32, i32, !llvm.vec<16 x i32>, i32, i32, i32) -> !llvm.vec<16 x i32>
%r11 = rocdl.mfma.i32.16x16x4i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 : %r11 = rocdl.mfma.i32.16x16x4i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<16 x i32>, (i32, i32, !llvm.vec<16 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x i32> i32, i32, i32) -> !llvm.vec<16 x i32>
// CHECK: rocdl.mfma.i32.4x4x4i8 {{.*}} : (!llvm.i32, !llvm.i32, !llvm.vec<4 x i32>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x i32> // CHECK: rocdl.mfma.i32.4x4x4i8 {{.*}} : (i32, i32, !llvm.vec<4 x i32>, i32, i32, i32) -> !llvm.vec<4 x i32>
%r12 = rocdl.mfma.i32.4x4x4i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 : %r12 = rocdl.mfma.i32.4x4x4i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<4 x i32>, (i32, i32, !llvm.vec<4 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x i32> i32, i32, i32) -> !llvm.vec<4 x i32>
// CHECK: rocdl.mfma.i32.32x32x8i8 {{.*}} : (!llvm.i32, !llvm.i32, !llvm.vec<16 x i32>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x i32> // CHECK: rocdl.mfma.i32.32x32x8i8 {{.*}} : (i32, i32, !llvm.vec<16 x i32>, i32, i32, i32) -> !llvm.vec<16 x i32>
%r13 = rocdl.mfma.i32.32x32x8i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 : %r13 = rocdl.mfma.i32.32x32x8i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<16 x i32>, (i32, i32, !llvm.vec<16 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x i32> i32, i32, i32) -> !llvm.vec<16 x i32>
// CHECK: rocdl.mfma.i32.16x16x16i8 {{.*}} : (!llvm.i32, !llvm.i32, !llvm.vec<4 x i32>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x i32> // CHECK: rocdl.mfma.i32.16x16x16i8 {{.*}} : (i32, i32, !llvm.vec<4 x i32>, i32, i32, i32) -> !llvm.vec<4 x i32>
%r14 = rocdl.mfma.i32.16x16x16i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 : %r14 = rocdl.mfma.i32.16x16x16i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<4 x i32>, (i32, i32, !llvm.vec<4 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x i32> i32, i32, i32) -> !llvm.vec<4 x i32>
// CHECK: rocdl.mfma.f32.32x32x2bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<32 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> // CHECK: rocdl.mfma.f32.32x32x2bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<32 x float>, i32, i32, i32) -> !llvm.vec<32 x float>
%r15 = rocdl.mfma.f32.32x32x2bf16 %arg10, %arg10, %arg2, %arg3, %arg3, %arg3 : %r15 = rocdl.mfma.f32.32x32x2bf16 %arg10, %arg10, %arg2, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<32 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<32 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> i32, i32, i32) -> !llvm.vec<32 x float>
// CHECK: rocdl.mfma.f32.16x16x2bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> // CHECK: rocdl.mfma.f32.16x16x2bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, i32, i32, i32) -> !llvm.vec<16 x float>
%r16 = rocdl.mfma.f32.16x16x2bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 : %r16 = rocdl.mfma.f32.16x16x2bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: rocdl.mfma.f32.4x4x2bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> // CHECK: rocdl.mfma.f32.4x4x2bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, i32, i32, i32) -> !llvm.vec<4 x float>
%r17 = rocdl.mfma.f32.4x4x2bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 : %r17 = rocdl.mfma.f32.4x4x2bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: rocdl.mfma.f32.32x32x4bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> // CHECK: rocdl.mfma.f32.32x32x4bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, i32, i32, i32) -> !llvm.vec<16 x float>
%r18 = rocdl.mfma.f32.32x32x4bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 : %r18 = rocdl.mfma.f32.32x32x4bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: rocdl.mfma.f32.16x16x8bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, !llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> // CHECK: rocdl.mfma.f32.16x16x8bf16 {{.*}} : (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, i32, i32, i32) -> !llvm.vec<4 x float>
%r19 = rocdl.mfma.f32.16x16x8bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 : %r19 = rocdl.mfma.f32.16x16x8bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
llvm.return %r0 : !llvm.vec<32 x float> llvm.return %r0 : !llvm.vec<32 x float>
} }
llvm.func @rocdl.mubuf(%rsrc : !llvm.vec<4 x i32>, %vindex : !llvm.i32, llvm.func @rocdl.mubuf(%rsrc : !llvm.vec<4 x i32>, %vindex : i32,
%offset : !llvm.i32, %glc : !llvm.i1, %offset : i32, %glc : i1,
%slc : !llvm.i1, %vdata1 : !llvm.vec<1 x float>, %slc : i1, %vdata1 : !llvm.vec<1 x float>,
%vdata2 : !llvm.vec<2 x float>, %vdata4 : !llvm.vec<4 x float>) { %vdata2 : !llvm.vec<2 x float>, %vdata4 : !llvm.vec<4 x float>) {
// CHECK-LABEL: rocdl.mubuf // CHECK-LABEL: rocdl.mubuf
// CHECK: %{{.*}} = rocdl.buffer.load %{{.*}} %{{.*}} %{{.*}} %{{.*}} %{{.*}} : !llvm.vec<1 x float> // CHECK: %{{.*}} = rocdl.buffer.load %{{.*}} %{{.*}} %{{.*}} %{{.*}} %{{.*}} : !llvm.vec<1 x float>
%r1 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<1 x float> %r1 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<1 x float>
// CHECK: %{{.*}} = rocdl.buffer.load %{{.*}} %{{.*}} %{{.*}} %{{.*}} %{{.*}} : !llvm.vec<2 x float> // CHECK: %{{.*}} = rocdl.buffer.load %{{.*}} %{{.*}} %{{.*}} %{{.*}} %{{.*}} : !llvm.vec<2 x float>
%r2 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<2 x float> %r2 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<2 x float>
// CHECK: %{{.*}} = rocdl.buffer.load %{{.*}} %{{.*}} %{{.*}} %{{.*}} %{{.*}} : !llvm.vec<4 x float> // CHECK: %{{.*}} = rocdl.buffer.load %{{.*}} %{{.*}} %{{.*}} %{{.*}} %{{.*}} : !llvm.vec<4 x float>
%r4 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<4 x float> %r4 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<4 x float>
Show All 11 Lines

mlir/test/Dialect/LLVMIR/roundtrip.mlir

// RUN: mlir-opt %s | mlir-opt | FileCheck %s // RUN: mlir-opt %s | mlir-opt | FileCheck %s
// CHECK-LABEL: func @ops // CHECK-LABEL: func @ops
// CHECK-SAME: (%[[I32:.*]]: !llvm.i32, %[[FLOAT:.*]]: !llvm.float, %[[I8PTR1:.*]]: !llvm.ptr<i8>, %[[I8PTR2:.*]]: !llvm.ptr<i8>, %[[BOOL:.*]]: !llvm.i1) // CHECK-SAME: (%[[I32:.*]]: i32, %[[FLOAT:.*]]: !llvm.float, %[[I8PTR1:.*]]: !llvm.ptr<i8>, %[[I8PTR2:.*]]: !llvm.ptr<i8>, %[[BOOL:.*]]: i1)
func @ops(%arg0: !llvm.i32, %arg1: !llvm.float, func @ops(%arg0: i32, %arg1: !llvm.float,
%arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>, %arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>,
%arg4: !llvm.i1) { %arg4: i1) {
// Integer arithmetic binary operations. // Integer arithmetic binary operations.
// //
// CHECK: {{.*}} = llvm.add %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.add %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.sub %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.sub %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.mul %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.mul %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.udiv %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.udiv %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.sdiv %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.sdiv %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.urem %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.urem %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.srem %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.srem %[[I32]], %[[I32]] : i32
// CHECK: {{.*}} = llvm.icmp "ne" %[[I32]], %[[I32]] : !llvm.i32 // CHECK: {{.*}} = llvm.icmp "ne" %[[I32]], %[[I32]] : i32
%0 = llvm.add %arg0, %arg0 : !llvm.i32 %0 = llvm.add %arg0, %arg0 : i32
%1 = llvm.sub %arg0, %arg0 : !llvm.i32 %1 = llvm.sub %arg0, %arg0 : i32
%2 = llvm.mul %arg0, %arg0 : !llvm.i32 %2 = llvm.mul %arg0, %arg0 : i32
%3 = llvm.udiv %arg0, %arg0 : !llvm.i32 %3 = llvm.udiv %arg0, %arg0 : i32
%4 = llvm.sdiv %arg0, %arg0 : !llvm.i32 %4 = llvm.sdiv %arg0, %arg0 : i32
%5 = llvm.urem %arg0, %arg0 : !llvm.i32 %5 = llvm.urem %arg0, %arg0 : i32
%6 = llvm.srem %arg0, %arg0 : !llvm.i32 %6 = llvm.srem %arg0, %arg0 : i32
%7 = llvm.icmp "ne" %arg0, %arg0 : !llvm.i32 %7 = llvm.icmp "ne" %arg0, %arg0 : i32
// Floating point binary operations. // Floating point binary operations.
// //
// CHECK: {{.*}} = llvm.fadd %[[FLOAT]], %[[FLOAT]] : !llvm.float // CHECK: {{.*}} = llvm.fadd %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.fsub %[[FLOAT]], %[[FLOAT]] : !llvm.float // CHECK: {{.*}} = llvm.fsub %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.fmul %[[FLOAT]], %[[FLOAT]] : !llvm.float // CHECK: {{.*}} = llvm.fmul %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.fdiv %[[FLOAT]], %[[FLOAT]] : !llvm.float // CHECK: {{.*}} = llvm.fdiv %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.frem %[[FLOAT]], %[[FLOAT]] : !llvm.float // CHECK: {{.*}} = llvm.frem %[[FLOAT]], %[[FLOAT]] : !llvm.float
%8 = llvm.fadd %arg1, %arg1 : !llvm.float %8 = llvm.fadd %arg1, %arg1 : !llvm.float
%9 = llvm.fsub %arg1, %arg1 : !llvm.float %9 = llvm.fsub %arg1, %arg1 : !llvm.float
%10 = llvm.fmul %arg1, %arg1 : !llvm.float %10 = llvm.fmul %arg1, %arg1 : !llvm.float
%11 = llvm.fdiv %arg1, %arg1 : !llvm.float %11 = llvm.fdiv %arg1, %arg1 : !llvm.float
%12 = llvm.frem %arg1, %arg1 : !llvm.float %12 = llvm.frem %arg1, %arg1 : !llvm.float
// Memory-related operations. // Memory-related operations.
// //
// CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x !llvm.double : (!llvm.i32) -> !llvm.ptr<double> // CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x !llvm.double : (i32) -> !llvm.ptr<double>
// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]], %[[I32]]] : (!llvm.ptr<double>, !llvm.i32, !llvm.i32) -> !llvm.ptr<double> // CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]], %[[I32]]] : (!llvm.ptr<double>, i32, i32) -> !llvm.ptr<double>
// CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<double> // CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<double>
// CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : !llvm.ptr<double> // CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : !llvm.ptr<double>
// CHECK-NEXT: %{{.*}} = llvm.bitcast %[[ALLOCA]] : !llvm.ptr<double> to !llvm.ptr<i64> // CHECK-NEXT: %{{.*}} = llvm.bitcast %[[ALLOCA]] : !llvm.ptr<double> to !llvm.ptr<i64>
%13 = llvm.alloca %arg0 x !llvm.double : (!llvm.i32) -> !llvm.ptr<double> %13 = llvm.alloca %arg0 x !llvm.double : (i32) -> !llvm.ptr<double>
%14 = llvm.getelementptr %13[%arg0, %arg0] : (!llvm.ptr<double>, !llvm.i32, !llvm.i32) -> !llvm.ptr<double> %14 = llvm.getelementptr %13[%arg0, %arg0] : (!llvm.ptr<double>, i32, i32) -> !llvm.ptr<double>
%15 = llvm.load %14 : !llvm.ptr<double> %15 = llvm.load %14 : !llvm.ptr<double>
llvm.store %15, %13 : !llvm.ptr<double> llvm.store %15, %13 : !llvm.ptr<double>
%16 = llvm.bitcast %13 : !llvm.ptr<double> to !llvm.ptr<i64> %16 = llvm.bitcast %13 : !llvm.ptr<double> to !llvm.ptr<i64>
// Function call-related operations. // Function call-related operations.
// //
// CHECK: %[[STRUCT:.*]] = llvm.call @foo(%[[I32]]) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> // CHECK: %[[STRUCT:.*]] = llvm.call @foo(%[[I32]]) : (i32) -> !llvm.struct<(i32, double, i32)>
// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0] : !llvm.struct<(i32, double, i32)> // CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[NEW_STRUCT:.*]] = llvm.insertvalue %[[VALUE]], %[[STRUCT]][2] : !llvm.struct<(i32, double, i32)> // CHECK: %[[NEW_STRUCT:.*]] = llvm.insertvalue %[[VALUE]], %[[STRUCT]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @foo : !llvm.ptr<func<struct<(i32, double, i32)> (i32)>> // CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @foo : !llvm.ptr<func<struct<(i32, double, i32)> (i32)>>
// CHECK: %{{.*}} = llvm.call %[[FUNC]](%[[I32]]) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> // CHECK: %{{.*}} = llvm.call %[[FUNC]](%[[I32]]) : (i32) -> !llvm.struct<(i32, double, i32)>
%17 = llvm.call @foo(%arg0) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> %17 = llvm.call @foo(%arg0) : (i32) -> !llvm.struct<(i32, double, i32)>
%18 = llvm.extractvalue %17[0] : !llvm.struct<(i32, double, i32)> %18 = llvm.extractvalue %17[0] : !llvm.struct<(i32, double, i32)>
%19 = llvm.insertvalue %18, %17[2] : !llvm.struct<(i32, double, i32)> %19 = llvm.insertvalue %18, %17[2] : !llvm.struct<(i32, double, i32)>
%20 = llvm.mlir.addressof @foo : !llvm.ptr<func<struct<(i32, double, i32)> (i32)>> %20 = llvm.mlir.addressof @foo : !llvm.ptr<func<struct<(i32, double, i32)> (i32)>>
%21 = llvm.call %20(%arg0) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> %21 = llvm.call %20(%arg0) : (i32) -> !llvm.struct<(i32, double, i32)>
// Terminator operations and their successors. // Terminator operations and their successors.
// //
// CHECK: llvm.br ^[[BB1:.*]] // CHECK: llvm.br ^[[BB1:.*]]
llvm.br ^bb1 llvm.br ^bb1
// CHECK: ^[[BB1]] // CHECK: ^[[BB1]]
^bb1: ^bb1:
// CHECK: llvm.cond_br %7, ^[[BB2:.*]], ^[[BB3:.*]] // CHECK: llvm.cond_br %7, ^[[BB2:.*]], ^[[BB3:.*]]
llvm.cond_br %7, ^bb2, ^bb3 llvm.cond_br %7, ^bb2, ^bb3
// CHECK: ^[[BB2]] // CHECK: ^[[BB2]]
^bb2: ^bb2:
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(i32, double, i32)> // CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
// CHECK: %{{.*}} = llvm.mlir.constant(42 : i64) : !llvm.i47 // CHECK: %{{.*}} = llvm.mlir.constant(42 : i64) : i47
%22 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)> %22 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
%23 = llvm.mlir.constant(42) : !llvm.i47 %23 = llvm.mlir.constant(42) : i47
// CHECK: llvm.switch %0, ^[[BB3]] [ // CHECK: llvm.switch %0, ^[[BB3]] [
// CHECK-NEXT: 1: ^[[BB4:.*]], // CHECK-NEXT: 1: ^[[BB4:.*]],
// CHECK-NEXT: 2: ^[[BB5:.*]], // CHECK-NEXT: 2: ^[[BB5:.*]],
// CHECK-NEXT: 3: ^[[BB6:.*]] // CHECK-NEXT: 3: ^[[BB6:.*]]
// CHECK-NEXT: ] // CHECK-NEXT: ]
llvm.switch %0, ^bb3 [ llvm.switch %0, ^bb3 [
1: ^bb4, 1: ^bb4,
2: ^bb5, 2: ^bb5,
Show All 20 Lines
// CHECK: ^[[BB6]] // CHECK: ^[[BB6]]
^bb6: ^bb6:
llvm.switch %0, ^bb7 [ llvm.switch %0, ^bb7 [
] ]
// CHECK: ^[[BB7]] // CHECK: ^[[BB7]]
^bb7: ^bb7:
// Misc operations. // Misc operations.
// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i32 // CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : i1, i32
%24 = llvm.select %7, %0, %1 : !llvm.i1, !llvm.i32 %24 = llvm.select %7, %0, %1 : i1, i32
// Integer to pointer and pointer to integer conversions. // Integer to pointer and pointer to integer conversions.
// //
// CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : !llvm.i32 to !llvm.ptr<i32> // CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : i32 to !llvm.ptr<i32>
// CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr<i32> to !llvm.i32 // CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr<i32> to i32
%25 = llvm.inttoptr %arg0 : !llvm.i32 to !llvm.ptr<i32> %25 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
%26 = llvm.ptrtoint %25 : !llvm.ptr<i32> to !llvm.i32 %26 = llvm.ptrtoint %25 : !llvm.ptr<i32> to i32
// Extended and Quad floating point // Extended and Quad floating point
// //
// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : !llvm.float to !llvm.x86_fp80 // CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : !llvm.float to !llvm.x86_fp80
// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : !llvm.float to !llvm.fp128 // CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : !llvm.float to !llvm.fp128
%27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80 %27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80
%28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128 %28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128
// CHECK: %{{.*}} = llvm.fneg %[[FLOAT]] : !llvm.float // CHECK: %{{.*}} = llvm.fneg %[[FLOAT]] : !llvm.float
%29 = llvm.fneg %arg1 : !llvm.float %29 = llvm.fneg %arg1 : !llvm.float
// CHECK: "llvm.intr.sin"(%[[FLOAT]]) : (!llvm.float) -> !llvm.float // CHECK: "llvm.intr.sin"(%[[FLOAT]]) : (!llvm.float) -> !llvm.float
%30 = "llvm.intr.sin"(%arg1) : (!llvm.float) -> !llvm.float %30 = "llvm.intr.sin"(%arg1) : (!llvm.float) -> !llvm.float
// CHECK: "llvm.intr.pow"(%[[FLOAT]], %[[FLOAT]]) : (!llvm.float, !llvm.float) -> !llvm.float // CHECK: "llvm.intr.pow"(%[[FLOAT]], %[[FLOAT]]) : (!llvm.float, !llvm.float) -> !llvm.float
%31 = "llvm.intr.pow"(%arg1, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float %31 = "llvm.intr.pow"(%arg1, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float
// CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (!llvm.i32) -> !llvm.i32 // CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (i32) -> i32
%32 = "llvm.intr.bitreverse"(%arg0) : (!llvm.i32) -> !llvm.i32 %32 = "llvm.intr.bitreverse"(%arg0) : (i32) -> i32
// CHECK: "llvm.intr.ctpop"(%{{.*}}) : (!llvm.i32) -> !llvm.i32 // CHECK: "llvm.intr.ctpop"(%{{.*}}) : (i32) -> i32
%33 = "llvm.intr.ctpop"(%arg0) : (!llvm.i32) -> !llvm.i32 %33 = "llvm.intr.ctpop"(%arg0) : (i32) -> i32
// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> () // CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
"llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> () "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> () // CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
"llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> () "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
// CHECK: %[[SZ:.*]] = llvm.mlir.constant // CHECK: %[[SZ:.*]] = llvm.mlir.constant
%sz = llvm.mlir.constant(10: i64) : !llvm.i64 %sz = llvm.mlir.constant(10: i64) : i64
// CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i64, !llvm.i1) -> () // CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
"llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i64, !llvm.i1) -> () "llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
// CHECK: llvm.return // CHECK: llvm.return
llvm.return llvm.return
} }
// An larger self-contained function. // An larger self-contained function.
// CHECK-LABEL: llvm.func @foo(%{{.*}}: !llvm.i32) -> !llvm.struct<(i32, double, i32)> { // CHECK-LABEL: llvm.func @foo(%{{.*}}: i32) -> !llvm.struct<(i32, double, i32)> {
llvm.func @foo(%arg0: !llvm.i32) -> !llvm.struct<(i32, double, i32)> { llvm.func @foo(%arg0: i32) -> !llvm.struct<(i32, double, i32)> {
// CHECK: %[[V0:.*]] = llvm.mlir.constant(3 : i64) : !llvm.i32 // CHECK: %[[V0:.*]] = llvm.mlir.constant(3 : i64) : i32
// CHECK: %[[V1:.*]] = llvm.mlir.constant(3 : i64) : !llvm.i32 // CHECK: %[[V1:.*]] = llvm.mlir.constant(3 : i64) : i32
// CHECK: %[[V2:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double // CHECK: %[[V2:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double
// CHECK: %[[V3:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double // CHECK: %[[V3:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double
// CHECK: %[[V4:.*]] = llvm.add %[[V0]], %[[V1]] : !llvm.i32 // CHECK: %[[V4:.*]] = llvm.add %[[V0]], %[[V1]] : i32
// CHECK: %[[V5:.*]] = llvm.mul %[[V4]], %[[V1]] : !llvm.i32 // CHECK: %[[V5:.*]] = llvm.mul %[[V4]], %[[V1]] : i32
// CHECK: %[[V6:.*]] = llvm.fadd %[[V2]], %[[V3]] : !llvm.double // CHECK: %[[V6:.*]] = llvm.fadd %[[V2]], %[[V3]] : !llvm.double
// CHECK: %[[V7:.*]] = llvm.fsub %[[V3]], %[[V6]] : !llvm.double // CHECK: %[[V7:.*]] = llvm.fsub %[[V3]], %[[V6]] : !llvm.double
// CHECK: %[[V8:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i1 // CHECK: %[[V8:.*]] = llvm.mlir.constant(1 : i64) : i1
// CHECK: llvm.cond_br %[[V8]], ^[[BB1:.*]](%[[V4]] : !llvm.i32), ^[[BB2:.*]](%[[V4]] : !llvm.i32) // CHECK: llvm.cond_br %[[V8]], ^[[BB1:.*]](%[[V4]] : i32), ^[[BB2:.*]](%[[V4]] : i32)
%0 = llvm.mlir.constant(3) : !llvm.i32 %0 = llvm.mlir.constant(3) : i32
%1 = llvm.mlir.constant(3) : !llvm.i32 %1 = llvm.mlir.constant(3) : i32
%2 = llvm.mlir.constant(4.200000e+01) : !llvm.double %2 = llvm.mlir.constant(4.200000e+01) : !llvm.double
%3 = llvm.mlir.constant(4.200000e+01) : !llvm.double %3 = llvm.mlir.constant(4.200000e+01) : !llvm.double
%4 = llvm.add %0, %1 : !llvm.i32 %4 = llvm.add %0, %1 : i32
%5 = llvm.mul %4, %1 : !llvm.i32 %5 = llvm.mul %4, %1 : i32
%6 = llvm.fadd %2, %3 : !llvm.double %6 = llvm.fadd %2, %3 : !llvm.double
%7 = llvm.fsub %3, %6 : !llvm.double %7 = llvm.fsub %3, %6 : !llvm.double
%8 = llvm.mlir.constant(1) : !llvm.i1 %8 = llvm.mlir.constant(1) : i1
llvm.cond_br %8, ^bb1(%4 : !llvm.i32), ^bb2(%4 : !llvm.i32) llvm.cond_br %8, ^bb1(%4 : i32), ^bb2(%4 : i32)
// CHECK:^[[BB1]](%[[V9:.*]]: !llvm.i32): // CHECK:^[[BB1]](%[[V9:.*]]: i32):
// CHECK: %[[V10:.*]] = llvm.call @foo(%[[V9]]) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> // CHECK: %[[V10:.*]] = llvm.call @foo(%[[V9]]) : (i32) -> !llvm.struct<(i32, double, i32)>
// CHECK: %[[V11:.*]] = llvm.extractvalue %[[V10]][0] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V11:.*]] = llvm.extractvalue %[[V10]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V12:.*]] = llvm.extractvalue %[[V10]][1] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V12:.*]] = llvm.extractvalue %[[V10]][1] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V13:.*]] = llvm.extractvalue %[[V10]][2] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V13:.*]] = llvm.extractvalue %[[V10]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V14:.*]] = llvm.mlir.undef : !llvm.struct<(i32, double, i32)> // CHECK: %[[V14:.*]] = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V15:.*]] = llvm.insertvalue %[[V5]], %[[V14]][0] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V15:.*]] = llvm.insertvalue %[[V5]], %[[V14]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V16:.*]] = llvm.insertvalue %[[V7]], %[[V15]][1] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V16:.*]] = llvm.insertvalue %[[V7]], %[[V15]][1] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V17:.*]] = llvm.insertvalue %[[V11]], %[[V16]][2] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V17:.*]] = llvm.insertvalue %[[V11]], %[[V16]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: llvm.return %[[V17]] : !llvm.struct<(i32, double, i32)> // CHECK: llvm.return %[[V17]] : !llvm.struct<(i32, double, i32)>
^bb1(%9: !llvm.i32): ^bb1(%9: i32):
%10 = llvm.call @foo(%9) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> %10 = llvm.call @foo(%9) : (i32) -> !llvm.struct<(i32, double, i32)>
%11 = llvm.extractvalue %10[0] : !llvm.struct<(i32, double, i32)> %11 = llvm.extractvalue %10[0] : !llvm.struct<(i32, double, i32)>
%12 = llvm.extractvalue %10[1] : !llvm.struct<(i32, double, i32)> %12 = llvm.extractvalue %10[1] : !llvm.struct<(i32, double, i32)>
%13 = llvm.extractvalue %10[2] : !llvm.struct<(i32, double, i32)> %13 = llvm.extractvalue %10[2] : !llvm.struct<(i32, double, i32)>
%14 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)> %14 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
%15 = llvm.insertvalue %5, %14[0] : !llvm.struct<(i32, double, i32)> %15 = llvm.insertvalue %5, %14[0] : !llvm.struct<(i32, double, i32)>
%16 = llvm.insertvalue %7, %15[1] : !llvm.struct<(i32, double, i32)> %16 = llvm.insertvalue %7, %15[1] : !llvm.struct<(i32, double, i32)>
%17 = llvm.insertvalue %11, %16[2] : !llvm.struct<(i32, double, i32)> %17 = llvm.insertvalue %11, %16[2] : !llvm.struct<(i32, double, i32)>
llvm.return %17 : !llvm.struct<(i32, double, i32)> llvm.return %17 : !llvm.struct<(i32, double, i32)>
// CHECK:^[[BB2]](%[[V18:.*]]: !llvm.i32): // CHECK:^[[BB2]](%[[V18:.*]]: i32):
// CHECK: %[[V19:.*]] = llvm.mlir.undef : !llvm.struct<(i32, double, i32)> // CHECK: %[[V19:.*]] = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V20:.*]] = llvm.insertvalue %[[V18]], %[[V19]][0] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V20:.*]] = llvm.insertvalue %[[V18]], %[[V19]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V21:.*]] = llvm.insertvalue %[[V7]], %[[V20]][1] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V21:.*]] = llvm.insertvalue %[[V7]], %[[V20]][1] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V22:.*]] = llvm.insertvalue %[[V5]], %[[V21]][2] : !llvm.struct<(i32, double, i32)> // CHECK: %[[V22:.*]] = llvm.insertvalue %[[V5]], %[[V21]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: llvm.return %[[V22]] : !llvm.struct<(i32, double, i32)> // CHECK: llvm.return %[[V22]] : !llvm.struct<(i32, double, i32)>
^bb2(%18: !llvm.i32): ^bb2(%18: i32):
%19 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)> %19 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
%20 = llvm.insertvalue %18, %19[0] : !llvm.struct<(i32, double, i32)> %20 = llvm.insertvalue %18, %19[0] : !llvm.struct<(i32, double, i32)>
%21 = llvm.insertvalue %7, %20[1] : !llvm.struct<(i32, double, i32)> %21 = llvm.insertvalue %7, %20[1] : !llvm.struct<(i32, double, i32)>
%22 = llvm.insertvalue %5, %21[2] : !llvm.struct<(i32, double, i32)> %22 = llvm.insertvalue %5, %21[2] : !llvm.struct<(i32, double, i32)>
llvm.return %22 : !llvm.struct<(i32, double, i32)> llvm.return %22 : !llvm.struct<(i32, double, i32)>
} }
// CHECK-LABEL: @casts // CHECK-LABEL: @casts
// CHECK-SAME: (%[[I32:.*]]: !llvm.i32, %[[I64:.*]]: !llvm.i64, %[[V4I32:.*]]: !llvm.vec<4 x i32>, %[[V4I64:.*]]: !llvm.vec<4 x i64>, %[[I32PTR:.*]]: !llvm.ptr<i32>) // CHECK-SAME: (%[[I32:.*]]: i32, %[[I64:.*]]: i64, %[[V4I32:.*]]: !llvm.vec<4 x i32>, %[[V4I64:.*]]: !llvm.vec<4 x i64>, %[[I32PTR:.*]]: !llvm.ptr<i32>)
func @casts(%arg0: !llvm.i32, %arg1: !llvm.i64, %arg2: !llvm.vec<4 x i32>, func @casts(%arg0: i32, %arg1: i64, %arg2: !llvm.vec<4 x i32>,
%arg3: !llvm.vec<4 x i64>, %arg4: !llvm.ptr<i32>) { %arg3: !llvm.vec<4 x i64>, %arg4: !llvm.ptr<i32>) {
// CHECK: = llvm.sext %[[I32]] : !llvm.i32 to !llvm.i56 // CHECK: = llvm.sext %[[I32]] : i32 to i56
%0 = llvm.sext %arg0 : !llvm.i32 to !llvm.i56 %0 = llvm.sext %arg0 : i32 to i56
// CHECK: = llvm.zext %[[I32]] : !llvm.i32 to !llvm.i64 // CHECK: = llvm.zext %[[I32]] : i32 to i64
%1 = llvm.zext %arg0 : !llvm.i32 to !llvm.i64 %1 = llvm.zext %arg0 : i32 to i64
// CHECK: = llvm.trunc %[[I64]] : !llvm.i64 to !llvm.i56 // CHECK: = llvm.trunc %[[I64]] : i64 to i56
%2 = llvm.trunc %arg1 : !llvm.i64 to !llvm.i56 %2 = llvm.trunc %arg1 : i64 to i56
// CHECK: = llvm.sext %[[V4I32]] : !llvm.vec<4 x i32> to !llvm.vec<4 x i56> // CHECK: = llvm.sext %[[V4I32]] : !llvm.vec<4 x i32> to !llvm.vec<4 x i56>
%3 = llvm.sext %arg2 : !llvm.vec<4 x i32> to !llvm.vec<4 x i56> %3 = llvm.sext %arg2 : !llvm.vec<4 x i32> to !llvm.vec<4 x i56>
// CHECK: = llvm.zext %[[V4I32]] : !llvm.vec<4 x i32> to !llvm.vec<4 x i64> // CHECK: = llvm.zext %[[V4I32]] : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
%4 = llvm.zext %arg2 : !llvm.vec<4 x i32> to !llvm.vec<4 x i64> %4 = llvm.zext %arg2 : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
// CHECK: = llvm.trunc %[[V4I64]] : !llvm.vec<4 x i64> to !llvm.vec<4 x i56> // CHECK: = llvm.trunc %[[V4I64]] : !llvm.vec<4 x i64> to !llvm.vec<4 x i56>
%5 = llvm.trunc %arg3 : !llvm.vec<4 x i64> to !llvm.vec<4 x i56> %5 = llvm.trunc %arg3 : !llvm.vec<4 x i64> to !llvm.vec<4 x i56>
// CHECK: = llvm.sitofp %[[I32]] : !llvm.i32 to !llvm.float // CHECK: = llvm.sitofp %[[I32]] : i32 to !llvm.float
%6 = llvm.sitofp %arg0 : !llvm.i32 to !llvm.float %6 = llvm.sitofp %arg0 : i32 to !llvm.float
// CHECK: %[[FLOAT:.*]] = llvm.uitofp %[[I32]] : !llvm.i32 to !llvm.float // CHECK: %[[FLOAT:.*]] = llvm.uitofp %[[I32]] : i32 to !llvm.float
%7 = llvm.uitofp %arg0 : !llvm.i32 to !llvm.float %7 = llvm.uitofp %arg0 : i32 to !llvm.float
// CHECK: = llvm.fptosi %[[FLOAT]] : !llvm.float to !llvm.i32 // CHECK: = llvm.fptosi %[[FLOAT]] : !llvm.float to i32
%8 = llvm.fptosi %7 : !llvm.float to !llvm.i32 %8 = llvm.fptosi %7 : !llvm.float to i32
// CHECK: = llvm.fptoui %[[FLOAT]] : !llvm.float to !llvm.i32 // CHECK: = llvm.fptoui %[[FLOAT]] : !llvm.float to i32
%9 = llvm.fptoui %7 : !llvm.float to !llvm.i32 %9 = llvm.fptoui %7 : !llvm.float to i32
// CHECK: = llvm.addrspacecast %[[I32PTR]] : !llvm.ptr<i32> to !llvm.ptr<i32, 2> // CHECK: = llvm.addrspacecast %[[I32PTR]] : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
%10 = llvm.addrspacecast %arg4 : !llvm.ptr<i32> to !llvm.ptr<i32, 2> %10 = llvm.addrspacecast %arg4 : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
llvm.return llvm.return
} }
// CHECK-LABEL: @vect // CHECK-LABEL: @vect
func @vect(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i32, %arg2: !llvm.float) { func @vect(%arg0: !llvm.vec<4 x float>, %arg1: i32, %arg2: !llvm.float) {
// CHECK: = llvm.extractelement {{.*}} : !llvm.vec<4 x float> // CHECK: = llvm.extractelement {{.*}} : !llvm.vec<4 x float>
%0 = llvm.extractelement %arg0[%arg1 : !llvm.i32] : !llvm.vec<4 x float> %0 = llvm.extractelement %arg0[%arg1 : i32] : !llvm.vec<4 x float>
// CHECK: = llvm.insertelement {{.*}} : !llvm.vec<4 x float> // CHECK: = llvm.insertelement {{.*}} : !llvm.vec<4 x float>
%1 = llvm.insertelement %arg2, %arg0[%arg1 : !llvm.i32] : !llvm.vec<4 x float> %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : !llvm.vec<4 x float>
// CHECK: = llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float> // CHECK: = llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
%2 = llvm.shufflevector %arg0, %arg0 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float> %2 = llvm.shufflevector %arg0, %arg0 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
// CHECK: = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : !llvm.vec<4 x float> // CHECK: = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : !llvm.vec<4 x float>
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float> %3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float>
return return
} }
// CHECK-LABEL: @alloca // CHECK-LABEL: @alloca
func @alloca(%size : !llvm.i64) { func @alloca(%size : i64) {
// CHECK: llvm.alloca %{{.*}} x !llvm.i32 : (!llvm.i64) -> !llvm.ptr<i32> // CHECK: llvm.alloca %{{.*}} x i32 : (i64) -> !llvm.ptr<i32>
llvm.alloca %size x !llvm.i32 {alignment = 0} : (!llvm.i64) -> (!llvm.ptr<i32>) llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr<i32>)
// CHECK: llvm.alloca %{{.*}} x !llvm.i32 {alignment = 8 : i64} : (!llvm.i64) -> !llvm.ptr<i32> // CHECK: llvm.alloca %{{.*}} x i32 {alignment = 8 : i64} : (i64) -> !llvm.ptr<i32>
llvm.alloca %size x !llvm.i32 {alignment = 8} : (!llvm.i64) -> (!llvm.ptr<i32>) llvm.alloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr<i32>)
llvm.return llvm.return
} }
// CHECK-LABEL: @null // CHECK-LABEL: @null
func @null() { func @null() {
// CHECK: llvm.mlir.null : !llvm.ptr<i8> // CHECK: llvm.mlir.null : !llvm.ptr<i8>
%0 = llvm.mlir.null : !llvm.ptr<i8> %0 = llvm.mlir.null : !llvm.ptr<i8>
// CHECK: llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>> // CHECK: llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
%1 = llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>> %1 = llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
llvm.return llvm.return
} }
// CHECK-LABEL: @atomicrmw // CHECK-LABEL: @atomicrmw
func @atomicrmw(%ptr : !llvm.ptr<float>, %val : !llvm.float) { func @atomicrmw(%ptr : !llvm.ptr<float>, %val : !llvm.float) {
// CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} unordered : !llvm.float // CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} unordered : !llvm.float
%0 = llvm.atomicrmw fadd %ptr, %val unordered : !llvm.float %0 = llvm.atomicrmw fadd %ptr, %val unordered : !llvm.float
llvm.return llvm.return
} }
// CHECK-LABEL: @cmpxchg // CHECK-LABEL: @cmpxchg
func @cmpxchg(%ptr : !llvm.ptr<i32>, %cmp : !llvm.i32, %new : !llvm.i32) { func @cmpxchg(%ptr : !llvm.ptr<i32>, %cmp : i32, %new : i32) {
// CHECK: llvm.cmpxchg %{{.*}}, %{{.*}}, %{{.*}} acq_rel monotonic : !llvm.i32 // CHECK: llvm.cmpxchg %{{.*}}, %{{.*}}, %{{.*}} acq_rel monotonic : i32
%0 = llvm.cmpxchg %ptr, %cmp, %new acq_rel monotonic : !llvm.i32 %0 = llvm.cmpxchg %ptr, %cmp, %new acq_rel monotonic : i32
llvm.return llvm.return
} }
llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8> llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8>
llvm.func @bar(!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) llvm.func @bar(!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>)
llvm.func @__gxx_personality_v0(...) -> !llvm.i32 llvm.func @__gxx_personality_v0(...) -> i32
// CHECK-LABEL: @invokeLandingpad // CHECK-LABEL: @invokeLandingpad
llvm.func @invokeLandingpad() -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } { llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {
// CHECK: %[[a0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32 // CHECK: %[[a0:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %{{.*}} = llvm.mlir.constant(3 : i32) : !llvm.i32 // CHECK: %{{.*}} = llvm.mlir.constant(3 : i32) : i32
// CHECK: %[[a2:.*]] = llvm.mlir.constant("\01") : !llvm.array<1 x i8> // CHECK: %[[a2:.*]] = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
// CHECK: %[[a3:.*]] = llvm.mlir.null : !llvm.ptr<ptr<i8>> // CHECK: %[[a3:.*]] = llvm.mlir.null : !llvm.ptr<ptr<i8>>
// CHECK: %[[a4:.*]] = llvm.mlir.null : !llvm.ptr<i8> // CHECK: %[[a4:.*]] = llvm.mlir.null : !llvm.ptr<i8>
// CHECK: %[[a5:.*]] = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>> // CHECK: %[[a5:.*]] = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
// CHECK: %[[a6:.*]] = llvm.bitcast %[[a5]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8> // CHECK: %[[a6:.*]] = llvm.bitcast %[[a5]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
// CHECK: %[[a7:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32 // CHECK: %[[a7:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[a8:.*]] = llvm.alloca %[[a7]] x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8> // CHECK: %[[a8:.*]] = llvm.alloca %[[a7]] x i8 : (i32) -> !llvm.ptr<i8>
// CHECK: %{{.*}} = llvm.invoke @foo(%[[a7]]) to ^[[BB2:.*]] unwind ^[[BB1:.*]] : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> // CHECK: %{{.*}} = llvm.invoke @foo(%[[a7]]) to ^[[BB2:.*]] unwind ^[[BB1:.*]] : (i32) -> !llvm.struct<(i32, double, i32)>
%0 = llvm.mlir.constant(0 : i32) : !llvm.i32 %0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant(3 : i32) : i32
%2 = llvm.mlir.constant("\01") : !llvm.array<1 x i8> %2 = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
%3 = llvm.mlir.null : !llvm.ptr<ptr<i8>> %3 = llvm.mlir.null : !llvm.ptr<ptr<i8>>
%4 = llvm.mlir.null : !llvm.ptr<i8> %4 = llvm.mlir.null : !llvm.ptr<i8>
%5 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>> %5 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
%6 = llvm.bitcast %5 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8> %6 = llvm.bitcast %5 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
%7 = llvm.mlir.constant(1 : i32) : !llvm.i32 %7 = llvm.mlir.constant(1 : i32) : i32
%8 = llvm.alloca %7 x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8> %8 = llvm.alloca %7 x i8 : (i32) -> !llvm.ptr<i8>
%9 = llvm.invoke @foo(%7) to ^bb2 unwind ^bb1 : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> %9 = llvm.invoke @foo(%7) to ^bb2 unwind ^bb1 : (i32) -> !llvm.struct<(i32, double, i32)>
// CHECK: ^[[BB1]]: // CHECK: ^[[BB1]]:
// CHECK: %[[lp:.*]] = llvm.landingpad cleanup (catch %[[a3]] : !llvm.ptr<ptr<i8>>) (catch %[[a6]] : !llvm.ptr<i8>) (filter %[[a2]] : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)> // CHECK: %[[lp:.*]] = llvm.landingpad cleanup (catch %[[a3]] : !llvm.ptr<ptr<i8>>) (catch %[[a6]] : !llvm.ptr<i8>) (filter %[[a2]] : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
// CHECK: llvm.resume %[[lp]] : !llvm.struct<(ptr<i8>, i32)> // CHECK: llvm.resume %[[lp]] : !llvm.struct<(ptr<i8>, i32)>
^bb1: ^bb1:
%10 = llvm.landingpad cleanup (catch %3 : !llvm.ptr<ptr<i8>>) (catch %6 : !llvm.ptr<i8>) (filter %2 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)> %10 = llvm.landingpad cleanup (catch %3 : !llvm.ptr<ptr<i8>>) (catch %6 : !llvm.ptr<i8>) (filter %2 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
llvm.resume %10 : !llvm.struct<(ptr<i8>, i32)> llvm.resume %10 : !llvm.struct<(ptr<i8>, i32)>
// CHECK: ^[[BB2]]: // CHECK: ^[[BB2]]:
// CHECK: llvm.return %[[a7]] : !llvm.i32 // CHECK: llvm.return %[[a7]] : i32
^bb2: ^bb2:
llvm.return %7 : !llvm.i32 llvm.return %7 : i32
// CHECK: ^[[BB3:.*]]: // CHECK: ^[[BB3:.*]]:
// CHECK: llvm.invoke @bar(%[[a8]], %[[a6]], %[[a4]]) to ^[[BB2]] unwind ^[[BB1]] : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> () // CHECK: llvm.invoke @bar(%[[a8]], %[[a6]], %[[a4]]) to ^[[BB2]] unwind ^[[BB1]] : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
^bb3: ^bb3:
llvm.invoke @bar(%8, %6, %4) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> () llvm.invoke @bar(%8, %6, %4) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
// CHECK: ^[[BB4:.*]]: // CHECK: ^[[BB4:.*]]:
// CHECK: llvm.return %[[a0]] : !llvm.i32 // CHECK: llvm.return %[[a0]] : i32
^bb4: ^bb4:
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
// CHECK-LABEL: @useFreezeOp // CHECK-LABEL: @useFreezeOp
func @useFreezeOp(%arg0: !llvm.i32) { func @useFreezeOp(%arg0: i32) {
// CHECK: = llvm.freeze %[[ARG0:.*]] : !llvm.i32 // CHECK: = llvm.freeze %[[ARG0:.*]] : i32
%0 = llvm.freeze %arg0 : !llvm.i32 %0 = llvm.freeze %arg0 : i32
// CHECK: %[[x:.*]] = llvm.mlir.undef : !llvm.i8 // CHECK: %[[x:.*]] = llvm.mlir.undef : i8
%1 = llvm.mlir.undef : !llvm.i8 %1 = llvm.mlir.undef : i8
// CHECK: = llvm.freeze %[[x]] : !llvm.i8 // CHECK: = llvm.freeze %[[x]] : i8
%2 = llvm.freeze %1 : !llvm.i8 %2 = llvm.freeze %1 : i8
return return
} }
// CHECK-LABEL: @useFenceInst // CHECK-LABEL: @useFenceInst
func @useFenceInst() { func @useFenceInst() {
// CHECK: syncscope("agent") seq_cst // CHECK: syncscope("agent") seq_cst
llvm.fence syncscope("agent") seq_cst llvm.fence syncscope("agent") seq_cst
// CHECK: seq_cst // CHECK: seq_cst
llvm.fence syncscope("") seq_cst llvm.fence syncscope("") seq_cst
// CHECK: release // CHECK: release
llvm.fence release llvm.fence release
return return
} }
// CHECK-LABEL: @useInlineAsm // CHECK-LABEL: @useInlineAsm
llvm.func @useInlineAsm(%arg0: !llvm.i32) { llvm.func @useInlineAsm(%arg0: i32) {
// CHECK: llvm.inline_asm {{.*}} (!llvm.i32) -> !llvm.i8 // CHECK: llvm.inline_asm {{.*}} (i32) -> i8
%0 = llvm.inline_asm "bswap $0", "=r,r" %arg0 : (!llvm.i32) -> !llvm.i8 %0 = llvm.inline_asm "bswap $0", "=r,r" %arg0 : (i32) -> i8
// CHECK-NEXT: llvm.inline_asm {{.*}} (!llvm.i32, !llvm.i32) -> !llvm.i8 // CHECK-NEXT: llvm.inline_asm {{.*}} (i32, i32) -> i8
%1 = llvm.inline_asm "foo", "bar" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %1 = llvm.inline_asm "foo", "bar" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: llvm.inline_asm has_side_effects {{.*}} (!llvm.i32, !llvm.i32) -> !llvm.i8 // CHECK-NEXT: llvm.inline_asm has_side_effects {{.*}} (i32, i32) -> i8
%2 = llvm.inline_asm has_side_effects "foo", "bar" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %2 = llvm.inline_asm has_side_effects "foo", "bar" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: llvm.inline_asm is_align_stack {{.*}} (!llvm.i32, !llvm.i32) -> !llvm.i8 // CHECK-NEXT: llvm.inline_asm is_align_stack {{.*}} (i32, i32) -> i8
%3 = llvm.inline_asm is_align_stack "foo", "bar" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %3 = llvm.inline_asm is_align_stack "foo", "bar" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: llvm.inline_asm "foo", "=r,=r,r" {{.*}} : (!llvm.i32) -> !llvm.struct<(i8, i8)> // CHECK-NEXT: llvm.inline_asm "foo", "=r,=r,r" {{.*}} : (i32) -> !llvm.struct<(i8, i8)>
%5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (!llvm.i32) -> !llvm.struct<(i8, i8)> %5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>
llvm.return llvm.return
} }
// CHECK-LABEL: @fastmathFlags // CHECK-LABEL: @fastmathFlags
func @fastmathFlags(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.i32) { func @fastmathFlags(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: i32) {
// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%1 = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %1 = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%2 = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %2 = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%3 = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %3 = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%4 = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %4 = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%5 = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %5 = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float // CHECK: {{.*}} = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
%6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : !llvm.float
// CHECK: {{.*}} = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> // CHECK: {{.*}} = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, double, i32)>
%7 = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (!llvm.i32) -> !llvm.struct<(i32, double, i32)> %7 = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, double, i32)>
// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 : !llvm.float // CHECK: {{.*}} = llvm.fadd %arg0, %arg1 : !llvm.float
%8 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<>} : !llvm.float %8 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<>} : !llvm.float
// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : !llvm.float // CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : !llvm.float
%9 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : !llvm.float %9 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : !llvm.float
// CHECK: {{.*}} = llvm.fneg %arg0 : !llvm.float // CHECK: {{.*}} = llvm.fneg %arg0 : !llvm.float
%10 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<>} : !llvm.float %10 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<>} : !llvm.float
return return
} }

mlir/test/Dialect/LLVMIR/terminator.mlir

// RUN: mlir-opt -pass-pipeline='func(canonicalize)' %s | FileCheck %s // RUN: mlir-opt -pass-pipeline='func(canonicalize)' %s | FileCheck %s
// verify that terminators survive the canonicalizer // verify that terminators survive the canonicalizer
// CHECK-LABEL: @return // CHECK-LABEL: @return
// CHECK: llvm.return // CHECK: llvm.return
func @return() { func @return() {
llvm.return llvm.return
} }
// CHECK-LABEL: @control_flow // CHECK-LABEL: @control_flow
// CHECK: llvm.br // CHECK: llvm.br
// CHECK: llvm.cond_br // CHECK: llvm.cond_br
// CHECK: llvm.return // CHECK: llvm.return
func @control_flow(%cond : !llvm.i1) { func @control_flow(%cond : i1) {
llvm.br ^bb1 llvm.br ^bb1
^bb1: ^bb1:
llvm.cond_br %cond, ^bb2, ^bb1 llvm.cond_br %cond, ^bb2, ^bb1
^bb2: ^bb2:
llvm.return llvm.return
} }

mlir/test/Dialect/LLVMIR/types-invalid.mlir

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
func @struct_literal_opaque() { func @struct_literal_opaque() {
// expected-error @+1 {{only identified structs can be opaque}} // expected-error @+1 {{only identified structs can be opaque}}
"some.op"() : () -> !llvm.struct<opaque> "some.op"() : () -> !llvm.struct<opaque>
} }
// ----- // -----
func @unexpected_type() { func @unexpected_type() {
// expected-error @+1 {{unexpected type, expected i* or keyword}} // expected-error @+1 {{unexpected type, expected keyword}}
"some.op"() : () -> !llvm.f32 "some.op"() : () -> !llvm.f32
} }
// ----- // -----
func @unexpected_type() { func @unexpected_type() {
// expected-error @+1 {{unknown LLVM type}} // expected-error @+1 {{unknown LLVM type}}
"some.op"() : () -> !llvm.ifoo "some.op"() : () -> !llvm.ifoo
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
} }
// ----- // -----
func @scalable_void_vector() { func @scalable_void_vector() {
// expected-error @+1 {{invalid vector element type}} // expected-error @+1 {{invalid vector element type}}
"some.op"() : () -> !llvm.vec<? x 4 x void> "some.op"() : () -> !llvm.vec<? x 4 x void>
} }
// -----
// expected-warning @+1 {{deprecated syntax, drop '!llvm.' for integers}}
func private @deprecated_int() -> !llvm.i32
// -----
// expected-error @+1 {{unexpected type, expected keyword}}
func private @unexpected_type() -> !llvm.tensor<*xf32>

mlir/test/Dialect/LLVMIR/types.mlir

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linesfunc @func() {
"some.op"() : () -> !llvm.func<void (...)> "some.op"() : () -> !llvm.func<void (...)>
// CHECK: !llvm.func<void (i32, i32, ...)> // CHECK: !llvm.func<void (i32, i32, ...)>
"some.op"() : () -> !llvm.func<void (i32, i32, ...)> "some.op"() : () -> !llvm.func<void (i32, i32, ...)>
return return
} }
// CHECK-LABEL: @integer // CHECK-LABEL: @integer
func @integer() { func @integer() {
// CHECK: !llvm.i1 // CHECK: i1
"some.op"() : () -> !llvm.i1 "some.op"() : () -> i1
// CHECK: !llvm.i8 // CHECK: i8
"some.op"() : () -> !llvm.i8 "some.op"() : () -> i8
// CHECK: !llvm.i16 // CHECK: i16
"some.op"() : () -> !llvm.i16 "some.op"() : () -> i16
// CHECK: !llvm.i32 // CHECK: i32
"some.op"() : () -> !llvm.i32 "some.op"() : () -> i32
// CHECK: !llvm.i64 // CHECK: i64
"some.op"() : () -> !llvm.i64 "some.op"() : () -> i64
// CHECK: !llvm.i57 // CHECK: i57
"some.op"() : () -> !llvm.i57 "some.op"() : () -> i57
// CHECK: !llvm.i129 // CHECK: i129
"some.op"() : () -> !llvm.i129 "some.op"() : () -> i129
return return
} }
// CHECK-LABEL: @ptr // CHECK-LABEL: @ptr
func @ptr() { func @ptr() {
// CHECK: !llvm.ptr<i8> // CHECK: !llvm.ptr<i8>
"some.op"() : () -> !llvm.ptr<i8> "some.op"() : () -> !llvm.ptr<i8>
// CHECK: !llvm.ptr<float> // CHECK: !llvm.ptr<float>
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Linesfunc @identified_struct() {
"some.op"() : () -> !llvm.array<10 x struct<"array-of-structs", (i32)>> "some.op"() : () -> !llvm.array<10 x struct<"array-of-structs", (i32)>>
// CHECK: !llvm.ptr<struct<"ptr-to-struct", (i8)>> // CHECK: !llvm.ptr<struct<"ptr-to-struct", (i8)>>
"some.op"() : () -> !llvm.ptr<struct<"ptr-to-struct", (i8)>> "some.op"() : () -> !llvm.ptr<struct<"ptr-to-struct", (i8)>>
return return
} }
func @verbose() { func @verbose() {
// CHECK: !llvm.struct<(i64, struct<(float)>)> // CHECK: !llvm.struct<(i64, struct<(float)>)>
"some.op"() : () -> !llvm.struct<(!llvm.i64, !llvm.struct<(!llvm.float)>)> "some.op"() : () -> !llvm.struct<(i64, !llvm.struct<(!llvm.float)>)>
return return
} }
// ----- // -----
// Check that type aliases can be used inside LLVM dialect types. Note that // Check that type aliases can be used inside LLVM dialect types. Note that
// currently they are _not_ printed back as this would require // currently they are _not_ printed back as this would require
// DialectAsmPrinter to have a mechanism for querying the presence and // DialectAsmPrinter to have a mechanism for querying the presence and
// usability of an alias outside of its `printType` method. // usability of an alias outside of its `printType` method.
!baz = type !llvm.i64 !baz = type i64
!qux = type !llvm.struct<(!baz)> !qux = type !llvm.struct<(!baz)>
!rec = type !llvm.struct<"a", (ptr<struct<"a">>)> !rec = type !llvm.struct<"a", (ptr<struct<"a">>)>
// CHECK: aliases // CHECK: aliases
llvm.func @aliases() { llvm.func @aliases() {
// CHECK: !llvm.struct<(i32, float, struct<(i64)>)> // CHECK: !llvm.struct<(i32, float, struct<(i64)>)>
"some.op"() : () -> !llvm.struct<(i32, float, !qux)> "some.op"() : () -> !llvm.struct<(i32, float, !qux)>
// CHECK: !llvm.struct<"a", (ptr<struct<"a">>)> // CHECK: !llvm.struct<"a", (ptr<struct<"a">>)>
"some.op"() : () -> !rec "some.op"() : () -> !rec
llvm.return llvm.return
} }

mlir/test/Dialect/Linalg/llvm.mlir

// RUN: mlir-opt %s -convert-linalg-to-llvm | FileCheck %s // RUN: mlir-opt %s -convert-linalg-to-llvm | FileCheck %s
func @range(%arg0: index) { func @range(%arg0: index) {
%c0 = constant 0 : index %c0 = constant 0 : index
%c1 = constant 1 : index %c1 = constant 1 : index
%R = linalg.range %c0:%arg0:%c1 : !linalg.range %R = linalg.range %c0:%arg0:%c1 : !linalg.range
return return
} }
// CHECK-LABEL: func @range(%{{.*}}: !llvm.i64) { // CHECK-LABEL: func @range(%{{.*}}: i64) {
// CHECK: llvm.mlir.constant(0 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(0 : index) : i64
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK-NEXT: llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.mlir.undef : !llvm.struct<(i64, i64, i64)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(i64, i64, i64)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(i64, i64, i64)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(i64, i64, i64)>
func @slice(%arg0: memref<?xf32, offset: ?, strides: [1]>, %arg1: !linalg.range) { func @slice(%arg0: memref<?xf32, offset: ?, strides: [1]>, %arg1: !linalg.range) {
%1 = linalg.slice %arg0[%arg1] : memref<?xf32, offset: ?, strides: [1]>, !linalg.range, memref<?xf32, offset: ?, strides: [1]> %1 = linalg.slice %arg0[%arg1] : memref<?xf32, offset: ?, strides: [1]>, !linalg.range, memref<?xf32, offset: ?, strides: [1]>
return return
} }
// CHECK-LABEL: func @slice // CHECK-LABEL: func @slice
// insert data ptr for slice op // insert data ptr for slice op
// CHECK: llvm.extractvalue %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i64, i64, i64)>
// CHECK-NEXT: llvm.mul %{{.*}}, %{{.*}} : !llvm.i64 // CHECK-NEXT: llvm.mul %{{.*}}, %{{.*}} : i64
// CHECK-NEXT: llvm.add %{{.*}}, %{{.*}} : !llvm.i64 // CHECK-NEXT: llvm.add %{{.*}}, %{{.*}} : i64
// insert offset // insert offset
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.mlir.constant(0 : index) // CHECK-NEXT: llvm.mlir.constant(0 : index)
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i64, i64, i64)>
// CHECK-NEXT: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, i64, i64)>
// CHECK-NEXT: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(i64, i64, i64)> // CHECK-NEXT: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(i64, i64, i64)>
// get size[0] from parent view // get size[0] from parent view
// CHECK-NEXT: llvm.extractvalue %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.extractvalue %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK-NEXT: llvm.icmp "slt" %{{.*}}, %{{.*}} : i64
// CHECK-NEXT: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i64 // CHECK-NEXT: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : i1, i64
// compute size[0] bounded by parent view's size[0] // compute size[0] bounded by parent view's size[0]
// CHECK-NEXT: llvm.sub %{{.*}}, %{{.*}} : !llvm.i64 // CHECK-NEXT: llvm.sub %{{.*}}, %{{.*}} : i64
// bound below by 0 // bound below by 0
// CHECK-NEXT: llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.i64 // CHECK-NEXT: llvm.icmp "slt" %{{.*}}, %{{.*}} : i64
// CHECK-NEXT: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i64 // CHECK-NEXT: llvm.select %{{.*}}, %{{.*}}, %{{.*}} : i1, i64
// compute stride[0] using bounded size // compute stride[0] using bounded size
// CHECK-NEXT: llvm.mul %{{.*}}, %{{.*}} : !llvm.i64 // CHECK-NEXT: llvm.mul %{{.*}}, %{{.*}} : i64
// insert size and stride // insert size and stride
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)> // CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<1 x i64>, array<1 x i64>)>
func @slice_with_range_and_index(%arg0: memref<?x?xf64, offset: ?, strides: [?, 1]>) { func @slice_with_range_and_index(%arg0: memref<?x?xf64, offset: ?, strides: [?, 1]>) {
%c0 = constant 0 : index %c0 = constant 0 : index
%c1 = constant 1 : index %c1 = constant 1 : index
%R = linalg.range %c0:%c1:%c1 : !linalg.range %R = linalg.range %c0:%c1:%c1 : !linalg.range
Show All 26 Lines
// CHECK-LABEL: func @reshape_static_expand // CHECK-LABEL: func @reshape_static_expand
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(3 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 3] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 3] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(5 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(60 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(60 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(20 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(20 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(5 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(5 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 3] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 3] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 4] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
func @reshape_static_collapse(%arg0: memref<1x3x4x1x5xf32>) -> memref<3x4x5xf32> { func @reshape_static_collapse(%arg0: memref<1x3x4x1x5xf32>) -> memref<3x4x5xf32> {
%0 = linalg.reshape %arg0 [affine_map<(i, j, k, l, m) -> (i, j)>, %0 = linalg.reshape %arg0 [affine_map<(i, j, k, l, m) -> (i, j)>,
affine_map<(i, j, k, l, m) -> (k)>, affine_map<(i, j, k, l, m) -> (k)>,
affine_map<(i, j, k, l, m) -> (l, m)>] : affine_map<(i, j, k, l, m) -> (l, m)>] :
memref<1x3x4x1x5xf32> into memref<3x4x5xf32> memref<1x3x4x1x5xf32> into memref<3x4x5xf32>
return %0 : memref<3x4x5xf32> return %0 : memref<3x4x5xf32>
} }
// CHECK-LABEL: func @reshape_static_collapse // CHECK-LABEL: func @reshape_static_collapse
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)> // CHECK: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<5 x i64>, array<5 x i64>)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.mlir.constant(3 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(3 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(5 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.mlir.constant(20 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(20 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.mlir.constant(5 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(5 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<3 x i64>, array<3 x i64>)>
func @reshape_fold_zero_dim(%arg0 : memref<1x1xf32>) -> memref<f32> { func @reshape_fold_zero_dim(%arg0 : memref<1x1xf32>) -> memref<f32> {
%0 = linalg.reshape %arg0 [] : memref<1x1xf32> into memref<f32> %0 = linalg.reshape %arg0 [] : memref<1x1xf32> into memref<f32>
return %0 : memref<f32> return %0 : memref<f32>
} }
// CHECK-LABEL: func @reshape_fold_zero_dim // CHECK-LABEL: func @reshape_fold_zero_dim
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64)>
Show All 11 Lines
// CHECK-LABEL: func @reshape_expand_zero_dim // CHECK-LABEL: func @reshape_expand_zero_dim
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)> // CHECK: llvm.extractvalue %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64)>
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(1 : index) : !llvm.i64 // CHECK: llvm.mlir.constant(1 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)> // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<float>, ptr<float>, i64, array<2 x i64>, array<2 x i64>)>

mlir/test/Dialect/OpenMP/ops.mlir

Show All 23 Lines
func @omp_taskyield() -> () { func @omp_taskyield() -> () {
// CHECK: omp.taskyield // CHECK: omp.taskyield
omp.taskyield omp.taskyield
return return
} }
// CHECK-LABEL: func @omp_flush // CHECK-LABEL: func @omp_flush
// CHECK-SAME: ([[ARG0:%.*]]: !llvm.i32) { // CHECK-SAME: ([[ARG0:%.*]]: i32) {
func @omp_flush(%arg0 : !llvm.i32) -> () { func @omp_flush(%arg0 : i32) -> () {
// Test without data var // Test without data var
// CHECK: omp.flush // CHECK: omp.flush
omp.flush omp.flush
// Test with one data var // Test with one data var
// CHECK: omp.flush([[ARG0]] : !llvm.i32) // CHECK: omp.flush([[ARG0]] : i32)
omp.flush(%arg0 : !llvm.i32) omp.flush(%arg0 : i32)
// Test with two data var // Test with two data var
// CHECK: omp.flush([[ARG0]], [[ARG0]] : !llvm.i32, !llvm.i32) // CHECK: omp.flush([[ARG0]], [[ARG0]] : i32, i32)
omp.flush(%arg0, %arg0: !llvm.i32, !llvm.i32) omp.flush(%arg0, %arg0: i32, i32)
return return
} }
func @omp_terminator() -> () { func @omp_terminator() -> () {
// CHECK: omp.terminator // CHECK: omp.terminator
omp.terminator omp.terminator
} }
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/types.mlir

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
// ----- // -----
// expected-error @+1 {{cannot use 'index' to compose SPIR-V types}} // expected-error @+1 {{cannot use 'index' to compose SPIR-V types}}
func private @index_type(!spv.array<4xindex>) -> () func private @index_type(!spv.array<4xindex>) -> ()
// ----- // -----
// expected-error @+1 {{cannot use '!llvm.i32' to compose SPIR-V types}} // expected-error @+1 {{cannot use '!llvm.struct<()>' to compose SPIR-V types}}
func private @llvm_type(!spv.array<4x!llvm.i32>) -> () func private @llvm_type(!spv.array<4x!llvm.struct<()>>) -> ()
// ----- // -----
// expected-error @+1 {{ArrayStride must be greater than zero}} // expected-error @+1 {{ArrayStride must be greater than zero}}
func private @array_type_zero_stride(!spv.array<4xi32, stride=0>) -> () func private @array_type_zero_stride(!spv.array<4xi32, stride=0>) -> ()
// ----- // -----
▲ Show 20 Lines • Show All 440 Lines • Show Last 20 Lines

mlir/test/Target/arm-sve.mlir

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesllvm.func @arm_sve_ummla(%arg0: !llvm.vec<? x 16 x i8>,
// CHECK: call <vscale x 4 x i32> @llvm.aarch64.sve.ummla.nxv4i32(<vscale x 4 // CHECK: call <vscale x 4 x i32> @llvm.aarch64.sve.ummla.nxv4i32(<vscale x 4
%0 = "llvm_arm_sve.ummla"(%arg2, %arg0, %arg1) : %0 = "llvm_arm_sve.ummla"(%arg2, %arg0, %arg1) :
(!llvm.vec<? x 4 x i32>, !llvm.vec<? x 16 x i8>, !llvm.vec<? x 16 x i8>) (!llvm.vec<? x 4 x i32>, !llvm.vec<? x 16 x i8>, !llvm.vec<? x 16 x i8>)
-> !llvm.vec<? x 4 x i32> -> !llvm.vec<? x 4 x i32>
llvm.return %0 : !llvm.vec<? x 4 x i32> llvm.return %0 : !llvm.vec<? x 4 x i32>
} }
// CHECK-LABEL: define i64 @get_vector_scale() // CHECK-LABEL: define i64 @get_vector_scale()
llvm.func @get_vector_scale() -> !llvm.i64 { llvm.func @get_vector_scale() -> i64 {
// CHECK: call i64 @llvm.vscale.i64() // CHECK: call i64 @llvm.vscale.i64()
%0 = "llvm_arm_sve.vscale"() : () -> !llvm.i64 %0 = "llvm_arm_sve.vscale"() : () -> i64
llvm.return %0 : !llvm.i64 llvm.return %0 : i64
} }

mlir/test/Target/avx512.mlir

// RUN: mlir-opt -verify-diagnostics %s | mlir-opt | mlir-translate --avx512-mlir-to-llvmir | FileCheck %s // RUN: mlir-opt -verify-diagnostics %s | mlir-opt | mlir-translate --avx512-mlir-to-llvmir | FileCheck %s
// CHECK-LABEL: define <16 x float> @LLVM_x86_avx512_mask_ps_512 // CHECK-LABEL: define <16 x float> @LLVM_x86_avx512_mask_ps_512
llvm.func @LLVM_x86_avx512_mask_ps_512(%a: !llvm.vec<16 x float>, llvm.func @LLVM_x86_avx512_mask_ps_512(%a: !llvm.vec<16 x float>,
%b: !llvm.i32, %b: i32,
%c: !llvm.i16) %c: i16)
-> (!llvm.vec<16 x float>) -> (!llvm.vec<16 x float>)
{ {
// CHECK: call <16 x float> @llvm.x86.avx512.mask.rndscale.ps.512(<16 x float> // CHECK: call <16 x float> @llvm.x86.avx512.mask.rndscale.ps.512(<16 x float>
%0 = "llvm_avx512.mask.rndscale.ps.512"(%a, %b, %a, %c, %b) : %0 = "llvm_avx512.mask.rndscale.ps.512"(%a, %b, %a, %c, %b) :
(!llvm.vec<16 x float>, !llvm.i32, !llvm.vec<16 x float>, !llvm.i16, !llvm.i32) -> !llvm.vec<16 x float> (!llvm.vec<16 x float>, i32, !llvm.vec<16 x float>, i16, i32) -> !llvm.vec<16 x float>
// CHECK: call <16 x float> @llvm.x86.avx512.mask.scalef.ps.512(<16 x float> // CHECK: call <16 x float> @llvm.x86.avx512.mask.scalef.ps.512(<16 x float>
%1 = "llvm_avx512.mask.scalef.ps.512"(%a, %a, %a, %c, %b) : %1 = "llvm_avx512.mask.scalef.ps.512"(%a, %a, %a, %c, %b) :
(!llvm.vec<16 x float>, !llvm.vec<16 x float>, !llvm.vec<16 x float>, !llvm.i16, !llvm.i32) -> !llvm.vec<16 x float> (!llvm.vec<16 x float>, !llvm.vec<16 x float>, !llvm.vec<16 x float>, i16, i32) -> !llvm.vec<16 x float>
llvm.return %1: !llvm.vec<16 x float> llvm.return %1: !llvm.vec<16 x float>
} }
// CHECK-LABEL: define <8 x double> @LLVM_x86_avx512_mask_pd_512 // CHECK-LABEL: define <8 x double> @LLVM_x86_avx512_mask_pd_512
llvm.func @LLVM_x86_avx512_mask_pd_512(%a: !llvm.vec<8 x double>, llvm.func @LLVM_x86_avx512_mask_pd_512(%a: !llvm.vec<8 x double>,
%b: !llvm.i32, %b: i32,
%c: !llvm.i8) %c: i8)
-> (!llvm.vec<8 x double>) -> (!llvm.vec<8 x double>)
{ {
// CHECK: call <8 x double> @llvm.x86.avx512.mask.rndscale.pd.512(<8 x double> // CHECK: call <8 x double> @llvm.x86.avx512.mask.rndscale.pd.512(<8 x double>
%0 = "llvm_avx512.mask.rndscale.pd.512"(%a, %b, %a, %c, %b) : %0 = "llvm_avx512.mask.rndscale.pd.512"(%a, %b, %a, %c, %b) :
(!llvm.vec<8 x double>, !llvm.i32, !llvm.vec<8 x double>, !llvm.i8, !llvm.i32) -> !llvm.vec<8 x double> (!llvm.vec<8 x double>, i32, !llvm.vec<8 x double>, i8, i32) -> !llvm.vec<8 x double>
// CHECK: call <8 x double> @llvm.x86.avx512.mask.scalef.pd.512(<8 x double> // CHECK: call <8 x double> @llvm.x86.avx512.mask.scalef.pd.512(<8 x double>
%1 = "llvm_avx512.mask.scalef.pd.512"(%a, %a, %a, %c, %b) : %1 = "llvm_avx512.mask.scalef.pd.512"(%a, %a, %a, %c, %b) :
(!llvm.vec<8 x double>, !llvm.vec<8 x double>, !llvm.vec<8 x double>, !llvm.i8, !llvm.i32) -> !llvm.vec<8 x double> (!llvm.vec<8 x double>, !llvm.vec<8 x double>, !llvm.vec<8 x double>, i8, i32) -> !llvm.vec<8 x double>
llvm.return %1: !llvm.vec<8 x double> llvm.return %1: !llvm.vec<8 x double>
} }

mlir/test/Target/import.ll

Show All 10 Lines
@g3 = internal global [6 x i8] c"string" @g3 = internal global [6 x i8] c"string"
; CHECK: llvm.mlir.global external @g5() : !llvm.vec<8 x i32> ; CHECK: llvm.mlir.global external @g5() : !llvm.vec<8 x i32>
@g5 = external global <8 x i32> @g5 = external global <8 x i32>
@g4 = external global i32, align 8 @g4 = external global i32, align 8
; CHECK: llvm.mlir.global internal constant @int_gep() : !llvm.ptr<i32> { ; CHECK: llvm.mlir.global internal constant @int_gep() : !llvm.ptr<i32> {
; CHECK-DAG: %[[addr:[0-9]+]] = llvm.mlir.addressof @g4 : !llvm.ptr<i32> ; CHECK-DAG: %[[addr:[0-9]+]] = llvm.mlir.addressof @g4 : !llvm.ptr<i32>
; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : !llvm.i32 ; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
; CHECK-NEXT: %[[gepinit:[0-9]+]] = llvm.getelementptr %[[addr]][%[[c2]]] : (!llvm.ptr<i32>, !llvm.i32) -> !llvm.ptr<i32> ; CHECK-NEXT: %[[gepinit:[0-9]+]] = llvm.getelementptr %[[addr]][%[[c2]]] : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
; CHECK-NEXT: llvm.return %[[gepinit]] : !llvm.ptr<i32> ; CHECK-NEXT: llvm.return %[[gepinit]] : !llvm.ptr<i32>
; CHECK-NEXT: } ; CHECK-NEXT: }
@int_gep = internal constant i32* getelementptr (i32, i32* @g4, i32 2) @int_gep = internal constant i32* getelementptr (i32, i32* @g4, i32 2)
; ;
; Linkage attribute. ; Linkage attribute.
; ;
; CHECK: llvm.mlir.global private @private(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global private @private(42 : i32) : i32
@private = private global i32 42 @private = private global i32 42
; CHECK: llvm.mlir.global internal @internal(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global internal @internal(42 : i32) : i32
@internal = internal global i32 42 @internal = internal global i32 42
; CHECK: llvm.mlir.global available_externally @available_externally(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global available_externally @available_externally(42 : i32) : i32
@available_externally = available_externally global i32 42 @available_externally = available_externally global i32 42
; CHECK: llvm.mlir.global linkonce @linkonce(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global linkonce @linkonce(42 : i32) : i32
@linkonce = linkonce global i32 42 @linkonce = linkonce global i32 42
; CHECK: llvm.mlir.global weak @weak(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global weak @weak(42 : i32) : i32
@weak = weak global i32 42 @weak = weak global i32 42
; CHECK: llvm.mlir.global common @common(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global common @common(42 : i32) : i32
@common = common global i32 42 @common = common global i32 42
; CHECK: llvm.mlir.global appending @appending(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global appending @appending(42 : i32) : i32
@appending = appending global i32 42 @appending = appending global i32 42
; CHECK: llvm.mlir.global extern_weak @extern_weak() : !llvm.i32 ; CHECK: llvm.mlir.global extern_weak @extern_weak() : i32
@extern_weak = extern_weak global i32 @extern_weak = extern_weak global i32
; CHECK: llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : i32
@linkonce_odr = linkonce_odr global i32 42 @linkonce_odr = linkonce_odr global i32 42
; CHECK: llvm.mlir.global weak_odr @weak_odr(42 : i32) : !llvm.i32 ; CHECK: llvm.mlir.global weak_odr @weak_odr(42 : i32) : i32
@weak_odr = weak_odr global i32 42 @weak_odr = weak_odr global i32 42
; CHECK: llvm.mlir.global external @external() : !llvm.i32 ; CHECK: llvm.mlir.global external @external() : i32
@external = external global i32 @external = external global i32
; ;
; Sequential constants. ; Sequential constants.
; ;
; CHECK: llvm.mlir.global internal constant @vector_constant(dense<[1, 2]> : vector<2xi32>) : !llvm.vec<2 x i32> ; CHECK: llvm.mlir.global internal constant @vector_constant(dense<[1, 2]> : vector<2xi32>) : !llvm.vec<2 x i32>
@vector_constant = internal constant <2 x i32> <i32 1, i32 2> @vector_constant = internal constant <2 x i32> <i32 1, i32 2>
Show All 10 Lines
; Linkage on functions. ; Linkage on functions.
; ;
; CHECK: llvm.func internal @func_internal ; CHECK: llvm.func internal @func_internal
define internal void @func_internal() { define internal void @func_internal() {
ret void ret void
} }
; CHECK: llvm.func @fe(!llvm.i32) -> !llvm.float ; CHECK: llvm.func @fe(i32) -> !llvm.float
declare float @fe(i32) declare float @fe(i32)
; FIXME: function attributes. ; FIXME: function attributes.
; CHECK-LABEL: llvm.func internal @f1(%arg0: !llvm.i64) -> !llvm.i32 { ; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 {
; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : !llvm.i32 ; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
; CHECK-DAG: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : !llvm.i32 ; CHECK-DAG: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32
; CHECK-DAG: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : !llvm.i1 ; CHECK-DAG: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : i1
; CHECK-DAG: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : !llvm.i32 ; CHECK-DAG: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : i32
define internal dso_local i32 @f1(i64 %a) norecurse { define internal dso_local i32 @f1(i64 %a) norecurse {
entry: entry:
; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : !llvm.i64 to !llvm.ptr<i64> ; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
%aa = inttoptr i64 %a to i64* %aa = inttoptr i64 %a to i64*
; %[[addrof:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<double> ; %[[addrof:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<double>
; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<double> ; %[[addrof2:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<double>
; %{{[0-9]+}} = llvm.inttoptr %arg0 : !llvm.i64 to !llvm.ptr<i64> ; %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm.ptr<double> to !llvm.i64 ; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm.ptr<double> to i64
; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm.ptr<double>, !llvm.i32) -> !llvm.ptr<double> ; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm.ptr<double>, i32) -> !llvm.ptr<double>
%bb = ptrtoint double* @g2 to i64 %bb = ptrtoint double* @g2 to i64
%cc = getelementptr double, double* @g2, i32 2 %cc = getelementptr double, double* @g2, i32 2
; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : !llvm.i64 to !llvm.i32 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : i64 to i32
%b = trunc i64 %a to i32 %b = trunc i64 %a to i32
; CHECK: %[[c:[0-9]+]] = llvm.call @fe(%[[b]]) : (!llvm.i32) -> !llvm.float ; CHECK: %[[c:[0-9]+]] = llvm.call @fe(%[[b]]) : (i32) -> !llvm.float
%c = call float @fe(i32 %b) %c = call float @fe(i32 %b)
; CHECK: %[[d:[0-9]+]] = llvm.fptosi %[[c]] : !llvm.float to !llvm.i32 ; CHECK: %[[d:[0-9]+]] = llvm.fptosi %[[c]] : !llvm.float to i32
%d = fptosi float %c to i32 %d = fptosi float %c to i32
; FIXME: icmp should return i1. ; FIXME: icmp should return i1.
; CHECK: %[[e:[0-9]+]] = llvm.icmp "ne" %[[d]], %[[c2]] : !llvm.i32 ; CHECK: %[[e:[0-9]+]] = llvm.icmp "ne" %[[d]], %[[c2]] : i32
%e = icmp ne i32 %d, 2 %e = icmp ne i32 %d, 2
; CHECK: llvm.cond_br %[[e]], ^bb1, ^bb2 ; CHECK: llvm.cond_br %[[e]], ^bb1, ^bb2
br i1 %e, label %if.then, label %if.end br i1 %e, label %if.then, label %if.end
; CHECK: ^bb1: ; CHECK: ^bb1:
if.then: if.then:
; CHECK: llvm.return %[[c42]] : !llvm.i32 ; CHECK: llvm.return %[[c42]] : i32
ret i32 42 ret i32 42
; CHECK: ^bb2: ; CHECK: ^bb2:
if.end: if.end:
; CHECK: %[[orcond:[0-9]+]] = llvm.or %[[e]], %[[c1]] : !llvm.i1 ; CHECK: %[[orcond:[0-9]+]] = llvm.or %[[e]], %[[c1]] : i1
%or.cond = or i1 %e, 1 %or.cond = or i1 %e, 1
; CHECK: llvm.return %[[c43]] ; CHECK: llvm.return %[[c43]]
ret i32 43 ret i32 43
} }
; Test that instructions that dominate can be out of sequential order. ; Test that instructions that dominate can be out of sequential order.
; CHECK-LABEL: llvm.func @f2(%arg0: !llvm.i64) -> !llvm.i64 { ; CHECK-LABEL: llvm.func @f2(%arg0: i64) -> i64 {
; CHECK-DAG: %[[c3:[0-9]+]] = llvm.mlir.constant(3 : i64) : !llvm.i64 ; CHECK-DAG: %[[c3:[0-9]+]] = llvm.mlir.constant(3 : i64) : i64
define i64 @f2(i64 %a) noduplicate { define i64 @f2(i64 %a) noduplicate {
entry: entry:
; CHECK: llvm.br ^bb2 ; CHECK: llvm.br ^bb2
br label %next br label %next
; CHECK: ^bb1: ; CHECK: ^bb1:
end: end:
; CHECK: llvm.return %1 ; CHECK: llvm.return %1
ret i64 %b ret i64 %b
; CHECK: ^bb2: ; CHECK: ^bb2:
next: next:
; CHECK: %1 = llvm.add %arg0, %[[c3]] : !llvm.i64 ; CHECK: %1 = llvm.add %arg0, %[[c3]] : i64
%b = add i64 %a, 3 %b = add i64 %a, 3
; CHECK: llvm.br ^bb1 ; CHECK: llvm.br ^bb1
br label %end br label %end
} }
; Test arguments/phis. ; Test arguments/phis.
; CHECK-LABEL: llvm.func @f2_phis(%arg0: !llvm.i64) -> !llvm.i64 { ; CHECK-LABEL: llvm.func @f2_phis(%arg0: i64) -> i64 {
; CHECK-DAG: %[[c3:[0-9]+]] = llvm.mlir.constant(3 : i64) : !llvm.i64 ; CHECK-DAG: %[[c3:[0-9]+]] = llvm.mlir.constant(3 : i64) : i64
define i64 @f2_phis(i64 %a) noduplicate { define i64 @f2_phis(i64 %a) noduplicate {
entry: entry:
; CHECK: llvm.br ^bb2 ; CHECK: llvm.br ^bb2
br label %next br label %next
; CHECK: ^bb1(%1: !llvm.i64): ; CHECK: ^bb1(%1: i64):
end: end:
%c = phi i64 [ %b, %next ] %c = phi i64 [ %b, %next ]
; CHECK: llvm.return %1 ; CHECK: llvm.return %1
ret i64 %c ret i64 %c
; CHECK: ^bb2: ; CHECK: ^bb2:
next: next:
; CHECK: %2 = llvm.add %arg0, %[[c3]] : !llvm.i64 ; CHECK: %2 = llvm.add %arg0, %[[c3]] : i64
%b = add i64 %a, 3 %b = add i64 %a, 3
; CHECK: llvm.br ^bb1 ; CHECK: llvm.br ^bb1
br label %end br label %end
} }
; CHECK-LABEL: llvm.func @f3() -> !llvm.ptr<i32> ; CHECK-LABEL: llvm.func @f3() -> !llvm.ptr<i32>
define i32* @f3() { define i32* @f3() {
; CHECK: %[[c:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<double> ; CHECK: %[[c:[0-9]+]] = llvm.mlir.addressof @g2 : !llvm.ptr<double>
Show All 28 Lines; CHECK: = llvm.icmp "ule"
%7 = icmp ule i32 %d, 2 %7 = icmp ule i32 %d, 2
; CHECK: = llvm.icmp "ugt" ; CHECK: = llvm.icmp "ugt"
%8 = icmp ugt i32 %d, 2 %8 = icmp ugt i32 %d, 2
ret void ret void
} }
; CHECK-LABEL: llvm.func @f6(%arg0: !llvm.ptr<func<void (i16)>>) ; CHECK-LABEL: llvm.func @f6(%arg0: !llvm.ptr<func<void (i16)>>)
define void @f6(void (i16) *%fn) { define void @f6(void (i16) *%fn) {
; CHECK: %[[c:[0-9]+]] = llvm.mlir.constant(0 : i16) : !llvm.i16 ; CHECK: %[[c:[0-9]+]] = llvm.mlir.constant(0 : i16) : i16
; CHECK: llvm.call %arg0(%[[c]]) ; CHECK: llvm.call %arg0(%[[c]])
call void %fn(i16 0) call void %fn(i16 0)
ret void ret void
} }
; CHECK-LABEL: llvm.func @FPArithmetic(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.double, %arg3: !llvm.double) ; CHECK-LABEL: llvm.func @FPArithmetic(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.double, %arg3: !llvm.double)
define void @FPArithmetic(float %a, float %b, double %c, double %d) { define void @FPArithmetic(float %a, float %b, double %c, double %d) {
; CHECK: %[[a1:[0-9]+]] = llvm.mlir.constant(3.030000e+01 : f64) : !llvm.double ; CHECK: %[[a1:[0-9]+]] = llvm.mlir.constant(3.030000e+01 : f64) : !llvm.double
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
@_ZTIii= external dso_local constant i8** @_ZTIii= external dso_local constant i8**
declare void @foo(i8*) declare void @foo(i8*)
declare i8* @bar(i8*) declare i8* @bar(i8*)
declare i32 @__gxx_personality_v0(...) declare i32 @__gxx_personality_v0(...)
; CHECK-LABEL: @invokeLandingpad ; CHECK-LABEL: @invokeLandingpad
define i32 @invokeLandingpad() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define i32 @invokeLandingpad() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
; CHECK: %[[a1:[0-9]+]] = llvm.bitcast %{{[0-9]+}} : !llvm.ptr<ptr<ptr<i8>>> to !llvm.ptr<i8> ; CHECK: %[[a1:[0-9]+]] = llvm.bitcast %{{[0-9]+}} : !llvm.ptr<ptr<ptr<i8>>> to !llvm.ptr<i8>
; CHECK: %[[a3:[0-9]+]] = llvm.alloca %{{[0-9]+}} x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8> ; CHECK: %[[a3:[0-9]+]] = llvm.alloca %{{[0-9]+}} x i8 : (i32) -> !llvm.ptr<i8>
%1 = alloca i8 %1 = alloca i8
; CHECK: llvm.invoke @foo(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> () ; CHECK: llvm.invoke @foo(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> ()
invoke void @foo(i8* %1) to label %4 unwind label %2 invoke void @foo(i8* %1) to label %4 unwind label %2
; CHECK: ^bb1: ; CHECK: ^bb1:
; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm.ptr<ptr<i8>>) (catch %[[a1]] : !llvm.ptr<i8>) (filter %{{[0-9]+}} : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)> ; CHECK: %{{[0-9]+}} = llvm.landingpad (catch %{{[0-9]+}} : !llvm.ptr<ptr<i8>>) (catch %[[a1]] : !llvm.ptr<i8>) (filter %{{[0-9]+}} : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
%3 = landingpad { i8*, i32 } catch i8** @_ZTIi catch i8* bitcast (i8*** @_ZTIii to i8*) %3 = landingpad { i8*, i32 } catch i8** @_ZTIi catch i8* bitcast (i8*** @_ZTIii to i8*)
; FIXME: Change filter to a constant array once they are handled. ; FIXME: Change filter to a constant array once they are handled.
; Currently, even though it parses this, LLVM module is broken ; Currently, even though it parses this, LLVM module is broken
filter [1 x i8] [i8 1] filter [1 x i8] [i8 1]
resume { i8*, i32 } %3 resume { i8*, i32 } %3
; CHECK: ^bb2: ; CHECK: ^bb2:
; CHECK: llvm.return %{{[0-9]+}} : !llvm.i32 ; CHECK: llvm.return %{{[0-9]+}} : i32
ret i32 1 ret i32 1
; CHECK: ^bb3: ; CHECK: ^bb3:
; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8> ; CHECK: %{{[0-9]+}} = llvm.invoke @bar(%[[a3]]) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
%6 = invoke i8* @bar(i8* %1) to label %4 unwind label %2 %6 = invoke i8* @bar(i8* %1) to label %4 unwind label %2
; CHECK: ^bb4: ; CHECK: ^bb4:
; CHECK: llvm.return %{{[0-9]+}} : !llvm.i32 ; CHECK: llvm.return %{{[0-9]+}} : i32
ret i32 0 ret i32 0
} }
;CHECK-LABEL: @useFreezeOp ;CHECK-LABEL: @useFreezeOp
define i32 @useFreezeOp(i32 %x) { define i32 @useFreezeOp(i32 %x) {
;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9a-z]+}} : !llvm.i32 ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9a-z]+}} : i32
%1 = freeze i32 %x %1 = freeze i32 %x
%2 = add i8 10, 10 %2 = add i8 10, 10
;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9]+}} : !llvm.i8 ;CHECK: %{{[0-9]+}} = llvm.freeze %{{[0-9]+}} : i8
%3 = freeze i8 %2 %3 = freeze i8 %2
%poison = add nsw i1 0, undef %poison = add nsw i1 0, undef
ret i32 0 ret i32 0
} }
;CHECK-LABEL: @useFenceInst ;CHECK-LABEL: @useFenceInst
define i32 @useFenceInst() { define i32 @useFenceInst() {
;CHECK: llvm.fence syncscope("agent") seq_cst ;CHECK: llvm.fence syncscope("agent") seq_cst
fence syncscope("agent") seq_cst fence syncscope("agent") seq_cst
;CHECK: llvm.fence release ;CHECK: llvm.fence release
fence release fence release
;CHECK: llvm.fence seq_cst ;CHECK: llvm.fence seq_cst
fence syncscope("") seq_cst fence syncscope("") seq_cst
ret i32 0 ret i32 0
} }

mlir/test/Target/llvmir-intrinsics.mlir

// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
// CHECK-LABEL: @intrinsics // CHECK-LABEL: @intrinsics
llvm.func @intrinsics(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.ptr<i8>) { llvm.func @intrinsics(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.ptr<i8>) {
%c3 = llvm.mlir.constant(3 : i32) : !llvm.i32 %c3 = llvm.mlir.constant(3 : i32) : i32
%c1 = llvm.mlir.constant(1 : i32) : !llvm.i32 %c1 = llvm.mlir.constant(1 : i32) : i32
%c0 = llvm.mlir.constant(0 : i32) : !llvm.i32 %c0 = llvm.mlir.constant(0 : i32) : i32
// CHECK: call float @llvm.fmuladd.f32 // CHECK: call float @llvm.fmuladd.f32
"llvm.intr.fmuladd"(%arg0, %arg1, %arg0) : (!llvm.float, !llvm.float, !llvm.float) -> !llvm.float "llvm.intr.fmuladd"(%arg0, %arg1, %arg0) : (!llvm.float, !llvm.float, !llvm.float) -> !llvm.float
// CHECK: call <8 x float> @llvm.fmuladd.v8f32 // CHECK: call <8 x float> @llvm.fmuladd.v8f32
"llvm.intr.fmuladd"(%arg2, %arg2, %arg2) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float> "llvm.intr.fmuladd"(%arg2, %arg2, %arg2) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float>
// CHECK: call float @llvm.fma.f32 // CHECK: call float @llvm.fma.f32
"llvm.intr.fma"(%arg0, %arg1, %arg0) : (!llvm.float, !llvm.float, !llvm.float) -> !llvm.float "llvm.intr.fma"(%arg0, %arg1, %arg0) : (!llvm.float, !llvm.float, !llvm.float) -> !llvm.float
// CHECK: call <8 x float> @llvm.fma.v8f32 // CHECK: call <8 x float> @llvm.fma.v8f32
"llvm.intr.fma"(%arg2, %arg2, %arg2) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float> "llvm.intr.fma"(%arg2, %arg2, %arg2) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float>
// CHECK: call void @llvm.prefetch.p0i8(i8* %3, i32 0, i32 3, i32 1) // CHECK: call void @llvm.prefetch.p0i8(i8* %3, i32 0, i32 3, i32 1)
"llvm.intr.prefetch"(%arg3, %c0, %c3, %c1) : (!llvm.ptr<i8>, !llvm.i32, !llvm.i32, !llvm.i32) -> () "llvm.intr.prefetch"(%arg3, %c0, %c3, %c1) : (!llvm.ptr<i8>, i32, i32, i32) -> ()
llvm.return llvm.return
} }
// CHECK-LABEL: @exp_test // CHECK-LABEL: @exp_test
llvm.func @exp_test(%arg0: !llvm.float, %arg1: !llvm.vec<8 x float>) { llvm.func @exp_test(%arg0: !llvm.float, %arg1: !llvm.vec<8 x float>) {
// CHECK: call float @llvm.exp.f32 // CHECK: call float @llvm.exp.f32
"llvm.intr.exp"(%arg0) : (!llvm.float) -> !llvm.float "llvm.intr.exp"(%arg0) : (!llvm.float) -> !llvm.float
// CHECK: call <8 x float> @llvm.exp.v8f32 // CHECK: call <8 x float> @llvm.exp.v8f32
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linesllvm.func @pow_test(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.vec<8 x float>) {
// CHECK: call float @llvm.pow.f32 // CHECK: call float @llvm.pow.f32
"llvm.intr.pow"(%arg0, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float "llvm.intr.pow"(%arg0, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float
// CHECK: call <8 x float> @llvm.pow.v8f32 // CHECK: call <8 x float> @llvm.pow.v8f32
"llvm.intr.pow"(%arg2, %arg3) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float> "llvm.intr.pow"(%arg2, %arg3) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float>
llvm.return llvm.return
} }
// CHECK-LABEL: @bitreverse_test // CHECK-LABEL: @bitreverse_test
llvm.func @bitreverse_test(%arg0: !llvm.i32, %arg1: !llvm.vec<8 x i32>) { llvm.func @bitreverse_test(%arg0: i32, %arg1: !llvm.vec<8 x i32>) {
// CHECK: call i32 @llvm.bitreverse.i32 // CHECK: call i32 @llvm.bitreverse.i32
"llvm.intr.bitreverse"(%arg0) : (!llvm.i32) -> !llvm.i32 "llvm.intr.bitreverse"(%arg0) : (i32) -> i32
// CHECK: call <8 x i32> @llvm.bitreverse.v8i32 // CHECK: call <8 x i32> @llvm.bitreverse.v8i32
"llvm.intr.bitreverse"(%arg1) : (!llvm.vec<8 x i32>) -> !llvm.vec<8 x i32> "llvm.intr.bitreverse"(%arg1) : (!llvm.vec<8 x i32>) -> !llvm.vec<8 x i32>
llvm.return llvm.return
} }
// CHECK-LABEL: @ctpop_test // CHECK-LABEL: @ctpop_test
llvm.func @ctpop_test(%arg0: !llvm.i32, %arg1: !llvm.vec<8 x i32>) { llvm.func @ctpop_test(%arg0: i32, %arg1: !llvm.vec<8 x i32>) {
// CHECK: call i32 @llvm.ctpop.i32 // CHECK: call i32 @llvm.ctpop.i32
"llvm.intr.ctpop"(%arg0) : (!llvm.i32) -> !llvm.i32 "llvm.intr.ctpop"(%arg0) : (i32) -> i32
// CHECK: call <8 x i32> @llvm.ctpop.v8i32 // CHECK: call <8 x i32> @llvm.ctpop.v8i32
"llvm.intr.ctpop"(%arg1) : (!llvm.vec<8 x i32>) -> !llvm.vec<8 x i32> "llvm.intr.ctpop"(%arg1) : (!llvm.vec<8 x i32>) -> !llvm.vec<8 x i32>
llvm.return llvm.return
} }
// CHECK-LABEL: @maxnum_test // CHECK-LABEL: @maxnum_test
llvm.func @maxnum_test(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.vec<8 x float>) { llvm.func @maxnum_test(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.vec<8 x float>) {
// CHECK: call float @llvm.maxnum.f32 // CHECK: call float @llvm.maxnum.f32
"llvm.intr.maxnum"(%arg0, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float "llvm.intr.maxnum"(%arg0, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float
// CHECK: call <8 x float> @llvm.maxnum.v8f32 // CHECK: call <8 x float> @llvm.maxnum.v8f32
"llvm.intr.maxnum"(%arg2, %arg3) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float> "llvm.intr.maxnum"(%arg2, %arg3) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float>
llvm.return llvm.return
} }
// CHECK-LABEL: @minnum_test // CHECK-LABEL: @minnum_test
llvm.func @minnum_test(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.vec<8 x float>) { llvm.func @minnum_test(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.vec<8 x float>, %arg3: !llvm.vec<8 x float>) {
// CHECK: call float @llvm.minnum.f32 // CHECK: call float @llvm.minnum.f32
"llvm.intr.minnum"(%arg0, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float "llvm.intr.minnum"(%arg0, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float
// CHECK: call <8 x float> @llvm.minnum.v8f32 // CHECK: call <8 x float> @llvm.minnum.v8f32
"llvm.intr.minnum"(%arg2, %arg3) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float> "llvm.intr.minnum"(%arg2, %arg3) : (!llvm.vec<8 x float>, !llvm.vec<8 x float>) -> !llvm.vec<8 x float>
llvm.return llvm.return
} }
// CHECK-LABEL: @smax_test // CHECK-LABEL: @smax_test
llvm.func @smax_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @smax_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call i32 @llvm.smax.i32 // CHECK: call i32 @llvm.smax.i32
"llvm.intr.smax"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.i32 "llvm.intr.smax"(%arg0, %arg1) : (i32, i32) -> i32
// CHECK: call <8 x i32> @llvm.smax.v8i32 // CHECK: call <8 x i32> @llvm.smax.v8i32
"llvm.intr.smax"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.vec<8 x i32> "llvm.intr.smax"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.vec<8 x i32>
llvm.return llvm.return
} }
// CHECK-LABEL: @smin_test // CHECK-LABEL: @smin_test
llvm.func @smin_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @smin_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call i32 @llvm.smin.i32 // CHECK: call i32 @llvm.smin.i32
"llvm.intr.smin"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.i32 "llvm.intr.smin"(%arg0, %arg1) : (i32, i32) -> i32
// CHECK: call <8 x i32> @llvm.smin.v8i32 // CHECK: call <8 x i32> @llvm.smin.v8i32
"llvm.intr.smin"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.vec<8 x i32> "llvm.intr.smin"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.vec<8 x i32>
llvm.return llvm.return
} }
// CHECK-LABEL: @vector_reductions // CHECK-LABEL: @vector_reductions
llvm.func @vector_reductions(%arg0: !llvm.float, %arg1: !llvm.vec<8 x float>, %arg2: !llvm.vec<8 x i32>) { llvm.func @vector_reductions(%arg0: !llvm.float, %arg1: !llvm.vec<8 x float>, %arg2: !llvm.vec<8 x i32>) {
// CHECK: call i32 @llvm.vector.reduce.add.v8i32 // CHECK: call i32 @llvm.vector.reduce.add.v8i32
"llvm.intr.vector.reduce.add"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.add"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call i32 @llvm.vector.reduce.and.v8i32 // CHECK: call i32 @llvm.vector.reduce.and.v8i32
"llvm.intr.vector.reduce.and"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.and"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call float @llvm.vector.reduce.fmax.v8f32 // CHECK: call float @llvm.vector.reduce.fmax.v8f32
"llvm.intr.vector.reduce.fmax"(%arg1) : (!llvm.vec<8 x float>) -> !llvm.float "llvm.intr.vector.reduce.fmax"(%arg1) : (!llvm.vec<8 x float>) -> !llvm.float
// CHECK: call float @llvm.vector.reduce.fmin.v8f32 // CHECK: call float @llvm.vector.reduce.fmin.v8f32
"llvm.intr.vector.reduce.fmin"(%arg1) : (!llvm.vec<8 x float>) -> !llvm.float "llvm.intr.vector.reduce.fmin"(%arg1) : (!llvm.vec<8 x float>) -> !llvm.float
// CHECK: call i32 @llvm.vector.reduce.mul.v8i32 // CHECK: call i32 @llvm.vector.reduce.mul.v8i32
"llvm.intr.vector.reduce.mul"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.mul"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call i32 @llvm.vector.reduce.or.v8i32 // CHECK: call i32 @llvm.vector.reduce.or.v8i32
"llvm.intr.vector.reduce.or"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.or"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call i32 @llvm.vector.reduce.smax.v8i32 // CHECK: call i32 @llvm.vector.reduce.smax.v8i32
"llvm.intr.vector.reduce.smax"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.smax"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call i32 @llvm.vector.reduce.smin.v8i32 // CHECK: call i32 @llvm.vector.reduce.smin.v8i32
"llvm.intr.vector.reduce.smin"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.smin"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call i32 @llvm.vector.reduce.umax.v8i32 // CHECK: call i32 @llvm.vector.reduce.umax.v8i32
"llvm.intr.vector.reduce.umax"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.umax"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call i32 @llvm.vector.reduce.umin.v8i32 // CHECK: call i32 @llvm.vector.reduce.umin.v8i32
"llvm.intr.vector.reduce.umin"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.umin"(%arg2) : (!llvm.vec<8 x i32>) -> i32
// CHECK: call float @llvm.vector.reduce.fadd.v8f32 // CHECK: call float @llvm.vector.reduce.fadd.v8f32
"llvm.intr.vector.reduce.fadd"(%arg0, %arg1) : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float "llvm.intr.vector.reduce.fadd"(%arg0, %arg1) : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float
// CHECK: call float @llvm.vector.reduce.fmul.v8f32 // CHECK: call float @llvm.vector.reduce.fmul.v8f32
"llvm.intr.vector.reduce.fmul"(%arg0, %arg1) : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float "llvm.intr.vector.reduce.fmul"(%arg0, %arg1) : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float
// CHECK: call reassoc float @llvm.vector.reduce.fadd.v8f32 // CHECK: call reassoc float @llvm.vector.reduce.fadd.v8f32
"llvm.intr.vector.reduce.fadd"(%arg0, %arg1) {reassoc = true} : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float "llvm.intr.vector.reduce.fadd"(%arg0, %arg1) {reassoc = true} : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float
// CHECK: call reassoc float @llvm.vector.reduce.fmul.v8f32 // CHECK: call reassoc float @llvm.vector.reduce.fmul.v8f32
"llvm.intr.vector.reduce.fmul"(%arg0, %arg1) {reassoc = true} : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float "llvm.intr.vector.reduce.fmul"(%arg0, %arg1) {reassoc = true} : (!llvm.float, !llvm.vec<8 x float>) -> !llvm.float
// CHECK: call i32 @llvm.vector.reduce.xor.v8i32 // CHECK: call i32 @llvm.vector.reduce.xor.v8i32
"llvm.intr.vector.reduce.xor"(%arg2) : (!llvm.vec<8 x i32>) -> !llvm.i32 "llvm.intr.vector.reduce.xor"(%arg2) : (!llvm.vec<8 x i32>) -> i32
llvm.return llvm.return
} }
// CHECK-LABEL: @matrix_intrinsics // CHECK-LABEL: @matrix_intrinsics
// 4x16 16x3 // 4x16 16x3
llvm.func @matrix_intrinsics(%A: !llvm.vec<64 x float>, %B: !llvm.vec<48 x float>, llvm.func @matrix_intrinsics(%A: !llvm.vec<64 x float>, %B: !llvm.vec<48 x float>,
%ptr: !llvm.ptr<float>, %stride: !llvm.i64) { %ptr: !llvm.ptr<float>, %stride: i64) {
// CHECK: call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %0, <48 x float> %1, i32 4, i32 16, i32 3) // CHECK: call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %0, <48 x float> %1, i32 4, i32 16, i32 3)
%C = llvm.intr.matrix.multiply %A, %B %C = llvm.intr.matrix.multiply %A, %B
{ lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} : { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} :
(!llvm.vec<64 x float>, !llvm.vec<48 x float>) -> !llvm.vec<12 x float> (!llvm.vec<64 x float>, !llvm.vec<48 x float>) -> !llvm.vec<12 x float>
// CHECK: call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %1, i32 3, i32 16) // CHECK: call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %1, i32 3, i32 16)
%D = llvm.intr.matrix.transpose %B { rows = 3: i32, columns = 16: i32} : %D = llvm.intr.matrix.transpose %B { rows = 3: i32, columns = 16: i32} :
!llvm.vec<48 x float> into !llvm.vec<48 x float> !llvm.vec<48 x float> into !llvm.vec<48 x float>
// CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32(float* align 4 %2, i64 %3, i1 false, i32 3, i32 16) // CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32(float* align 4 %2, i64 %3, i1 false, i32 3, i32 16)
%E = llvm.intr.matrix.column.major.load %ptr, <stride=%stride> %E = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
{ isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} : { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
!llvm.vec<48 x float> from !llvm.ptr<float> stride !llvm.i64 !llvm.vec<48 x float> from !llvm.ptr<float> stride i64
// CHECK: call void @llvm.matrix.column.major.store.v48f32(<48 x float> %7, float* align 4 %2, i64 %3, i1 false, i32 3, i32 16) // CHECK: call void @llvm.matrix.column.major.store.v48f32(<48 x float> %7, float* align 4 %2, i64 %3, i1 false, i32 3, i32 16)
llvm.intr.matrix.column.major.store %E, %ptr, <stride=%stride> llvm.intr.matrix.column.major.store %E, %ptr, <stride=%stride>
{ isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} : { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
!llvm.vec<48 x float> to !llvm.ptr<float> stride !llvm.i64 !llvm.vec<48 x float> to !llvm.ptr<float> stride i64
llvm.return llvm.return
} }
// CHECK-LABEL: @get_active_lane_mask // CHECK-LABEL: @get_active_lane_mask
llvm.func @get_active_lane_mask(%base: !llvm.i64, %n: !llvm.i64) -> (!llvm.vec<7 x i1>) { llvm.func @get_active_lane_mask(%base: i64, %n: i64) -> (!llvm.vec<7 x i1>) {
// CHECK: call <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64 %0, i64 %1) // CHECK: call <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64 %0, i64 %1)
%0 = llvm.intr.get.active.lane.mask %base, %n : !llvm.i64, !llvm.i64 to !llvm.vec<7 x i1> %0 = llvm.intr.get.active.lane.mask %base, %n : i64, i64 to !llvm.vec<7 x i1>
llvm.return %0 : !llvm.vec<7 x i1> llvm.return %0 : !llvm.vec<7 x i1>
} }
// CHECK-LABEL: @masked_load_store_intrinsics // CHECK-LABEL: @masked_load_store_intrinsics
llvm.func @masked_load_store_intrinsics(%A: !llvm.ptr<vec<7 x float>>, %mask: !llvm.vec<7 x i1>) { llvm.func @masked_load_store_intrinsics(%A: !llvm.ptr<vec<7 x float>>, %mask: !llvm.vec<7 x i1>) {
// CHECK: call <7 x float> @llvm.masked.load.v7f32.p0v7f32(<7 x float>* %{{.*}}, i32 1, <7 x i1> %{{.*}}, <7 x float> undef) // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0v7f32(<7 x float>* %{{.*}}, i32 1, <7 x i1> %{{.*}}, <7 x float> undef)
%a = llvm.intr.masked.load %A, %mask { alignment = 1: i32} : %a = llvm.intr.masked.load %A, %mask { alignment = 1: i32} :
(!llvm.ptr<vec<7 x float>>, !llvm.vec<7 x i1>) -> !llvm.vec<7 x float> (!llvm.ptr<vec<7 x float>>, !llvm.vec<7 x i1>) -> !llvm.vec<7 x float>
Show All 27 Lines %0 = "llvm.intr.masked.expandload"(%ptr, %mask, %passthru)
: (!llvm.ptr<float>, !llvm.vec<7 x i1>, !llvm.vec<7 x float>) -> (!llvm.vec<7 x float>) : (!llvm.ptr<float>, !llvm.vec<7 x i1>, !llvm.vec<7 x float>) -> (!llvm.vec<7 x float>)
// CHECK: call void @llvm.masked.compressstore.v7f32(<7 x float> %{{.*}}, float* %{{.*}}, <7 x i1> %{{.*}}) // CHECK: call void @llvm.masked.compressstore.v7f32(<7 x float> %{{.*}}, float* %{{.*}}, <7 x i1> %{{.*}})
"llvm.intr.masked.compressstore"(%0, %ptr, %mask) "llvm.intr.masked.compressstore"(%0, %ptr, %mask)
: (!llvm.vec<7 x float>, !llvm.ptr<float>, !llvm.vec<7 x i1>) -> () : (!llvm.vec<7 x float>, !llvm.ptr<float>, !llvm.vec<7 x i1>) -> ()
llvm.return llvm.return
} }
// CHECK-LABEL: @memcpy_test // CHECK-LABEL: @memcpy_test
llvm.func @memcpy_test(%arg0: !llvm.i32, %arg1: !llvm.i1, %arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>) { llvm.func @memcpy_test(%arg0: i32, %arg1: i1, %arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>) {
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %{{.*}}, i8* %{{.*}}, i32 %{{.*}}, i1 %{{.*}}) // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %{{.*}}, i8* %{{.*}}, i32 %{{.*}}, i1 %{{.*}})
"llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg1) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> () "llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg1) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32, i1) -> ()
%sz = llvm.mlir.constant(10: i64) : !llvm.i64 %sz = llvm.mlir.constant(10: i64) : i64
// CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* %{{.*}}, i8* %{{.*}}, i64 10, i1 %{{.*}}) // CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* %{{.*}}, i8* %{{.*}}, i64 10, i1 %{{.*}})
"llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg1) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i64, !llvm.i1) -> () "llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg1) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i64, i1) -> ()
llvm.return llvm.return
} }
// CHECK-LABEL: @sadd_with_overflow_test // CHECK-LABEL: @sadd_with_overflow_test
llvm.func @sadd_with_overflow_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @sadd_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call { i32, i1 } @llvm.sadd.with.overflow.i32 // CHECK: call { i32, i1 } @llvm.sadd.with.overflow.i32
"llvm.intr.sadd.with.overflow"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> "llvm.intr.sadd.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK: call { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32
"llvm.intr.sadd.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)> "llvm.intr.sadd.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)>
llvm.return llvm.return
} }
// CHECK-LABEL: @uadd_with_overflow_test // CHECK-LABEL: @uadd_with_overflow_test
llvm.func @uadd_with_overflow_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @uadd_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call { i32, i1 } @llvm.uadd.with.overflow.i32 // CHECK: call { i32, i1 } @llvm.uadd.with.overflow.i32
"llvm.intr.uadd.with.overflow"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> "llvm.intr.uadd.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK: call { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32
"llvm.intr.uadd.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)> "llvm.intr.uadd.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)>
llvm.return llvm.return
} }
// CHECK-LABEL: @ssub_with_overflow_test // CHECK-LABEL: @ssub_with_overflow_test
llvm.func @ssub_with_overflow_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @ssub_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call { i32, i1 } @llvm.ssub.with.overflow.i32 // CHECK: call { i32, i1 } @llvm.ssub.with.overflow.i32
"llvm.intr.ssub.with.overflow"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> "llvm.intr.ssub.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK: call { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32
"llvm.intr.ssub.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)> "llvm.intr.ssub.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)>
llvm.return llvm.return
} }
// CHECK-LABEL: @usub_with_overflow_test // CHECK-LABEL: @usub_with_overflow_test
llvm.func @usub_with_overflow_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @usub_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call { i32, i1 } @llvm.usub.with.overflow.i32 // CHECK: call { i32, i1 } @llvm.usub.with.overflow.i32
"llvm.intr.usub.with.overflow"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> "llvm.intr.usub.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK: call { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32
"llvm.intr.usub.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)> "llvm.intr.usub.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)>
llvm.return llvm.return
} }
// CHECK-LABEL: @smul_with_overflow_test // CHECK-LABEL: @smul_with_overflow_test
llvm.func @smul_with_overflow_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @smul_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call { i32, i1 } @llvm.smul.with.overflow.i32 // CHECK: call { i32, i1 } @llvm.smul.with.overflow.i32
"llvm.intr.smul.with.overflow"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> "llvm.intr.smul.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK: call { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32
"llvm.intr.smul.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)> "llvm.intr.smul.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)>
llvm.return llvm.return
} }
// CHECK-LABEL: @umul_with_overflow_test // CHECK-LABEL: @umul_with_overflow_test
llvm.func @umul_with_overflow_test(%arg0: !llvm.i32, %arg1: !llvm.i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) { llvm.func @umul_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: !llvm.vec<8 x i32>, %arg3: !llvm.vec<8 x i32>) {
// CHECK: call { i32, i1 } @llvm.umul.with.overflow.i32 // CHECK: call { i32, i1 } @llvm.umul.with.overflow.i32
"llvm.intr.umul.with.overflow"(%arg0, %arg1) : (!llvm.i32, !llvm.i32) -> !llvm.struct<(i32, i1)> "llvm.intr.umul.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>
// CHECK: call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32
"llvm.intr.umul.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)> "llvm.intr.umul.with.overflow"(%arg2, %arg3) : (!llvm.vec<8 x i32>, !llvm.vec<8 x i32>) -> !llvm.struct<(vec<8 x i32>, vec<8 x i1>)>
llvm.return llvm.return
} }
// Check that intrinsics are declared with appropriate types. // Check that intrinsics are declared with appropriate types.
// CHECK-DAG: declare float @llvm.fma.f32(float, float, float) // CHECK-DAG: declare float @llvm.fma.f32(float, float, float)
// CHECK-DAG: declare <8 x float> @llvm.fma.v8f32(<8 x float>, <8 x float>, <8 x float>) #0 // CHECK-DAG: declare <8 x float> @llvm.fma.v8f32(<8 x float>, <8 x float>, <8 x float>) #0
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

mlir/test/Target/llvmir-types.mlir

Show All 22 Lines
// CHECK: declare x86_mmx @return_x86_mmx() // CHECK: declare x86_mmx @return_x86_mmx()
llvm.func @return_x86_mmx() -> !llvm.x86_mmx llvm.func @return_x86_mmx() -> !llvm.x86_mmx
// //
// Functions. // Functions.
// //
// CHECK: declare void @f_void_i32(i32) // CHECK: declare void @f_void_i32(i32)
llvm.func @f_void_i32(!llvm.i32) -> !llvm.void llvm.func @f_void_i32(i32) -> !llvm.void
// CHECK: declare i32 @f_i32_empty() // CHECK: declare i32 @f_i32_empty()
llvm.func @f_i32_empty() -> !llvm.i32 llvm.func @f_i32_empty() -> i32
// CHECK: declare i32 @f_i32_half_bfloat_float_double(half, bfloat, float, double) // CHECK: declare i32 @f_i32_half_bfloat_float_double(half, bfloat, float, double)
llvm.func @f_i32_half_bfloat_float_double(!llvm.half, !llvm.bfloat, !llvm.float, !llvm.double) -> !llvm.i32 llvm.func @f_i32_half_bfloat_float_double(!llvm.half, !llvm.bfloat, !llvm.float, !llvm.double) -> i32
// CHECK: declare i32 @f_i32_i32_i32(i32, i32) // CHECK: declare i32 @f_i32_i32_i32(i32, i32)
llvm.func @f_i32_i32_i32(!llvm.i32, !llvm.i32) -> !llvm.i32 llvm.func @f_i32_i32_i32(i32, i32) -> i32
// CHECK: declare void @f_void_variadic(...) // CHECK: declare void @f_void_variadic(...)
llvm.func @f_void_variadic(...) llvm.func @f_void_variadic(...)
// CHECK: declare void @f_void_i32_i32_variadic(i32, i32, ...) // CHECK: declare void @f_void_i32_i32_variadic(i32, i32, ...)
llvm.func @f_void_i32_i32_variadic(!llvm.i32, !llvm.i32, ...) llvm.func @f_void_i32_i32_variadic(i32, i32, ...)
// CHECK: declare i32 (i32)* @f_f_i32_i32() // CHECK: declare i32 (i32)* @f_f_i32_i32()
llvm.func @f_f_i32_i32() -> !llvm.ptr<func<i32 (i32)>> llvm.func @f_f_i32_i32() -> !llvm.ptr<func<i32 (i32)>>
// //
// Integers. // Integers.
// //
// CHECK: declare i1 @return_i1() // CHECK: declare i1 @return_i1()
llvm.func @return_i1() -> !llvm.i1 llvm.func @return_i1() -> i1
// CHECK: declare i8 @return_i8() // CHECK: declare i8 @return_i8()
llvm.func @return_i8() -> !llvm.i8 llvm.func @return_i8() -> i8
// CHECK: declare i16 @return_i16() // CHECK: declare i16 @return_i16()
llvm.func @return_i16() -> !llvm.i16 llvm.func @return_i16() -> i16
// CHECK: declare i32 @return_i32() // CHECK: declare i32 @return_i32()
llvm.func @return_i32() -> !llvm.i32 llvm.func @return_i32() -> i32
// CHECK: declare i64 @return_i64() // CHECK: declare i64 @return_i64()
llvm.func @return_i64() -> !llvm.i64 llvm.func @return_i64() -> i64
// CHECK: declare i57 @return_i57() // CHECK: declare i57 @return_i57()
llvm.func @return_i57() -> !llvm.i57 llvm.func @return_i57() -> i57
// CHECK: declare i129 @return_i129() // CHECK: declare i129 @return_i129()
llvm.func @return_i129() -> !llvm.i129 llvm.func @return_i129() -> i129
// //
// Pointers. // Pointers.
// //
// CHECK: declare i8* @return_pi8() // CHECK: declare i8* @return_pi8()
llvm.func @return_pi8() -> !llvm.ptr<i8> llvm.func @return_pi8() -> !llvm.ptr<i8>
// CHECK: declare float* @return_pfloat() // CHECK: declare float* @return_pfloat()
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

mlir/test/Target/llvmir.mlir

// RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s // RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
// CHECK: @i32_global = internal global i32 42 // CHECK: @i32_global = internal global i32 42
llvm.mlir.global internal @i32_global(42: i32) : !llvm.i32 llvm.mlir.global internal @i32_global(42: i32) : i32
// CHECK: @i32_const = internal constant i53 52 // CHECK: @i32_const = internal constant i53 52
llvm.mlir.global internal constant @i32_const(52: i53) : !llvm.i53 llvm.mlir.global internal constant @i32_const(52: i53) : i53
// CHECK: @int_global_array = internal global [3 x i32] [i32 62, i32 62, i32 62] // CHECK: @int_global_array = internal global [3 x i32] [i32 62, i32 62, i32 62]
llvm.mlir.global internal @int_global_array(dense<62> : vector<3xi32>) : !llvm.array<3 x i32> llvm.mlir.global internal @int_global_array(dense<62> : vector<3xi32>) : !llvm.array<3 x i32>
// CHECK: @i32_global_addr_space = internal addrspace(7) global i32 62 // CHECK: @i32_global_addr_space = internal addrspace(7) global i32 62
llvm.mlir.global internal @i32_global_addr_space(62: i32) {addr_space = 7 : i32} : !llvm.i32 llvm.mlir.global internal @i32_global_addr_space(62: i32) {addr_space = 7 : i32} : i32
// CHECK: @float_global = internal global float 0.000000e+00 // CHECK: @float_global = internal global float 0.000000e+00
llvm.mlir.global internal @float_global(0.0: f32) : !llvm.float llvm.mlir.global internal @float_global(0.0: f32) : !llvm.float
// CHECK: @float_global_array = internal global [1 x float] [float -5.000000e+00] // CHECK: @float_global_array = internal global [1 x float] [float -5.000000e+00]
llvm.mlir.global internal @float_global_array(dense<[-5.0]> : vector<1xf32>) : !llvm.array<1 x float> llvm.mlir.global internal @float_global_array(dense<[-5.0]> : vector<1xf32>) : !llvm.array<1 x float>
// CHECK: @string_const = internal constant [6 x i8] c"foobar" // CHECK: @string_const = internal constant [6 x i8] c"foobar"
llvm.mlir.global internal constant @string_const("foobar") : !llvm.array<6 x i8> llvm.mlir.global internal constant @string_const("foobar") : !llvm.array<6 x i8>
// CHECK: @int_global_undef = internal global i64 undef // CHECK: @int_global_undef = internal global i64 undef
llvm.mlir.global internal @int_global_undef() : !llvm.i64 llvm.mlir.global internal @int_global_undef() : i64
// CHECK: @int_gep = internal constant i32* getelementptr (i32, i32* @i32_global, i32 2) // CHECK: @int_gep = internal constant i32* getelementptr (i32, i32* @i32_global, i32 2)
llvm.mlir.global internal constant @int_gep() : !llvm.ptr<i32> { llvm.mlir.global internal constant @int_gep() : !llvm.ptr<i32> {
%addr = llvm.mlir.addressof @i32_global : !llvm.ptr<i32> %addr = llvm.mlir.addressof @i32_global : !llvm.ptr<i32>
%_c0 = llvm.mlir.constant(2: i32) :!llvm.i32 %_c0 = llvm.mlir.constant(2: i32) :i32
%gepinit = llvm.getelementptr %addr[%_c0] : (!llvm.ptr<i32>, !llvm.i32) -> !llvm.ptr<i32> %gepinit = llvm.getelementptr %addr[%_c0] : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
llvm.return %gepinit : !llvm.ptr<i32> llvm.return %gepinit : !llvm.ptr<i32>
} }
// //
// Linkage attribute. // Linkage attribute.
// //
// CHECK: @private = private global i32 42 // CHECK: @private = private global i32 42
llvm.mlir.global private @private(42 : i32) : !llvm.i32 llvm.mlir.global private @private(42 : i32) : i32
// CHECK: @internal = internal global i32 42 // CHECK: @internal = internal global i32 42
llvm.mlir.global internal @internal(42 : i32) : !llvm.i32 llvm.mlir.global internal @internal(42 : i32) : i32
// CHECK: @available_externally = available_externally global i32 42 // CHECK: @available_externally = available_externally global i32 42
llvm.mlir.global available_externally @available_externally(42 : i32) : !llvm.i32 llvm.mlir.global available_externally @available_externally(42 : i32) : i32
// CHECK: @linkonce = linkonce global i32 42 // CHECK: @linkonce = linkonce global i32 42
llvm.mlir.global linkonce @linkonce(42 : i32) : !llvm.i32 llvm.mlir.global linkonce @linkonce(42 : i32) : i32
// CHECK: @weak = weak global i32 42 // CHECK: @weak = weak global i32 42
llvm.mlir.global weak @weak(42 : i32) : !llvm.i32 llvm.mlir.global weak @weak(42 : i32) : i32
// CHECK: @common = common global i32 42 // CHECK: @common = common global i32 42
llvm.mlir.global common @common(42 : i32) : !llvm.i32 llvm.mlir.global common @common(42 : i32) : i32
// CHECK: @appending = appending global i32 42 // CHECK: @appending = appending global i32 42
llvm.mlir.global appending @appending(42 : i32) : !llvm.i32 llvm.mlir.global appending @appending(42 : i32) : i32
// CHECK: @extern_weak = extern_weak global i32 // CHECK: @extern_weak = extern_weak global i32
llvm.mlir.global extern_weak @extern_weak() : !llvm.i32 llvm.mlir.global extern_weak @extern_weak() : i32
// CHECK: @linkonce_odr = linkonce_odr global i32 42 // CHECK: @linkonce_odr = linkonce_odr global i32 42
llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : !llvm.i32 llvm.mlir.global linkonce_odr @linkonce_odr(42 : i32) : i32
// CHECK: @weak_odr = weak_odr global i32 42 // CHECK: @weak_odr = weak_odr global i32 42
llvm.mlir.global weak_odr @weak_odr(42 : i32) : !llvm.i32 llvm.mlir.global weak_odr @weak_odr(42 : i32) : i32
// CHECK: @external = external global i32 // CHECK: @external = external global i32
llvm.mlir.global external @external() : !llvm.i32 llvm.mlir.global external @external() : i32
// //
// Declarations of the allocation functions to be linked against. These are // Declarations of the allocation functions to be linked against. These are
// inserted before other functions in the module. // inserted before other functions in the module.
// //
// CHECK: declare i8* @malloc(i64) // CHECK: declare i8* @malloc(i64)
llvm.func @malloc(!llvm.i64) -> !llvm.ptr<i8> llvm.func @malloc(i64) -> !llvm.ptr<i8>
// CHECK: declare void @free(i8*) // CHECK: declare void @free(i8*)
// //
// Basic functionality: function and block conversion, function calls, // Basic functionality: function and block conversion, function calls,
// phi nodes, scalar type conversion, arithmetic operations. // phi nodes, scalar type conversion, arithmetic operations.
// //
Show All 9 Linesllvm.func @global_refs() {
// Check load from globals. // Check load from globals.
// CHECK: load i32, i32* @i32_global // CHECK: load i32, i32* @i32_global
%0 = llvm.mlir.addressof @i32_global : !llvm.ptr<i32> %0 = llvm.mlir.addressof @i32_global : !llvm.ptr<i32>
%1 = llvm.load %0 : !llvm.ptr<i32> %1 = llvm.load %0 : !llvm.ptr<i32>
// Check the contracted form of load from array constants. // Check the contracted form of load from array constants.
// CHECK: load i8, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @string_const, i64 0, i64 0) // CHECK: load i8, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @string_const, i64 0, i64 0)
%2 = llvm.mlir.addressof @string_const : !llvm.ptr<array<6 x i8>> %2 = llvm.mlir.addressof @string_const : !llvm.ptr<array<6 x i8>>
%c0 = llvm.mlir.constant(0 : index) : !llvm.i64 %c0 = llvm.mlir.constant(0 : index) : i64
%3 = llvm.getelementptr %2[%c0, %c0] : (!llvm.ptr<array<6 x i8>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i8> %3 = llvm.getelementptr %2[%c0, %c0] : (!llvm.ptr<array<6 x i8>>, i64, i64) -> !llvm.ptr<i8>
%4 = llvm.load %3 : !llvm.ptr<i8> %4 = llvm.load %3 : !llvm.ptr<i8>
llvm.return llvm.return
} }
// CHECK-LABEL: declare void @body(i64) // CHECK-LABEL: declare void @body(i64)
llvm.func @body(!llvm.i64) llvm.func @body(i64)
// CHECK-LABEL: define void @simple_loop() // CHECK-LABEL: define void @simple_loop()
llvm.func @simple_loop() { llvm.func @simple_loop() {
// CHECK: br label %[[SIMPLE_bb1:[0-9]+]] // CHECK: br label %[[SIMPLE_bb1:[0-9]+]]
llvm.br ^bb1 llvm.br ^bb1
// Constants are inlined in LLVM rather than a separate instruction. // Constants are inlined in LLVM rather than a separate instruction.
// CHECK: [[SIMPLE_bb1]]: // CHECK: [[SIMPLE_bb1]]:
// CHECK-NEXT: br label %[[SIMPLE_bb2:[0-9]+]] // CHECK-NEXT: br label %[[SIMPLE_bb2:[0-9]+]]
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%0 = llvm.mlir.constant(1 : index) : !llvm.i64 %0 = llvm.mlir.constant(1 : index) : i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64 %1 = llvm.mlir.constant(42 : index) : i64
llvm.br ^bb2(%0 : !llvm.i64) llvm.br ^bb2(%0 : i64)
// CHECK: [[SIMPLE_bb2]]: // CHECK: [[SIMPLE_bb2]]:
// CHECK-NEXT: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %[[SIMPLE_bb3:[0-9]+]] ], [ 1, %[[SIMPLE_bb1]] ] // CHECK-NEXT: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %[[SIMPLE_bb3:[0-9]+]] ], [ 1, %[[SIMPLE_bb1]] ]
// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 42 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 42
// CHECK-NEXT: br i1 %{{[0-9]+}}, label %[[SIMPLE_bb3]], label %[[SIMPLE_bb4:[0-9]+]] // CHECK-NEXT: br i1 %{{[0-9]+}}, label %[[SIMPLE_bb3]], label %[[SIMPLE_bb4:[0-9]+]]
^bb2(%2: !llvm.i64): // 2 preds: ^bb1, ^bb3 ^bb2(%2: i64): // 2 preds: ^bb1, ^bb3
%3 = llvm.icmp "slt" %2, %1 : !llvm.i64 %3 = llvm.icmp "slt" %2, %1 : i64
llvm.cond_br %3, ^bb3, ^bb4 llvm.cond_br %3, ^bb3, ^bb4
// CHECK: [[SIMPLE_bb3]]: // CHECK: [[SIMPLE_bb3]]:
// CHECK-NEXT: call void @body(i64 %{{[0-9]+}}) // CHECK-NEXT: call void @body(i64 %{{[0-9]+}})
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
// CHECK-NEXT: br label %[[SIMPLE_bb2]] // CHECK-NEXT: br label %[[SIMPLE_bb2]]
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
llvm.call @body(%2) : (!llvm.i64) -> () llvm.call @body(%2) : (i64) -> ()
%4 = llvm.mlir.constant(1 : index) : !llvm.i64 %4 = llvm.mlir.constant(1 : index) : i64
%5 = llvm.add %2, %4 : !llvm.i64 %5 = llvm.add %2, %4 : i64
llvm.br ^bb2(%5 : !llvm.i64) llvm.br ^bb2(%5 : i64)
// CHECK: [[SIMPLE_bb4]]: // CHECK: [[SIMPLE_bb4]]:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
^bb4: // pred: ^bb2 ^bb4: // pred: ^bb2
llvm.return llvm.return
} }
// CHECK-LABEL: define void @simple_caller() // CHECK-LABEL: define void @simple_caller()
Show All 19 Lines
// CHECK-NEXT: } // CHECK-NEXT: }
llvm.func @ml_caller() { llvm.func @ml_caller() {
llvm.call @simple_loop() : () -> () llvm.call @simple_loop() : () -> ()
llvm.call @more_imperfectly_nested_loops() : () -> () llvm.call @more_imperfectly_nested_loops() : () -> ()
llvm.return llvm.return
} }
// CHECK-LABEL: declare i64 @body_args(i64) // CHECK-LABEL: declare i64 @body_args(i64)
llvm.func @body_args(!llvm.i64) -> !llvm.i64 llvm.func @body_args(i64) -> i64
// CHECK-LABEL: declare i32 @other(i64, i32) // CHECK-LABEL: declare i32 @other(i64, i32)
llvm.func @other(!llvm.i64, !llvm.i32) -> !llvm.i32 llvm.func @other(i64, i32) -> i32
// CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}}) // CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}})
// CHECK-NEXT: br label %[[ARGS_bb1:[0-9]+]] // CHECK-NEXT: br label %[[ARGS_bb1:[0-9]+]]
llvm.func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 { llvm.func @func_args(%arg0: i32, %arg1: i32) -> i32 {
%0 = llvm.mlir.constant(0 : i32) : !llvm.i32 %0 = llvm.mlir.constant(0 : i32) : i32
llvm.br ^bb1 llvm.br ^bb1
// CHECK: [[ARGS_bb1]]: // CHECK: [[ARGS_bb1]]:
// CHECK-NEXT: br label %[[ARGS_bb2:[0-9]+]] // CHECK-NEXT: br label %[[ARGS_bb2:[0-9]+]]
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%1 = llvm.mlir.constant(0 : index) : !llvm.i64 %1 = llvm.mlir.constant(0 : index) : i64
%2 = llvm.mlir.constant(42 : index) : !llvm.i64 %2 = llvm.mlir.constant(42 : index) : i64
llvm.br ^bb2(%1 : !llvm.i64) llvm.br ^bb2(%1 : i64)
// CHECK: [[ARGS_bb2]]: // CHECK: [[ARGS_bb2]]:
// CHECK-NEXT: %5 = phi i64 [ %12, %[[ARGS_bb3:[0-9]+]] ], [ 0, %[[ARGS_bb1]] ] // CHECK-NEXT: %5 = phi i64 [ %12, %[[ARGS_bb3:[0-9]+]] ], [ 0, %[[ARGS_bb1]] ]
// CHECK-NEXT: %6 = icmp slt i64 %5, 42 // CHECK-NEXT: %6 = icmp slt i64 %5, 42
// CHECK-NEXT: br i1 %6, label %[[ARGS_bb3]], label %[[ARGS_bb4:[0-9]+]] // CHECK-NEXT: br i1 %6, label %[[ARGS_bb3]], label %[[ARGS_bb4:[0-9]+]]
^bb2(%3: !llvm.i64): // 2 preds: ^bb1, ^bb3 ^bb2(%3: i64): // 2 preds: ^bb1, ^bb3
%4 = llvm.icmp "slt" %3, %2 : !llvm.i64 %4 = llvm.icmp "slt" %3, %2 : i64
llvm.cond_br %4, ^bb3, ^bb4 llvm.cond_br %4, ^bb3, ^bb4
// CHECK: [[ARGS_bb3]]: // CHECK: [[ARGS_bb3]]:
// CHECK-NEXT: %8 = call i64 @body_args(i64 %5) // CHECK-NEXT: %8 = call i64 @body_args(i64 %5)
// CHECK-NEXT: %9 = call i32 @other(i64 %8, i32 %0) // CHECK-NEXT: %9 = call i32 @other(i64 %8, i32 %0)
// CHECK-NEXT: %10 = call i32 @other(i64 %8, i32 %9) // CHECK-NEXT: %10 = call i32 @other(i64 %8, i32 %9)
// CHECK-NEXT: %11 = call i32 @other(i64 %8, i32 %1) // CHECK-NEXT: %11 = call i32 @other(i64 %8, i32 %1)
// CHECK-NEXT: %12 = add i64 %5, 1 // CHECK-NEXT: %12 = add i64 %5, 1
// CHECK-NEXT: br label %[[ARGS_bb2]] // CHECK-NEXT: br label %[[ARGS_bb2]]
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
%5 = llvm.call @body_args(%3) : (!llvm.i64) -> !llvm.i64 %5 = llvm.call @body_args(%3) : (i64) -> i64
%6 = llvm.call @other(%5, %arg0) : (!llvm.i64, !llvm.i32) -> !llvm.i32 %6 = llvm.call @other(%5, %arg0) : (i64, i32) -> i32
%7 = llvm.call @other(%5, %6) : (!llvm.i64, !llvm.i32) -> !llvm.i32 %7 = llvm.call @other(%5, %6) : (i64, i32) -> i32
%8 = llvm.call @other(%5, %arg1) : (!llvm.i64, !llvm.i32) -> !llvm.i32 %8 = llvm.call @other(%5, %arg1) : (i64, i32) -> i32
%9 = llvm.mlir.constant(1 : index) : !llvm.i64 %9 = llvm.mlir.constant(1 : index) : i64
%10 = llvm.add %3, %9 : !llvm.i64 %10 = llvm.add %3, %9 : i64
llvm.br ^bb2(%10 : !llvm.i64) llvm.br ^bb2(%10 : i64)
// CHECK: [[ARGS_bb4]]: // CHECK: [[ARGS_bb4]]:
// CHECK-NEXT: %14 = call i32 @other(i64 0, i32 0) // CHECK-NEXT: %14 = call i32 @other(i64 0, i32 0)
// CHECK-NEXT: ret i32 %14 // CHECK-NEXT: ret i32 %14
^bb4: // pred: ^bb2 ^bb4: // pred: ^bb2
%11 = llvm.mlir.constant(0 : index) : !llvm.i64 %11 = llvm.mlir.constant(0 : index) : i64
%12 = llvm.call @other(%11, %0) : (!llvm.i64, !llvm.i32) -> !llvm.i32 %12 = llvm.call @other(%11, %0) : (i64, i32) -> i32
llvm.return %12 : !llvm.i32 llvm.return %12 : i32
} }
// CHECK: declare void @pre(i64) // CHECK: declare void @pre(i64)
llvm.func @pre(!llvm.i64) llvm.func @pre(i64)
// CHECK: declare void @body2(i64, i64) // CHECK: declare void @body2(i64, i64)
llvm.func @body2(!llvm.i64, !llvm.i64) llvm.func @body2(i64, i64)
// CHECK: declare void @post(i64) // CHECK: declare void @post(i64)
llvm.func @post(!llvm.i64) llvm.func @post(i64)
// CHECK-LABEL: define void @imperfectly_nested_loops() // CHECK-LABEL: define void @imperfectly_nested_loops()
// CHECK-NEXT: br label %[[IMPER_bb1:[0-9]+]] // CHECK-NEXT: br label %[[IMPER_bb1:[0-9]+]]
llvm.func @imperfectly_nested_loops() { llvm.func @imperfectly_nested_loops() {
llvm.br ^bb1 llvm.br ^bb1
// CHECK: [[IMPER_bb1]]: // CHECK: [[IMPER_bb1]]:
// CHECK-NEXT: br label %[[IMPER_bb2:[0-9]+]] // CHECK-NEXT: br label %[[IMPER_bb2:[0-9]+]]
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%0 = llvm.mlir.constant(0 : index) : !llvm.i64 %0 = llvm.mlir.constant(0 : index) : i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64 %1 = llvm.mlir.constant(42 : index) : i64
llvm.br ^bb2(%0 : !llvm.i64) llvm.br ^bb2(%0 : i64)
// CHECK: [[IMPER_bb2]]: // CHECK: [[IMPER_bb2]]:
// CHECK-NEXT: %3 = phi i64 [ %13, %[[IMPER_bb7:[0-9]+]] ], [ 0, %[[IMPER_bb1]] ] // CHECK-NEXT: %3 = phi i64 [ %13, %[[IMPER_bb7:[0-9]+]] ], [ 0, %[[IMPER_bb1]] ]
// CHECK-NEXT: %4 = icmp slt i64 %3, 42 // CHECK-NEXT: %4 = icmp slt i64 %3, 42
// CHECK-NEXT: br i1 %4, label %[[IMPER_bb3:[0-9]+]], label %[[IMPER_bb8:[0-9]+]] // CHECK-NEXT: br i1 %4, label %[[IMPER_bb3:[0-9]+]], label %[[IMPER_bb8:[0-9]+]]
^bb2(%2: !llvm.i64): // 2 preds: ^bb1, ^bb7 ^bb2(%2: i64): // 2 preds: ^bb1, ^bb7
%3 = llvm.icmp "slt" %2, %1 : !llvm.i64 %3 = llvm.icmp "slt" %2, %1 : i64
llvm.cond_br %3, ^bb3, ^bb8 llvm.cond_br %3, ^bb3, ^bb8
// CHECK: [[IMPER_bb3]]: // CHECK: [[IMPER_bb3]]:
// CHECK-NEXT: call void @pre(i64 %3) // CHECK-NEXT: call void @pre(i64 %3)
// CHECK-NEXT: br label %[[IMPER_bb4:[0-9]+]] // CHECK-NEXT: br label %[[IMPER_bb4:[0-9]+]]
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
llvm.call @pre(%2) : (!llvm.i64) -> () llvm.call @pre(%2) : (i64) -> ()
llvm.br ^bb4 llvm.br ^bb4
// CHECK: [[IMPER_bb4]]: // CHECK: [[IMPER_bb4]]:
// CHECK-NEXT: br label %[[IMPER_bb5:[0-9]+]] // CHECK-NEXT: br label %[[IMPER_bb5:[0-9]+]]
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
%4 = llvm.mlir.constant(7 : index) : !llvm.i64 %4 = llvm.mlir.constant(7 : index) : i64
%5 = llvm.mlir.constant(56 : index) : !llvm.i64 %5 = llvm.mlir.constant(56 : index) : i64
llvm.br ^bb5(%4 : !llvm.i64) llvm.br ^bb5(%4 : i64)
// CHECK: [[IMPER_bb5]]: // CHECK: [[IMPER_bb5]]:
// CHECK-NEXT: %8 = phi i64 [ %11, %[[IMPER_bb6:[0-9]+]] ], [ 7, %[[IMPER_bb4]] ] // CHECK-NEXT: %8 = phi i64 [ %11, %[[IMPER_bb6:[0-9]+]] ], [ 7, %[[IMPER_bb4]] ]
// CHECK-NEXT: %9 = icmp slt i64 %8, 56 // CHECK-NEXT: %9 = icmp slt i64 %8, 56
// CHECK-NEXT: br i1 %9, label %[[IMPER_bb6]], label %[[IMPER_bb7]] // CHECK-NEXT: br i1 %9, label %[[IMPER_bb6]], label %[[IMPER_bb7]]
^bb5(%6: !llvm.i64): // 2 preds: ^bb4, ^bb6 ^bb5(%6: i64): // 2 preds: ^bb4, ^bb6
%7 = llvm.icmp "slt" %6, %5 : !llvm.i64 %7 = llvm.icmp "slt" %6, %5 : i64
llvm.cond_br %7, ^bb6, ^bb7 llvm.cond_br %7, ^bb6, ^bb7
// CHECK: [[IMPER_bb6]]: // CHECK: [[IMPER_bb6]]:
// CHECK-NEXT: call void @body2(i64 %3, i64 %8) // CHECK-NEXT: call void @body2(i64 %3, i64 %8)
// CHECK-NEXT: %11 = add i64 %8, 2 // CHECK-NEXT: %11 = add i64 %8, 2
// CHECK-NEXT: br label %[[IMPER_bb5]] // CHECK-NEXT: br label %[[IMPER_bb5]]
^bb6: // pred: ^bb5 ^bb6: // pred: ^bb5
llvm.call @body2(%2, %6) : (!llvm.i64, !llvm.i64) -> () llvm.call @body2(%2, %6) : (i64, i64) -> ()
%8 = llvm.mlir.constant(2 : index) : !llvm.i64 %8 = llvm.mlir.constant(2 : index) : i64
%9 = llvm.add %6, %8 : !llvm.i64 %9 = llvm.add %6, %8 : i64
llvm.br ^bb5(%9 : !llvm.i64) llvm.br ^bb5(%9 : i64)
// CHECK: [[IMPER_bb7]]: // CHECK: [[IMPER_bb7]]:
// CHECK-NEXT: call void @post(i64 %3) // CHECK-NEXT: call void @post(i64 %3)
// CHECK-NEXT: %13 = add i64 %3, 1 // CHECK-NEXT: %13 = add i64 %3, 1
// CHECK-NEXT: br label %[[IMPER_bb2]] // CHECK-NEXT: br label %[[IMPER_bb2]]
^bb7: // pred: ^bb5 ^bb7: // pred: ^bb5
llvm.call @post(%2) : (!llvm.i64) -> () llvm.call @post(%2) : (i64) -> ()
%10 = llvm.mlir.constant(1 : index) : !llvm.i64 %10 = llvm.mlir.constant(1 : index) : i64
%11 = llvm.add %2, %10 : !llvm.i64 %11 = llvm.add %2, %10 : i64
llvm.br ^bb2(%11 : !llvm.i64) llvm.br ^bb2(%11 : i64)
// CHECK: [[IMPER_bb8]]: // CHECK: [[IMPER_bb8]]:
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
^bb8: // pred: ^bb2 ^bb8: // pred: ^bb2
llvm.return llvm.return
} }
// CHECK: declare void @mid(i64) // CHECK: declare void @mid(i64)
llvm.func @mid(!llvm.i64) llvm.func @mid(i64)
// CHECK: declare void @body3(i64, i64) // CHECK: declare void @body3(i64, i64)
llvm.func @body3(!llvm.i64, !llvm.i64) llvm.func @body3(i64, i64)
// A complete function transformation check. // A complete function transformation check.
// CHECK-LABEL: define void @more_imperfectly_nested_loops() // CHECK-LABEL: define void @more_imperfectly_nested_loops()
// CHECK-NEXT: br label %1 // CHECK-NEXT: br label %1
// CHECK: 1: ; preds = %0 // CHECK: 1: ; preds = %0
// CHECK-NEXT: br label %2 // CHECK-NEXT: br label %2
// CHECK: 2: ; preds = %19, %1 // CHECK: 2: ; preds = %19, %1
// CHECK-NEXT: %3 = phi i64 [ %20, %19 ], [ 0, %1 ] // CHECK-NEXT: %3 = phi i64 [ %20, %19 ], [ 0, %1 ]
Show All 30 Lines
// CHECK-NEXT: %20 = add i64 %3, 1 // CHECK-NEXT: %20 = add i64 %3, 1
// CHECK-NEXT: br label %2 // CHECK-NEXT: br label %2
// CHECK: 21: ; preds = %2 // CHECK: 21: ; preds = %2
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// CHECK-NEXT: } // CHECK-NEXT: }
llvm.func @more_imperfectly_nested_loops() { llvm.func @more_imperfectly_nested_loops() {
llvm.br ^bb1 llvm.br ^bb1
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%0 = llvm.mlir.constant(0 : index) : !llvm.i64 %0 = llvm.mlir.constant(0 : index) : i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64 %1 = llvm.mlir.constant(42 : index) : i64
llvm.br ^bb2(%0 : !llvm.i64) llvm.br ^bb2(%0 : i64)
^bb2(%2: !llvm.i64): // 2 preds: ^bb1, ^bb11 ^bb2(%2: i64): // 2 preds: ^bb1, ^bb11
%3 = llvm.icmp "slt" %2, %1 : !llvm.i64 %3 = llvm.icmp "slt" %2, %1 : i64
llvm.cond_br %3, ^bb3, ^bb12 llvm.cond_br %3, ^bb3, ^bb12
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
llvm.call @pre(%2) : (!llvm.i64) -> () llvm.call @pre(%2) : (i64) -> ()
llvm.br ^bb4 llvm.br ^bb4
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
%4 = llvm.mlir.constant(7 : index) : !llvm.i64 %4 = llvm.mlir.constant(7 : index) : i64
%5 = llvm.mlir.constant(56 : index) : !llvm.i64 %5 = llvm.mlir.constant(56 : index) : i64
llvm.br ^bb5(%4 : !llvm.i64) llvm.br ^bb5(%4 : i64)
^bb5(%6: !llvm.i64): // 2 preds: ^bb4, ^bb6 ^bb5(%6: i64): // 2 preds: ^bb4, ^bb6
%7 = llvm.icmp "slt" %6, %5 : !llvm.i64 %7 = llvm.icmp "slt" %6, %5 : i64
llvm.cond_br %7, ^bb6, ^bb7 llvm.cond_br %7, ^bb6, ^bb7
^bb6: // pred: ^bb5 ^bb6: // pred: ^bb5
llvm.call @body2(%2, %6) : (!llvm.i64, !llvm.i64) -> () llvm.call @body2(%2, %6) : (i64, i64) -> ()
%8 = llvm.mlir.constant(2 : index) : !llvm.i64 %8 = llvm.mlir.constant(2 : index) : i64
%9 = llvm.add %6, %8 : !llvm.i64 %9 = llvm.add %6, %8 : i64
llvm.br ^bb5(%9 : !llvm.i64) llvm.br ^bb5(%9 : i64)
^bb7: // pred: ^bb5 ^bb7: // pred: ^bb5
llvm.call @mid(%2) : (!llvm.i64) -> () llvm.call @mid(%2) : (i64) -> ()
llvm.br ^bb8 llvm.br ^bb8
^bb8: // pred: ^bb7 ^bb8: // pred: ^bb7
%10 = llvm.mlir.constant(18 : index) : !llvm.i64 %10 = llvm.mlir.constant(18 : index) : i64
%11 = llvm.mlir.constant(37 : index) : !llvm.i64 %11 = llvm.mlir.constant(37 : index) : i64
llvm.br ^bb9(%10 : !llvm.i64) llvm.br ^bb9(%10 : i64)
^bb9(%12: !llvm.i64): // 2 preds: ^bb8, ^bb10 ^bb9(%12: i64): // 2 preds: ^bb8, ^bb10
%13 = llvm.icmp "slt" %12, %11 : !llvm.i64 %13 = llvm.icmp "slt" %12, %11 : i64
llvm.cond_br %13, ^bb10, ^bb11 llvm.cond_br %13, ^bb10, ^bb11
^bb10: // pred: ^bb9 ^bb10: // pred: ^bb9
llvm.call @body3(%2, %12) : (!llvm.i64, !llvm.i64) -> () llvm.call @body3(%2, %12) : (i64, i64) -> ()
%14 = llvm.mlir.constant(3 : index) : !llvm.i64 %14 = llvm.mlir.constant(3 : index) : i64
%15 = llvm.add %12, %14 : !llvm.i64 %15 = llvm.add %12, %14 : i64
llvm.br ^bb9(%15 : !llvm.i64) llvm.br ^bb9(%15 : i64)
^bb11: // pred: ^bb9 ^bb11: // pred: ^bb9
llvm.call @post(%2) : (!llvm.i64) -> () llvm.call @post(%2) : (i64) -> ()
%16 = llvm.mlir.constant(1 : index) : !llvm.i64 %16 = llvm.mlir.constant(1 : index) : i64
%17 = llvm.add %2, %16 : !llvm.i64 %17 = llvm.add %2, %16 : i64
llvm.br ^bb2(%17 : !llvm.i64) llvm.br ^bb2(%17 : i64)
^bb12: // pred: ^bb2 ^bb12: // pred: ^bb2
llvm.return llvm.return
} }
// //
// Check that linkage is translated for functions. No need to check all linkage // Check that linkage is translated for functions. No need to check all linkage
// flags since the logic is the same as for globals. // flags since the logic is the same as for globals.
// //
// CHECK: define internal void @func_internal // CHECK: define internal void @func_internal
llvm.func internal @func_internal() { llvm.func internal @func_internal() {
llvm.return llvm.return
} }
// //
// MemRef type conversion, allocation and communication with functions. // MemRef type conversion, allocation and communication with functions.
// //
// CHECK-LABEL: define void @memref_alloc() // CHECK-LABEL: define void @memref_alloc()
llvm.func @memref_alloc() { llvm.func @memref_alloc() {
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 400) // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 400)
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float* // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0
%0 = llvm.mlir.constant(10 : index) : !llvm.i64 %0 = llvm.mlir.constant(10 : index) : i64
%1 = llvm.mlir.constant(10 : index) : !llvm.i64 %1 = llvm.mlir.constant(10 : index) : i64
%2 = llvm.mul %0, %1 : !llvm.i64 %2 = llvm.mul %0, %1 : i64
%3 = llvm.mlir.undef : !llvm.struct<(ptr<float>)> %3 = llvm.mlir.undef : !llvm.struct<(ptr<float>)>
%4 = llvm.mlir.constant(4 : index) : !llvm.i64 %4 = llvm.mlir.constant(4 : index) : i64
%5 = llvm.mul %2, %4 : !llvm.i64 %5 = llvm.mul %2, %4 : i64
%6 = llvm.call @malloc(%5) : (!llvm.i64) -> !llvm.ptr<i8> %6 = llvm.call @malloc(%5) : (i64) -> !llvm.ptr<i8>
%7 = llvm.bitcast %6 : !llvm.ptr<i8> to !llvm.ptr<float> %7 = llvm.bitcast %6 : !llvm.ptr<i8> to !llvm.ptr<float>
%8 = llvm.insertvalue %7, %3[0] : !llvm.struct<(ptr<float>)> %8 = llvm.insertvalue %7, %3[0] : !llvm.struct<(ptr<float>)>
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: declare i64 @get_index() // CHECK-LABEL: declare i64 @get_index()
llvm.func @get_index() -> !llvm.i64 llvm.func @get_index() -> i64
// CHECK-LABEL: define void @store_load_static() // CHECK-LABEL: define void @store_load_static()
llvm.func @store_load_static() { llvm.func @store_load_static() {
^bb0: ^bb0:
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 40) // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 40)
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float* // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0
%0 = llvm.mlir.constant(10 : index) : !llvm.i64 %0 = llvm.mlir.constant(10 : index) : i64
%1 = llvm.mlir.undef : !llvm.struct<(ptr<float>)> %1 = llvm.mlir.undef : !llvm.struct<(ptr<float>)>
%2 = llvm.mlir.constant(4 : index) : !llvm.i64 %2 = llvm.mlir.constant(4 : index) : i64
%3 = llvm.mul %0, %2 : !llvm.i64 %3 = llvm.mul %0, %2 : i64
%4 = llvm.call @malloc(%3) : (!llvm.i64) -> !llvm.ptr<i8> %4 = llvm.call @malloc(%3) : (i64) -> !llvm.ptr<i8>
%5 = llvm.bitcast %4 : !llvm.ptr<i8> to !llvm.ptr<float> %5 = llvm.bitcast %4 : !llvm.ptr<i8> to !llvm.ptr<float>
%6 = llvm.insertvalue %5, %1[0] : !llvm.struct<(ptr<float>)> %6 = llvm.insertvalue %5, %1[0] : !llvm.struct<(ptr<float>)>
%7 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float %7 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float
llvm.br ^bb1 llvm.br ^bb1
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%8 = llvm.mlir.constant(0 : index) : !llvm.i64 %8 = llvm.mlir.constant(0 : index) : i64
%9 = llvm.mlir.constant(10 : index) : !llvm.i64 %9 = llvm.mlir.constant(10 : index) : i64
llvm.br ^bb2(%8 : !llvm.i64) llvm.br ^bb2(%8 : i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ] // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb2(%10: !llvm.i64): // 2 preds: ^bb1, ^bb3 ^bb2(%10: i64): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10
%11 = llvm.icmp "slt" %10, %9 : !llvm.i64 %11 = llvm.icmp "slt" %10, %9 : i64
// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}} // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
llvm.cond_br %11, ^bb3, ^bb4 llvm.cond_br %11, ^bb3, ^bb4
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
// CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0 // CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}} // CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}}
%12 = llvm.mlir.constant(10 : index) : !llvm.i64 %12 = llvm.mlir.constant(10 : index) : i64
%13 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>)> %13 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>)>
%14 = llvm.getelementptr %13[%10] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %14 = llvm.getelementptr %13[%10] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %7, %14 : !llvm.ptr<float> llvm.store %7, %14 : !llvm.ptr<float>
%15 = llvm.mlir.constant(1 : index) : !llvm.i64 %15 = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%16 = llvm.add %10, %15 : !llvm.i64 %16 = llvm.add %10, %15 : i64
// CHECK-NEXT: br label %{{[0-9]+}} // CHECK-NEXT: br label %{{[0-9]+}}
llvm.br ^bb2(%16 : !llvm.i64) llvm.br ^bb2(%16 : i64)
^bb4: // pred: ^bb2 ^bb4: // pred: ^bb2
llvm.br ^bb5 llvm.br ^bb5
^bb5: // pred: ^bb4 ^bb5: // pred: ^bb4
%17 = llvm.mlir.constant(0 : index) : !llvm.i64 %17 = llvm.mlir.constant(0 : index) : i64
%18 = llvm.mlir.constant(10 : index) : !llvm.i64 %18 = llvm.mlir.constant(10 : index) : i64
llvm.br ^bb6(%17 : !llvm.i64) llvm.br ^bb6(%17 : i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ] // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb6(%19: !llvm.i64): // 2 preds: ^bb5, ^bb7 ^bb6(%19: i64): // 2 preds: ^bb5, ^bb7
// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10 // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, 10
%20 = llvm.icmp "slt" %19, %18 : !llvm.i64 %20 = llvm.icmp "slt" %19, %18 : i64
// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}} // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
llvm.cond_br %20, ^bb7, ^bb8 llvm.cond_br %20, ^bb7, ^bb8
^bb7: // pred: ^bb6 ^bb7: // pred: ^bb6
// CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0 // CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
%21 = llvm.mlir.constant(10 : index) : !llvm.i64 %21 = llvm.mlir.constant(10 : index) : i64
%22 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>)> %22 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>)>
%23 = llvm.getelementptr %22[%19] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %23 = llvm.getelementptr %22[%19] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
%24 = llvm.load %23 : !llvm.ptr<float> %24 = llvm.load %23 : !llvm.ptr<float>
%25 = llvm.mlir.constant(1 : index) : !llvm.i64 %25 = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%26 = llvm.add %19, %25 : !llvm.i64 %26 = llvm.add %19, %25 : i64
// CHECK-NEXT: br label %{{[0-9]+}} // CHECK-NEXT: br label %{{[0-9]+}}
llvm.br ^bb6(%26 : !llvm.i64) llvm.br ^bb6(%26 : i64)
^bb8: // pred: ^bb6 ^bb8: // pred: ^bb6
// CHECK: ret void // CHECK: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: define void @store_load_dynamic(i64 {{%.*}}) // CHECK-LABEL: define void @store_load_dynamic(i64 {{%.*}})
llvm.func @store_load_dynamic(%arg0: !llvm.i64) { llvm.func @store_load_dynamic(%arg0: i64) {
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}}) // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}})
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float* // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
%0 = llvm.mlir.undef : !llvm.struct<(ptr<float>, i64)> %0 = llvm.mlir.undef : !llvm.struct<(ptr<float>, i64)>
%1 = llvm.mlir.constant(4 : index) : !llvm.i64 %1 = llvm.mlir.constant(4 : index) : i64
%2 = llvm.mul %arg0, %1 : !llvm.i64 %2 = llvm.mul %arg0, %1 : i64
%3 = llvm.call @malloc(%2) : (!llvm.i64) -> !llvm.ptr<i8> %3 = llvm.call @malloc(%2) : (i64) -> !llvm.ptr<i8>
%4 = llvm.bitcast %3 : !llvm.ptr<i8> to !llvm.ptr<float> %4 = llvm.bitcast %3 : !llvm.ptr<i8> to !llvm.ptr<float>
%5 = llvm.insertvalue %4, %0[0] : !llvm.struct<(ptr<float>, i64)> %5 = llvm.insertvalue %4, %0[0] : !llvm.struct<(ptr<float>, i64)>
%6 = llvm.insertvalue %arg0, %5[1] : !llvm.struct<(ptr<float>, i64)> %6 = llvm.insertvalue %arg0, %5[1] : !llvm.struct<(ptr<float>, i64)>
%7 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float %7 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float
// CHECK-NEXT: br label %{{[0-9]+}} // CHECK-NEXT: br label %{{[0-9]+}}
llvm.br ^bb1 llvm.br ^bb1
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
%8 = llvm.mlir.constant(0 : index) : !llvm.i64 %8 = llvm.mlir.constant(0 : index) : i64
llvm.br ^bb2(%8 : !llvm.i64) llvm.br ^bb2(%8 : i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ] // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb2(%9: !llvm.i64): // 2 preds: ^bb1, ^bb3 ^bb2(%9: i64): // 2 preds: ^bb1, ^bb3
// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}}
%10 = llvm.icmp "slt" %9, %arg0 : !llvm.i64 %10 = llvm.icmp "slt" %9, %arg0 : i64
// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}} // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
llvm.cond_br %10, ^bb3, ^bb4 llvm.cond_br %10, ^bb3, ^bb4
^bb3: // pred: ^bb2 ^bb3: // pred: ^bb2
// CHECK: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1 // CHECK: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}} // CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}}
%11 = llvm.extractvalue %6[1] : !llvm.struct<(ptr<float>, i64)> %11 = llvm.extractvalue %6[1] : !llvm.struct<(ptr<float>, i64)>
%12 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>, i64)> %12 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>, i64)>
%13 = llvm.getelementptr %12[%9] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %13 = llvm.getelementptr %12[%9] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %7, %13 : !llvm.ptr<float> llvm.store %7, %13 : !llvm.ptr<float>
%14 = llvm.mlir.constant(1 : index) : !llvm.i64 %14 = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%15 = llvm.add %9, %14 : !llvm.i64 %15 = llvm.add %9, %14 : i64
// CHECK-NEXT: br label %{{[0-9]+}} // CHECK-NEXT: br label %{{[0-9]+}}
llvm.br ^bb2(%15 : !llvm.i64) llvm.br ^bb2(%15 : i64)
^bb4: // pred: ^bb3 ^bb4: // pred: ^bb3
llvm.br ^bb5 llvm.br ^bb5
^bb5: // pred: ^bb4 ^bb5: // pred: ^bb4
%16 = llvm.mlir.constant(0 : index) : !llvm.i64 %16 = llvm.mlir.constant(0 : index) : i64
llvm.br ^bb6(%16 : !llvm.i64) llvm.br ^bb6(%16 : i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ] // CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb6(%17: !llvm.i64): // 2 preds: ^bb5, ^bb7 ^bb6(%17: i64): // 2 preds: ^bb5, ^bb7
// CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = icmp slt i64 %{{[0-9]+}}, %{{[0-9]+}}
%18 = llvm.icmp "slt" %17, %arg0 : !llvm.i64 %18 = llvm.icmp "slt" %17, %arg0 : i64
// CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}} // CHECK-NEXT: br i1 %{{[0-9]+}}, label %{{[0-9]+}}, label %{{[0-9]+}}
llvm.cond_br %18, ^bb7, ^bb8 llvm.cond_br %18, ^bb7, ^bb8
^bb7: // pred: ^bb6 ^bb7: // pred: ^bb6
// CHECK: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1 // CHECK: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
%19 = llvm.extractvalue %6[1] : !llvm.struct<(ptr<float>, i64)> %19 = llvm.extractvalue %6[1] : !llvm.struct<(ptr<float>, i64)>
%20 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>, i64)> %20 = llvm.extractvalue %6[0] : !llvm.struct<(ptr<float>, i64)>
%21 = llvm.getelementptr %20[%17] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %21 = llvm.getelementptr %20[%17] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
%22 = llvm.load %21 : !llvm.ptr<float> %22 = llvm.load %21 : !llvm.ptr<float>
%23 = llvm.mlir.constant(1 : index) : !llvm.i64 %23 = llvm.mlir.constant(1 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%24 = llvm.add %17, %23 : !llvm.i64 %24 = llvm.add %17, %23 : i64
// CHECK-NEXT: br label %{{[0-9]+}} // CHECK-NEXT: br label %{{[0-9]+}}
llvm.br ^bb6(%24 : !llvm.i64) llvm.br ^bb6(%24 : i64)
^bb8: // pred: ^bb6 ^bb8: // pred: ^bb6
// CHECK: ret void // CHECK: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: define void @store_load_mixed(i64 {{%.*}}) // CHECK-LABEL: define void @store_load_mixed(i64 {{%.*}})
llvm.func @store_load_mixed(%arg0: !llvm.i64) { llvm.func @store_load_mixed(%arg0: i64) {
%0 = llvm.mlir.constant(10 : index) : !llvm.i64 %0 = llvm.mlir.constant(10 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = mul i64 2, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 2, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 10 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 10
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}}) // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}})
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float* // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } undef, float* %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } undef, float* %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 10, 2 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 10, 2
%1 = llvm.mlir.constant(2 : index) : !llvm.i64 %1 = llvm.mlir.constant(2 : index) : i64
%2 = llvm.mlir.constant(4 : index) : !llvm.i64 %2 = llvm.mlir.constant(4 : index) : i64
%3 = llvm.mul %1, %arg0 : !llvm.i64 %3 = llvm.mul %1, %arg0 : i64
%4 = llvm.mul %3, %2 : !llvm.i64 %4 = llvm.mul %3, %2 : i64
%5 = llvm.mul %4, %0 : !llvm.i64 %5 = llvm.mul %4, %0 : i64
%6 = llvm.mlir.undef : !llvm.struct<(ptr<float>, i64, i64)> %6 = llvm.mlir.undef : !llvm.struct<(ptr<float>, i64, i64)>
%7 = llvm.mlir.constant(4 : index) : !llvm.i64 %7 = llvm.mlir.constant(4 : index) : i64
%8 = llvm.mul %5, %7 : !llvm.i64 %8 = llvm.mul %5, %7 : i64
%9 = llvm.call @malloc(%8) : (!llvm.i64) -> !llvm.ptr<i8> %9 = llvm.call @malloc(%8) : (i64) -> !llvm.ptr<i8>
%10 = llvm.bitcast %9 : !llvm.ptr<i8> to !llvm.ptr<float> %10 = llvm.bitcast %9 : !llvm.ptr<i8> to !llvm.ptr<float>
%11 = llvm.insertvalue %10, %6[0] : !llvm.struct<(ptr<float>, i64, i64)> %11 = llvm.insertvalue %10, %6[0] : !llvm.struct<(ptr<float>, i64, i64)>
%12 = llvm.insertvalue %arg0, %11[1] : !llvm.struct<(ptr<float>, i64, i64)> %12 = llvm.insertvalue %arg0, %11[1] : !llvm.struct<(ptr<float>, i64, i64)>
%13 = llvm.insertvalue %0, %12[2] : !llvm.struct<(ptr<float>, i64, i64)> %13 = llvm.insertvalue %0, %12[2] : !llvm.struct<(ptr<float>, i64, i64)>
// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index() // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index() // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
%14 = llvm.mlir.constant(1 : index) : !llvm.i64 %14 = llvm.mlir.constant(1 : index) : i64
%15 = llvm.mlir.constant(2 : index) : !llvm.i64 %15 = llvm.mlir.constant(2 : index) : i64
%16 = llvm.call @get_index() : () -> !llvm.i64 %16 = llvm.call @get_index() : () -> i64
%17 = llvm.call @get_index() : () -> !llvm.i64 %17 = llvm.call @get_index() : () -> i64
%18 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float %18 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
%19 = llvm.mlir.constant(2 : index) : !llvm.i64 %19 = llvm.mlir.constant(2 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2
// CHECK-NEXT: %{{[0-9]+}} = mul i64 1, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 1, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}} // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%20 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<float>, i64, i64)> %20 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<float>, i64, i64)>
%21 = llvm.mlir.constant(4 : index) : !llvm.i64 %21 = llvm.mlir.constant(4 : index) : i64
%22 = llvm.extractvalue %13[2] : !llvm.struct<(ptr<float>, i64, i64)> %22 = llvm.extractvalue %13[2] : !llvm.struct<(ptr<float>, i64, i64)>
%23 = llvm.mul %14, %20 : !llvm.i64 %23 = llvm.mul %14, %20 : i64
%24 = llvm.add %23, %15 : !llvm.i64 %24 = llvm.add %23, %15 : i64
%25 = llvm.mul %24, %21 : !llvm.i64 %25 = llvm.mul %24, %21 : i64
%26 = llvm.add %25, %16 : !llvm.i64 %26 = llvm.add %25, %16 : i64
%27 = llvm.mul %26, %22 : !llvm.i64 %27 = llvm.mul %26, %22 : i64
%28 = llvm.add %27, %17 : !llvm.i64 %28 = llvm.add %27, %17 : i64
%29 = llvm.extractvalue %13[0] : !llvm.struct<(ptr<float>, i64, i64)> %29 = llvm.extractvalue %13[0] : !llvm.struct<(ptr<float>, i64, i64)>
%30 = llvm.getelementptr %29[%28] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %30 = llvm.getelementptr %29[%28] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %18, %30 : !llvm.ptr<float> llvm.store %18, %30 : !llvm.ptr<float>
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 2
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
%31 = llvm.mlir.constant(2 : index) : !llvm.i64 %31 = llvm.mlir.constant(2 : index) : i64
%32 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<float>, i64, i64)> %32 = llvm.extractvalue %13[1] : !llvm.struct<(ptr<float>, i64, i64)>
%33 = llvm.mlir.constant(4 : index) : !llvm.i64 %33 = llvm.mlir.constant(4 : index) : i64
%34 = llvm.extractvalue %13[2] : !llvm.struct<(ptr<float>, i64, i64)> %34 = llvm.extractvalue %13[2] : !llvm.struct<(ptr<float>, i64, i64)>
%35 = llvm.mul %17, %32 : !llvm.i64 %35 = llvm.mul %17, %32 : i64
%36 = llvm.add %35, %16 : !llvm.i64 %36 = llvm.add %35, %16 : i64
%37 = llvm.mul %36, %33 : !llvm.i64 %37 = llvm.mul %36, %33 : i64
%38 = llvm.add %37, %15 : !llvm.i64 %38 = llvm.add %37, %15 : i64
%39 = llvm.mul %38, %34 : !llvm.i64 %39 = llvm.mul %38, %34 : i64
%40 = llvm.add %39, %14 : !llvm.i64 %40 = llvm.add %39, %14 : i64
%41 = llvm.extractvalue %13[0] : !llvm.struct<(ptr<float>, i64, i64)> %41 = llvm.extractvalue %13[0] : !llvm.struct<(ptr<float>, i64, i64)>
%42 = llvm.getelementptr %41[%40] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %42 = llvm.getelementptr %41[%40] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
%43 = llvm.load %42 : !llvm.ptr<float> %43 = llvm.load %42 : !llvm.ptr<float>
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: define { float*, i64 } @memref_args_rets({ float* } {{%.*}}, { float*, i64 } {{%.*}}, { float*, i64 } {{%.*}}) // CHECK-LABEL: define { float*, i64 } @memref_args_rets({ float* } {{%.*}}, { float*, i64 } {{%.*}}, { float*, i64 } {{%.*}})
llvm.func @memref_args_rets(%arg0: !llvm.struct<(ptr<float>)>, %arg1: !llvm.struct<(ptr<float>, i64)>, %arg2: !llvm.struct<(ptr<float>, i64)>) -> !llvm.struct<(ptr<float>, i64)> { llvm.func @memref_args_rets(%arg0: !llvm.struct<(ptr<float>)>, %arg1: !llvm.struct<(ptr<float>, i64)>, %arg2: !llvm.struct<(ptr<float>, i64)>) -> !llvm.struct<(ptr<float>, i64)> {
%0 = llvm.mlir.constant(7 : index) : !llvm.i64 %0 = llvm.mlir.constant(7 : index) : i64
// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index() // CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
%1 = llvm.call @get_index() : () -> !llvm.i64 %1 = llvm.call @get_index() : () -> i64
%2 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float %2 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}} // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%3 = llvm.mlir.constant(10 : index) : !llvm.i64 %3 = llvm.mlir.constant(10 : index) : i64
%4 = llvm.extractvalue %arg0[0] : !llvm.struct<(ptr<float>)> %4 = llvm.extractvalue %arg0[0] : !llvm.struct<(ptr<float>)>
%5 = llvm.getelementptr %4[%0] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %5 = llvm.getelementptr %4[%0] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %2, %5 : !llvm.ptr<float> llvm.store %2, %5 : !llvm.ptr<float>
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7 // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}} // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%6 = llvm.extractvalue %arg1[1] : !llvm.struct<(ptr<float>, i64)> %6 = llvm.extractvalue %arg1[1] : !llvm.struct<(ptr<float>, i64)>
%7 = llvm.extractvalue %arg1[0] : !llvm.struct<(ptr<float>, i64)> %7 = llvm.extractvalue %arg1[0] : !llvm.struct<(ptr<float>, i64)>
%8 = llvm.getelementptr %7[%0] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %8 = llvm.getelementptr %7[%0] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %2, %8 : !llvm.ptr<float> llvm.store %2, %8 : !llvm.ptr<float>
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = mul i64 7, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 7, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}} // CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%9 = llvm.mlir.constant(10 : index) : !llvm.i64 %9 = llvm.mlir.constant(10 : index) : i64
%10 = llvm.extractvalue %arg2[1] : !llvm.struct<(ptr<float>, i64)> %10 = llvm.extractvalue %arg2[1] : !llvm.struct<(ptr<float>, i64)>
%11 = llvm.mul %0, %10 : !llvm.i64 %11 = llvm.mul %0, %10 : i64
%12 = llvm.add %11, %1 : !llvm.i64 %12 = llvm.add %11, %1 : i64
%13 = llvm.extractvalue %arg2[0] : !llvm.struct<(ptr<float>, i64)> %13 = llvm.extractvalue %arg2[0] : !llvm.struct<(ptr<float>, i64)>
%14 = llvm.getelementptr %13[%12] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %14 = llvm.getelementptr %13[%12] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %2, %14 : !llvm.ptr<float> llvm.store %2, %14 : !llvm.ptr<float>
// CHECK-NEXT: %{{[0-9]+}} = mul i64 10, %{{[0-9]+}} // CHECK-NEXT: %{{[0-9]+}} = mul i64 10, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4 // CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}}) // CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 %{{[0-9]+}})
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float* // CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
%15 = llvm.mlir.constant(10 : index) : !llvm.i64 %15 = llvm.mlir.constant(10 : index) : i64
%16 = llvm.mul %15, %1 : !llvm.i64 %16 = llvm.mul %15, %1 : i64
%17 = llvm.mlir.undef : !llvm.struct<(ptr<float>, i64)> %17 = llvm.mlir.undef : !llvm.struct<(ptr<float>, i64)>
%18 = llvm.mlir.constant(4 : index) : !llvm.i64 %18 = llvm.mlir.constant(4 : index) : i64
%19 = llvm.mul %16, %18 : !llvm.i64 %19 = llvm.mul %16, %18 : i64
%20 = llvm.call @malloc(%19) : (!llvm.i64) -> !llvm.ptr<i8> %20 = llvm.call @malloc(%19) : (i64) -> !llvm.ptr<i8>
%21 = llvm.bitcast %20 : !llvm.ptr<i8> to !llvm.ptr<float> %21 = llvm.bitcast %20 : !llvm.ptr<i8> to !llvm.ptr<float>
%22 = llvm.insertvalue %21, %17[0] : !llvm.struct<(ptr<float>, i64)> %22 = llvm.insertvalue %21, %17[0] : !llvm.struct<(ptr<float>, i64)>
%23 = llvm.insertvalue %1, %22[1] : !llvm.struct<(ptr<float>, i64)> %23 = llvm.insertvalue %1, %22[1] : !llvm.struct<(ptr<float>, i64)>
// CHECK-NEXT: ret { float*, i64 } %{{[0-9]+}} // CHECK-NEXT: ret { float*, i64 } %{{[0-9]+}}
llvm.return %23 : !llvm.struct<(ptr<float>, i64)> llvm.return %23 : !llvm.struct<(ptr<float>, i64)>
} }
// CHECK-LABEL: define i64 @memref_dim({ float*, i64, i64 } {{%.*}}) // CHECK-LABEL: define i64 @memref_dim({ float*, i64, i64 } {{%.*}})
llvm.func @memref_dim(%arg0: !llvm.struct<(ptr<float>, i64, i64)>) -> !llvm.i64 { llvm.func @memref_dim(%arg0: !llvm.struct<(ptr<float>, i64, i64)>) -> i64 {
// Expecting this to create an LLVM constant. // Expecting this to create an LLVM constant.
%0 = llvm.mlir.constant(42 : index) : !llvm.i64 %0 = llvm.mlir.constant(42 : index) : i64
// CHECK-NEXT: %2 = extractvalue { float*, i64, i64 } %0, 1 // CHECK-NEXT: %2 = extractvalue { float*, i64, i64 } %0, 1
%1 = llvm.extractvalue %arg0[1] : !llvm.struct<(ptr<float>, i64, i64)> %1 = llvm.extractvalue %arg0[1] : !llvm.struct<(ptr<float>, i64, i64)>
// Expecting this to create an LLVM constant. // Expecting this to create an LLVM constant.
%2 = llvm.mlir.constant(10 : index) : !llvm.i64 %2 = llvm.mlir.constant(10 : index) : i64
// CHECK-NEXT: %3 = extractvalue { float*, i64, i64 } %0, 2 // CHECK-NEXT: %3 = extractvalue { float*, i64, i64 } %0, 2
%3 = llvm.extractvalue %arg0[2] : !llvm.struct<(ptr<float>, i64, i64)> %3 = llvm.extractvalue %arg0[2] : !llvm.struct<(ptr<float>, i64, i64)>
// Checking that the constant for d0 has been created. // Checking that the constant for d0 has been created.
// CHECK-NEXT: %4 = add i64 42, %2 // CHECK-NEXT: %4 = add i64 42, %2
%4 = llvm.add %0, %1 : !llvm.i64 %4 = llvm.add %0, %1 : i64
// Checking that the constant for d2 has been created. // Checking that the constant for d2 has been created.
// CHECK-NEXT: %5 = add i64 10, %3 // CHECK-NEXT: %5 = add i64 10, %3
%5 = llvm.add %2, %3 : !llvm.i64 %5 = llvm.add %2, %3 : i64
// CHECK-NEXT: %6 = add i64 %4, %5 // CHECK-NEXT: %6 = add i64 %4, %5
%6 = llvm.add %4, %5 : !llvm.i64 %6 = llvm.add %4, %5 : i64
// CHECK-NEXT: ret i64 %6 // CHECK-NEXT: ret i64 %6
llvm.return %6 : !llvm.i64 llvm.return %6 : i64
} }
llvm.func @get_i64() -> !llvm.i64 llvm.func @get_i64() -> i64
llvm.func @get_f32() -> !llvm.float llvm.func @get_f32() -> !llvm.float
llvm.func @get_memref() -> !llvm.struct<(ptr<float>, i64, i64)> llvm.func @get_memref() -> !llvm.struct<(ptr<float>, i64, i64)>
// CHECK-LABEL: define { i64, float, { float*, i64, i64 } } @multireturn() // CHECK-LABEL: define { i64, float, { float*, i64, i64 } } @multireturn()
llvm.func @multireturn() -> !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> { llvm.func @multireturn() -> !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> {
%0 = llvm.call @get_i64() : () -> !llvm.i64 %0 = llvm.call @get_i64() : () -> i64
%1 = llvm.call @get_f32() : () -> !llvm.float %1 = llvm.call @get_f32() : () -> !llvm.float
%2 = llvm.call @get_memref() : () -> !llvm.struct<(ptr<float>, i64, i64)> %2 = llvm.call @get_memref() : () -> !llvm.struct<(ptr<float>, i64, i64)>
// CHECK: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } undef, i64 %{{[0-9]+}}, 0 // CHECK: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } undef, i64 %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, float %{{[0-9]+}}, 1 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, float %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, { float*, i64, i64 } %{{[0-9]+}}, 2 // CHECK-NEXT: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, { float*, i64, i64 } %{{[0-9]+}}, 2
// CHECK-NEXT: ret { i64, float, { float*, i64, i64 } } %{{[0-9]+}} // CHECK-NEXT: ret { i64, float, { float*, i64, i64 } } %{{[0-9]+}}
%3 = llvm.mlir.undef : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %3 = llvm.mlir.undef : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%4 = llvm.insertvalue %0, %3[0] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %4 = llvm.insertvalue %0, %3[0] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%5 = llvm.insertvalue %1, %4[1] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %5 = llvm.insertvalue %1, %4[1] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%6 = llvm.insertvalue %2, %5[2] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %6 = llvm.insertvalue %2, %5[2] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
llvm.return %6 : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> llvm.return %6 : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
} }
// CHECK-LABEL: define void @multireturn_caller() // CHECK-LABEL: define void @multireturn_caller()
llvm.func @multireturn_caller() { llvm.func @multireturn_caller() {
// CHECK-NEXT: %1 = call { i64, float, { float*, i64, i64 } } @multireturn() // CHECK-NEXT: %1 = call { i64, float, { float*, i64, i64 } } @multireturn()
// CHECK-NEXT: [[ret0:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 0 // CHECK-NEXT: [[ret0:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 0
// CHECK-NEXT: [[ret1:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 1 // CHECK-NEXT: [[ret1:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 1
// CHECK-NEXT: [[ret2:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 2 // CHECK-NEXT: [[ret2:%[0-9]+]] = extractvalue { i64, float, { float*, i64, i64 } } %1, 2
%0 = llvm.call @multireturn() : () -> !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %0 = llvm.call @multireturn() : () -> !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%1 = llvm.extractvalue %0[0] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %1 = llvm.extractvalue %0[0] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%2 = llvm.extractvalue %0[1] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %2 = llvm.extractvalue %0[1] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%3 = llvm.extractvalue %0[2] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)> %3 = llvm.extractvalue %0[2] : !llvm.struct<(i64, float, struct<(ptr<float>, i64, i64)>)>
%4 = llvm.mlir.constant(42) : !llvm.i64 %4 = llvm.mlir.constant(42) : i64
// CHECK: add i64 [[ret0]], 42 // CHECK: add i64 [[ret0]], 42
%5 = llvm.add %1, %4 : !llvm.i64 %5 = llvm.add %1, %4 : i64
%6 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float %6 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
// CHECK: fadd float [[ret1]], 4.200000e+01 // CHECK: fadd float [[ret1]], 4.200000e+01
%7 = llvm.fadd %2, %6 : !llvm.float %7 = llvm.fadd %2, %6 : !llvm.float
%8 = llvm.mlir.constant(0 : index) : !llvm.i64 %8 = llvm.mlir.constant(0 : index) : i64
%9 = llvm.mlir.constant(42 : index) : !llvm.i64 %9 = llvm.mlir.constant(42 : index) : i64
// CHECK: extractvalue { float*, i64, i64 } [[ret2]], 0 // CHECK: extractvalue { float*, i64, i64 } [[ret2]], 0
%10 = llvm.extractvalue %3[1] : !llvm.struct<(ptr<float>, i64, i64)> %10 = llvm.extractvalue %3[1] : !llvm.struct<(ptr<float>, i64, i64)>
%11 = llvm.mlir.constant(10 : index) : !llvm.i64 %11 = llvm.mlir.constant(10 : index) : i64
%12 = llvm.extractvalue %3[2] : !llvm.struct<(ptr<float>, i64, i64)> %12 = llvm.extractvalue %3[2] : !llvm.struct<(ptr<float>, i64, i64)>
%13 = llvm.mul %8, %10 : !llvm.i64 %13 = llvm.mul %8, %10 : i64
%14 = llvm.add %13, %8 : !llvm.i64 %14 = llvm.add %13, %8 : i64
%15 = llvm.mul %14, %11 : !llvm.i64 %15 = llvm.mul %14, %11 : i64
%16 = llvm.add %15, %8 : !llvm.i64 %16 = llvm.add %15, %8 : i64
%17 = llvm.mul %16, %12 : !llvm.i64 %17 = llvm.mul %16, %12 : i64
%18 = llvm.add %17, %8 : !llvm.i64 %18 = llvm.add %17, %8 : i64
%19 = llvm.extractvalue %3[0] : !llvm.struct<(ptr<float>, i64, i64)> %19 = llvm.extractvalue %3[0] : !llvm.struct<(ptr<float>, i64, i64)>
%20 = llvm.getelementptr %19[%18] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %20 = llvm.getelementptr %19[%18] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
%21 = llvm.load %20 : !llvm.ptr<float> %21 = llvm.load %20 : !llvm.ptr<float>
llvm.return llvm.return
} }
// CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}}) // CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}})
llvm.func @vector_ops(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.vec<4 x i1>, %arg2: !llvm.vec<4 x i64>) -> !llvm.vec<4 x float> { llvm.func @vector_ops(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.vec<4 x i1>, %arg2: !llvm.vec<4 x i64>) -> !llvm.vec<4 x float> {
%0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm.vec<4 x float> %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm.vec<4 x float>
// CHECK-NEXT: %4 = fadd <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01> // CHECK-NEXT: %4 = fadd <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01>
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
// CHECK-LABEL: @vector_splat_nonzero // CHECK-LABEL: @vector_splat_nonzero
llvm.func @vector_splat_nonzero() -> !llvm.vec<4 x float> { llvm.func @vector_splat_nonzero() -> !llvm.vec<4 x float> {
// CHECK: ret <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00> // CHECK: ret <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
%0 = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : !llvm.vec<4 x float> %0 = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : !llvm.vec<4 x float>
llvm.return %0 : !llvm.vec<4 x float> llvm.return %0 : !llvm.vec<4 x float>
} }
// CHECK-LABEL: @ops // CHECK-LABEL: @ops
llvm.func @ops(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.i32, %arg3: !llvm.i32) -> !llvm.struct<(float, i32)> { llvm.func @ops(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: i32, %arg3: i32) -> !llvm.struct<(float, i32)> {
// CHECK-NEXT: fsub float %0, %1 // CHECK-NEXT: fsub float %0, %1
%0 = llvm.fsub %arg0, %arg1 : !llvm.float %0 = llvm.fsub %arg0, %arg1 : !llvm.float
// CHECK-NEXT: %6 = sub i32 %2, %3 // CHECK-NEXT: %6 = sub i32 %2, %3
%1 = llvm.sub %arg2, %arg3 : !llvm.i32 %1 = llvm.sub %arg2, %arg3 : i32
// CHECK-NEXT: %7 = icmp slt i32 %2, %6 // CHECK-NEXT: %7 = icmp slt i32 %2, %6
%2 = llvm.icmp "slt" %arg2, %1 : !llvm.i32 %2 = llvm.icmp "slt" %arg2, %1 : i32
// CHECK-NEXT: %8 = select i1 %7, i32 %2, i32 %6 // CHECK-NEXT: %8 = select i1 %7, i32 %2, i32 %6
%3 = llvm.select %2, %arg2, %1 : !llvm.i1, !llvm.i32 %3 = llvm.select %2, %arg2, %1 : i1, i32
// CHECK-NEXT: %9 = sdiv i32 %2, %3 // CHECK-NEXT: %9 = sdiv i32 %2, %3
%4 = llvm.sdiv %arg2, %arg3 : !llvm.i32 %4 = llvm.sdiv %arg2, %arg3 : i32
// CHECK-NEXT: %10 = udiv i32 %2, %3 // CHECK-NEXT: %10 = udiv i32 %2, %3
%5 = llvm.udiv %arg2, %arg3 : !llvm.i32 %5 = llvm.udiv %arg2, %arg3 : i32
// CHECK-NEXT: %11 = srem i32 %2, %3 // CHECK-NEXT: %11 = srem i32 %2, %3
%6 = llvm.srem %arg2, %arg3 : !llvm.i32 %6 = llvm.srem %arg2, %arg3 : i32
// CHECK-NEXT: %12 = urem i32 %2, %3 // CHECK-NEXT: %12 = urem i32 %2, %3
%7 = llvm.urem %arg2, %arg3 : !llvm.i32 %7 = llvm.urem %arg2, %arg3 : i32
%8 = llvm.mlir.undef : !llvm.struct<(float, i32)> %8 = llvm.mlir.undef : !llvm.struct<(float, i32)>
%9 = llvm.insertvalue %0, %8[0] : !llvm.struct<(float, i32)> %9 = llvm.insertvalue %0, %8[0] : !llvm.struct<(float, i32)>
%10 = llvm.insertvalue %3, %9[1] : !llvm.struct<(float, i32)> %10 = llvm.insertvalue %3, %9[1] : !llvm.struct<(float, i32)>
// CHECK: %15 = fdiv float %0, %1 // CHECK: %15 = fdiv float %0, %1
%11 = llvm.fdiv %arg0, %arg1 : !llvm.float %11 = llvm.fdiv %arg0, %arg1 : !llvm.float
// CHECK-NEXT: %16 = frem float %0, %1 // CHECK-NEXT: %16 = frem float %0, %1
%12 = llvm.frem %arg0, %arg1 : !llvm.float %12 = llvm.frem %arg0, %arg1 : !llvm.float
// CHECK-NEXT: %17 = and i32 %2, %3 // CHECK-NEXT: %17 = and i32 %2, %3
%13 = llvm.and %arg2, %arg3 : !llvm.i32 %13 = llvm.and %arg2, %arg3 : i32
// CHECK-NEXT: %18 = or i32 %2, %3 // CHECK-NEXT: %18 = or i32 %2, %3
%14 = llvm.or %arg2, %arg3 : !llvm.i32 %14 = llvm.or %arg2, %arg3 : i32
// CHECK-NEXT: %19 = xor i32 %2, %3 // CHECK-NEXT: %19 = xor i32 %2, %3
%15 = llvm.xor %arg2, %arg3 : !llvm.i32 %15 = llvm.xor %arg2, %arg3 : i32
// CHECK-NEXT: %20 = shl i32 %2, %3 // CHECK-NEXT: %20 = shl i32 %2, %3
%16 = llvm.shl %arg2, %arg3 : !llvm.i32 %16 = llvm.shl %arg2, %arg3 : i32
// CHECK-NEXT: %21 = lshr i32 %2, %3 // CHECK-NEXT: %21 = lshr i32 %2, %3
%17 = llvm.lshr %arg2, %arg3 : !llvm.i32 %17 = llvm.lshr %arg2, %arg3 : i32
// CHECK-NEXT: %22 = ashr i32 %2, %3 // CHECK-NEXT: %22 = ashr i32 %2, %3
%18 = llvm.ashr %arg2, %arg3 : !llvm.i32 %18 = llvm.ashr %arg2, %arg3 : i32
// CHECK-NEXT: fneg float %0 // CHECK-NEXT: fneg float %0
%19 = llvm.fneg %arg0 : !llvm.float %19 = llvm.fneg %arg0 : !llvm.float
llvm.return %10 : !llvm.struct<(float, i32)> llvm.return %10 : !llvm.struct<(float, i32)>
} }
// //
// Indirect function calls // Indirect function calls
// //
// CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}}) // CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}})
llvm.func @indirect_const_call(%arg0: !llvm.i64) { llvm.func @indirect_const_call(%arg0: i64) {
// CHECK-NEXT: call void @body(i64 %0) // CHECK-NEXT: call void @body(i64 %0)
%0 = llvm.mlir.addressof @body : !llvm.ptr<func<void (i64)>> %0 = llvm.mlir.addressof @body : !llvm.ptr<func<void (i64)>>
llvm.call %0(%arg0) : (!llvm.i64) -> () llvm.call %0(%arg0) : (i64) -> ()
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: define i32 @indirect_call(i32 (float)* {{%.*}}, float {{%.*}}) // CHECK-LABEL: define i32 @indirect_call(i32 (float)* {{%.*}}, float {{%.*}})
llvm.func @indirect_call(%arg0: !llvm.ptr<func<i32 (float)>>, %arg1: !llvm.float) -> !llvm.i32 { llvm.func @indirect_call(%arg0: !llvm.ptr<func<i32 (float)>>, %arg1: !llvm.float) -> i32 {
// CHECK-NEXT: %3 = call i32 %0(float %1) // CHECK-NEXT: %3 = call i32 %0(float %1)
%0 = llvm.call %arg0(%arg1) : (!llvm.float) -> !llvm.i32 %0 = llvm.call %arg0(%arg1) : (!llvm.float) -> i32
// CHECK-NEXT: ret i32 %3 // CHECK-NEXT: ret i32 %3
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
// //
// Check that we properly construct phi nodes in the blocks that have the same // Check that we properly construct phi nodes in the blocks that have the same
// predecessor more than once. // predecessor more than once.
// //
// CHECK-LABEL: define void @cond_br_arguments(i1 {{%.*}}, i1 {{%.*}}) // CHECK-LABEL: define void @cond_br_arguments(i1 {{%.*}}, i1 {{%.*}})
llvm.func @cond_br_arguments(%arg0: !llvm.i1, %arg1: !llvm.i1) { llvm.func @cond_br_arguments(%arg0: i1, %arg1: i1) {
// CHECK-NEXT: br i1 %0, label %3, label %5 // CHECK-NEXT: br i1 %0, label %3, label %5
llvm.cond_br %arg0, ^bb1(%arg0 : !llvm.i1), ^bb2 llvm.cond_br %arg0, ^bb1(%arg0 : i1), ^bb2
// CHECK: 3: // CHECK: 3:
// CHECK-NEXT: %4 = phi i1 [ %1, %5 ], [ %0, %2 ] // CHECK-NEXT: %4 = phi i1 [ %1, %5 ], [ %0, %2 ]
^bb1(%0 : !llvm.i1): ^bb1(%0 : i1):
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
llvm.return llvm.return
// CHECK: 5: // CHECK: 5:
^bb2: ^bb2:
// CHECK-NEXT: br label %3 // CHECK-NEXT: br label %3
llvm.br ^bb1(%arg1 : !llvm.i1) llvm.br ^bb1(%arg1 : i1)
} }
// CHECK-LABEL: define void @llvm_noalias(float* noalias {{%*.}}) // CHECK-LABEL: define void @llvm_noalias(float* noalias {{%*.}})
llvm.func @llvm_noalias(%arg0: !llvm.ptr<float> {llvm.noalias = true}) { llvm.func @llvm_noalias(%arg0: !llvm.ptr<float> {llvm.noalias = true}) {
llvm.return llvm.return
} }
// CHECK-LABEL: define void @llvm_align(float* align 4 {{%*.}}) // CHECK-LABEL: define void @llvm_align(float* align 4 {{%*.}})
llvm.func @llvm_align(%arg0: !llvm.ptr<float> {llvm.align = 4}) { llvm.func @llvm_align(%arg0: !llvm.ptr<float> {llvm.align = 4}) {
llvm.return llvm.return
} }
// CHECK-LABEL: @llvm_varargs(...) // CHECK-LABEL: @llvm_varargs(...)
llvm.func @llvm_varargs(...) llvm.func @llvm_varargs(...)
llvm.func @intpointerconversion(%arg0 : !llvm.i32) -> !llvm.i32 { llvm.func @intpointerconversion(%arg0 : i32) -> i32 {
// CHECK: %2 = inttoptr i32 %0 to i32* // CHECK: %2 = inttoptr i32 %0 to i32*
// CHECK-NEXT: %3 = ptrtoint i32* %2 to i32 // CHECK-NEXT: %3 = ptrtoint i32* %2 to i32
%1 = llvm.inttoptr %arg0 : !llvm.i32 to !llvm.ptr<i32> %1 = llvm.inttoptr %arg0 : i32 to !llvm.ptr<i32>
%2 = llvm.ptrtoint %1 : !llvm.ptr<i32> to !llvm.i32 %2 = llvm.ptrtoint %1 : !llvm.ptr<i32> to i32
llvm.return %2 : !llvm.i32 llvm.return %2 : i32
} }
llvm.func @fpconversion(%arg0 : !llvm.i32) -> !llvm.i32 { llvm.func @fpconversion(%arg0 : i32) -> i32 {
// CHECK: %2 = sitofp i32 %0 to float // CHECK: %2 = sitofp i32 %0 to float
// CHECK-NEXT: %3 = fptosi float %2 to i32 // CHECK-NEXT: %3 = fptosi float %2 to i32
// CHECK-NEXT: %4 = uitofp i32 %3 to float // CHECK-NEXT: %4 = uitofp i32 %3 to float
// CHECK-NEXT: %5 = fptoui float %4 to i32 // CHECK-NEXT: %5 = fptoui float %4 to i32
%1 = llvm.sitofp %arg0 : !llvm.i32 to !llvm.float %1 = llvm.sitofp %arg0 : i32 to !llvm.float
%2 = llvm.fptosi %1 : !llvm.float to !llvm.i32 %2 = llvm.fptosi %1 : !llvm.float to i32
%3 = llvm.uitofp %2 : !llvm.i32 to !llvm.float %3 = llvm.uitofp %2 : i32 to !llvm.float
%4 = llvm.fptoui %3 : !llvm.float to !llvm.i32 %4 = llvm.fptoui %3 : !llvm.float to i32
llvm.return %4 : !llvm.i32 llvm.return %4 : i32
} }
// CHECK-LABEL: @addrspace // CHECK-LABEL: @addrspace
llvm.func @addrspace(%arg0 : !llvm.ptr<i32>) -> !llvm.ptr<i32, 2> { llvm.func @addrspace(%arg0 : !llvm.ptr<i32>) -> !llvm.ptr<i32, 2> {
// CHECK: %2 = addrspacecast i32* %0 to i32 addrspace(2)* // CHECK: %2 = addrspacecast i32* %0 to i32 addrspace(2)*
%1 = llvm.addrspacecast %arg0 : !llvm.ptr<i32> to !llvm.ptr<i32, 2> %1 = llvm.addrspacecast %arg0 : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
llvm.return %1 : !llvm.ptr<i32, 2> llvm.return %1 : !llvm.ptr<i32, 2>
} }
Show All 38 Linesllvm.func @fcmp(%arg0: !llvm.float, %arg1: !llvm.float) {
%10 = llvm.fcmp "ult" %arg0, %arg1 : !llvm.float %10 = llvm.fcmp "ult" %arg0, %arg1 : !llvm.float
%11 = llvm.fcmp "ule" %arg0, %arg1 : !llvm.float %11 = llvm.fcmp "ule" %arg0, %arg1 : !llvm.float
%12 = llvm.fcmp "une" %arg0, %arg1 : !llvm.float %12 = llvm.fcmp "une" %arg0, %arg1 : !llvm.float
%13 = llvm.fcmp "uno" %arg0, %arg1 : !llvm.float %13 = llvm.fcmp "uno" %arg0, %arg1 : !llvm.float
llvm.return llvm.return
} }
// CHECK-LABEL: @vect // CHECK-LABEL: @vect
llvm.func @vect(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i32, %arg2: !llvm.float) { llvm.func @vect(%arg0: !llvm.vec<4 x float>, %arg1: i32, %arg2: !llvm.float) {
// CHECK-NEXT: extractelement <4 x float> {{.*}}, i32 // CHECK-NEXT: extractelement <4 x float> {{.*}}, i32
// CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i32 // CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i32
// CHECK-NEXT: shufflevector <4 x float> {{.*}}, <4 x float> {{.*}}, <5 x i32> <i32 0, i32 0, i32 0, i32 0, i32 7> // CHECK-NEXT: shufflevector <4 x float> {{.*}}, <4 x float> {{.*}}, <5 x i32> <i32 0, i32 0, i32 0, i32 0, i32 7>
%0 = llvm.extractelement %arg0[%arg1 : !llvm.i32] : !llvm.vec<4 x float> %0 = llvm.extractelement %arg0[%arg1 : i32] : !llvm.vec<4 x float>
%1 = llvm.insertelement %arg2, %arg0[%arg1 : !llvm.i32] : !llvm.vec<4 x float> %1 = llvm.insertelement %arg2, %arg0[%arg1 : i32] : !llvm.vec<4 x float>
%2 = llvm.shufflevector %arg0, %arg0 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float> %2 = llvm.shufflevector %arg0, %arg0 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
llvm.return llvm.return
} }
// CHECK-LABEL: @vect_i64idx // CHECK-LABEL: @vect_i64idx
llvm.func @vect_i64idx(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i64, %arg2: !llvm.float) { llvm.func @vect_i64idx(%arg0: !llvm.vec<4 x float>, %arg1: i64, %arg2: !llvm.float) {
// CHECK-NEXT: extractelement <4 x float> {{.*}}, i64 // CHECK-NEXT: extractelement <4 x float> {{.*}}, i64
// CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i64 // CHECK-NEXT: insertelement <4 x float> {{.*}}, float %2, i64
%0 = llvm.extractelement %arg0[%arg1 : !llvm.i64] : !llvm.vec<4 x float> %0 = llvm.extractelement %arg0[%arg1 : i64] : !llvm.vec<4 x float>
%1 = llvm.insertelement %arg2, %arg0[%arg1 : !llvm.i64] : !llvm.vec<4 x float> %1 = llvm.insertelement %arg2, %arg0[%arg1 : i64] : !llvm.vec<4 x float>
llvm.return llvm.return
} }
// CHECK-LABEL: @alloca // CHECK-LABEL: @alloca
llvm.func @alloca(%size : !llvm.i64) { llvm.func @alloca(%size : i64) {
// Alignment automatically set by the LLVM IR builder when alignment attribute // Alignment automatically set by the LLVM IR builder when alignment attribute
// is 0. // is 0.
// CHECK: alloca {{.*}} align 4 // CHECK: alloca {{.*}} align 4
llvm.alloca %size x !llvm.i32 {alignment = 0} : (!llvm.i64) -> (!llvm.ptr<i32>) llvm.alloca %size x i32 {alignment = 0} : (i64) -> (!llvm.ptr<i32>)
// CHECK-NEXT: alloca {{.*}} align 8 // CHECK-NEXT: alloca {{.*}} align 8
llvm.alloca %size x !llvm.i32 {alignment = 8} : (!llvm.i64) -> (!llvm.ptr<i32>) llvm.alloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr<i32>)
llvm.return llvm.return
} }
// CHECK-LABEL: @constants // CHECK-LABEL: @constants
llvm.func @constants() -> !llvm.vec<4 x float> { llvm.func @constants() -> !llvm.vec<4 x float> {
// CHECK: ret <4 x float> <float 4.2{{0*}}e+01, float 0.{{0*}}e+00, float 0.{{0*}}e+00, float 0.{{0*}}e+00> // CHECK: ret <4 x float> <float 4.2{{0*}}e+01, float 0.{{0*}}e+00, float 0.{{0*}}e+00, float 0.{{0*}}e+00>
%0 = llvm.mlir.constant(sparse<[[0]], [4.2e+01]> : vector<4xf32>) : !llvm.vec<4 x float> %0 = llvm.mlir.constant(sparse<[[0]], [4.2e+01]> : vector<4xf32>) : !llvm.vec<4 x float>
llvm.return %0 : !llvm.vec<4 x float> llvm.return %0 : !llvm.vec<4 x float>
} }
// CHECK-LABEL: @fp_casts // CHECK-LABEL: @fp_casts
llvm.func @fp_casts(%fp1 : !llvm.float, %fp2 : !llvm.double) -> !llvm.i16 { llvm.func @fp_casts(%fp1 : !llvm.float, %fp2 : !llvm.double) -> i16 {
// CHECK: fptrunc double {{.*}} to float // CHECK: fptrunc double {{.*}} to float
%a = llvm.fptrunc %fp2 : !llvm.double to !llvm.float %a = llvm.fptrunc %fp2 : !llvm.double to !llvm.float
// CHECK: fpext float {{.*}} to double // CHECK: fpext float {{.*}} to double
%b = llvm.fpext %fp1 : !llvm.float to !llvm.double %b = llvm.fpext %fp1 : !llvm.float to !llvm.double
// CHECK: fptosi double {{.*}} to i16 // CHECK: fptosi double {{.*}} to i16
%c = llvm.fptosi %b : !llvm.double to !llvm.i16 %c = llvm.fptosi %b : !llvm.double to i16
llvm.return %c : !llvm.i16 llvm.return %c : i16
} }
// CHECK-LABEL: @integer_extension_and_truncation // CHECK-LABEL: @integer_extension_and_truncation
llvm.func @integer_extension_and_truncation(%a : !llvm.i32) { llvm.func @integer_extension_and_truncation(%a : i32) {
// CHECK: sext i32 {{.*}} to i64 // CHECK: sext i32 {{.*}} to i64
// CHECK: zext i32 {{.*}} to i64 // CHECK: zext i32 {{.*}} to i64
// CHECK: trunc i32 {{.*}} to i16 // CHECK: trunc i32 {{.*}} to i16
%0 = llvm.sext %a : !llvm.i32 to !llvm.i64 %0 = llvm.sext %a : i32 to i64
%1 = llvm.zext %a : !llvm.i32 to !llvm.i64 %1 = llvm.zext %a : i32 to i64
%2 = llvm.trunc %a : !llvm.i32 to !llvm.i16 %2 = llvm.trunc %a : i32 to i16
llvm.return llvm.return
} }
// Check that the auxiliary `null` operation is converted into a `null` value. // Check that the auxiliary `null` operation is converted into a `null` value.
// CHECK-LABEL: @null // CHECK-LABEL: @null
llvm.func @null() -> !llvm.ptr<i32> { llvm.func @null() -> !llvm.ptr<i32> {
%0 = llvm.mlir.null : !llvm.ptr<i32> %0 = llvm.mlir.null : !llvm.ptr<i32>
// CHECK: ret i32* null // CHECK: ret i32* null
Show All 17 Linesllvm.func @elements_constant_3d_array() -> !llvm.array<2 x array<2 x array<2 x i32>>> {
// CHECK-SAME: [2 x [2 x i32]] {{\[}}[2 x i32] [i32 42, i32 43], [2 x i32] [i32 44, i32 45]]] // CHECK-SAME: [2 x [2 x i32]] {{\[}}[2 x i32] [i32 42, i32 43], [2 x i32] [i32 44, i32 45]]]
%0 = llvm.mlir.constant(dense<[[[1, 2], [3, 4]], [[42, 43], [44, 45]]]> : tensor<2x2x2xi32>) : !llvm.array<2 x array<2 x array<2 x i32>>> %0 = llvm.mlir.constant(dense<[[[1, 2], [3, 4]], [[42, 43], [44, 45]]]> : tensor<2x2x2xi32>) : !llvm.array<2 x array<2 x array<2 x i32>>>
llvm.return %0 : !llvm.array<2 x array<2 x array<2 x i32>>> llvm.return %0 : !llvm.array<2 x array<2 x array<2 x i32>>>
} }
// CHECK-LABEL: @atomicrmw // CHECK-LABEL: @atomicrmw
llvm.func @atomicrmw( llvm.func @atomicrmw(
%f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float, %f32_ptr : !llvm.ptr<float>, %f32 : !llvm.float,
%i32_ptr : !llvm.ptr<i32>, %i32 : !llvm.i32) { %i32_ptr : !llvm.ptr<i32>, %i32 : i32) {
// CHECK: atomicrmw fadd float* %{{.*}}, float %{{.*}} unordered // CHECK: atomicrmw fadd float* %{{.*}}, float %{{.*}} unordered
%0 = llvm.atomicrmw fadd %f32_ptr, %f32 unordered : !llvm.float %0 = llvm.atomicrmw fadd %f32_ptr, %f32 unordered : !llvm.float
// CHECK: atomicrmw fsub float* %{{.*}}, float %{{.*}} unordered // CHECK: atomicrmw fsub float* %{{.*}}, float %{{.*}} unordered
%1 = llvm.atomicrmw fsub %f32_ptr, %f32 unordered : !llvm.float %1 = llvm.atomicrmw fsub %f32_ptr, %f32 unordered : !llvm.float
// CHECK: atomicrmw xchg float* %{{.*}}, float %{{.*}} monotonic // CHECK: atomicrmw xchg float* %{{.*}}, float %{{.*}} monotonic
%2 = llvm.atomicrmw xchg %f32_ptr, %f32 monotonic : !llvm.float %2 = llvm.atomicrmw xchg %f32_ptr, %f32 monotonic : !llvm.float
// CHECK: atomicrmw add i32* %{{.*}}, i32 %{{.*}} acquire // CHECK: atomicrmw add i32* %{{.*}}, i32 %{{.*}} acquire
%3 = llvm.atomicrmw add %i32_ptr, %i32 acquire : !llvm.i32 %3 = llvm.atomicrmw add %i32_ptr, %i32 acquire : i32
// CHECK: atomicrmw sub i32* %{{.*}}, i32 %{{.*}} release // CHECK: atomicrmw sub i32* %{{.*}}, i32 %{{.*}} release
%4 = llvm.atomicrmw sub %i32_ptr, %i32 release : !llvm.i32 %4 = llvm.atomicrmw sub %i32_ptr, %i32 release : i32
// CHECK: atomicrmw and i32* %{{.*}}, i32 %{{.*}} acq_rel // CHECK: atomicrmw and i32* %{{.*}}, i32 %{{.*}} acq_rel
%5 = llvm.atomicrmw _and %i32_ptr, %i32 acq_rel : !llvm.i32 %5 = llvm.atomicrmw _and %i32_ptr, %i32 acq_rel : i32
// CHECK: atomicrmw nand i32* %{{.*}}, i32 %{{.*}} seq_cst // CHECK: atomicrmw nand i32* %{{.*}}, i32 %{{.*}} seq_cst
%6 = llvm.atomicrmw nand %i32_ptr, %i32 seq_cst : !llvm.i32 %6 = llvm.atomicrmw nand %i32_ptr, %i32 seq_cst : i32
// CHECK: atomicrmw or i32* %{{.*}}, i32 %{{.*}} unordered // CHECK: atomicrmw or i32* %{{.*}}, i32 %{{.*}} unordered
%7 = llvm.atomicrmw _or %i32_ptr, %i32 unordered : !llvm.i32 %7 = llvm.atomicrmw _or %i32_ptr, %i32 unordered : i32
// CHECK: atomicrmw xor i32* %{{.*}}, i32 %{{.*}} unordered // CHECK: atomicrmw xor i32* %{{.*}}, i32 %{{.*}} unordered
%8 = llvm.atomicrmw _xor %i32_ptr, %i32 unordered : !llvm.i32 %8 = llvm.atomicrmw _xor %i32_ptr, %i32 unordered : i32
// CHECK: atomicrmw max i32* %{{.*}}, i32 %{{.*}} unordered // CHECK: atomicrmw max i32* %{{.*}}, i32 %{{.*}} unordered
%9 = llvm.atomicrmw max %i32_ptr, %i32 unordered : !llvm.i32 %9 = llvm.atomicrmw max %i32_ptr, %i32 unordered : i32
// CHECK: atomicrmw min i32* %{{.*}}, i32 %{{.*}} unordered // CHECK: atomicrmw min i32* %{{.*}}, i32 %{{.*}} unordered
%10 = llvm.atomicrmw min %i32_ptr, %i32 unordered : !llvm.i32 %10 = llvm.atomicrmw min %i32_ptr, %i32 unordered : i32
// CHECK: atomicrmw umax i32* %{{.*}}, i32 %{{.*}} unordered // CHECK: atomicrmw umax i32* %{{.*}}, i32 %{{.*}} unordered
%11 = llvm.atomicrmw umax %i32_ptr, %i32 unordered : !llvm.i32 %11 = llvm.atomicrmw umax %i32_ptr, %i32 unordered : i32
// CHECK: atomicrmw umin i32* %{{.*}}, i32 %{{.*}} unordered // CHECK: atomicrmw umin i32* %{{.*}}, i32 %{{.*}} unordered
%12 = llvm.atomicrmw umin %i32_ptr, %i32 unordered : !llvm.i32 %12 = llvm.atomicrmw umin %i32_ptr, %i32 unordered : i32
llvm.return llvm.return
} }
// CHECK-LABEL: @cmpxchg // CHECK-LABEL: @cmpxchg
llvm.func @cmpxchg(%ptr : !llvm.ptr<i32>, %cmp : !llvm.i32, %val: !llvm.i32) { llvm.func @cmpxchg(%ptr : !llvm.ptr<i32>, %cmp : i32, %val: i32) {
// CHECK: cmpxchg i32* %{{.*}}, i32 %{{.*}}, i32 %{{.*}} acq_rel monotonic // CHECK: cmpxchg i32* %{{.*}}, i32 %{{.*}}, i32 %{{.*}} acq_rel monotonic
%0 = llvm.cmpxchg %ptr, %cmp, %val acq_rel monotonic : !llvm.i32 %0 = llvm.cmpxchg %ptr, %cmp, %val acq_rel monotonic : i32
// CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 0 // CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 0
%1 = llvm.extractvalue %0[0] : !llvm.struct<(i32, i1)> %1 = llvm.extractvalue %0[0] : !llvm.struct<(i32, i1)>
// CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 1 // CHECK: %{{[0-9]+}} = extractvalue { i32, i1 } %{{[0-9]+}}, 1
%2 = llvm.extractvalue %0[1] : !llvm.struct<(i32, i1)> %2 = llvm.extractvalue %0[1] : !llvm.struct<(i32, i1)>
llvm.return llvm.return
} }
llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8> llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8>
llvm.func @foo(!llvm.ptr<i8>) llvm.func @foo(!llvm.ptr<i8>)
llvm.func @bar(!llvm.ptr<i8>) -> !llvm.ptr<i8> llvm.func @bar(!llvm.ptr<i8>) -> !llvm.ptr<i8>
llvm.func @__gxx_personality_v0(...) -> !llvm.i32 llvm.func @__gxx_personality_v0(...) -> i32
// CHECK-LABEL: @invokeLandingpad // CHECK-LABEL: @invokeLandingpad
llvm.func @invokeLandingpad() -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } { llvm.func @invokeLandingpad() -> i32 attributes { personality = @__gxx_personality_v0 } {
// CHECK: %[[a1:[0-9]+]] = alloca i8 // CHECK: %[[a1:[0-9]+]] = alloca i8
%0 = llvm.mlir.constant(0 : i32) : !llvm.i32 %0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant("\01") : !llvm.array<1 x i8> %1 = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
%2 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>> %2 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
%3 = llvm.bitcast %2 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8> %3 = llvm.bitcast %2 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
%4 = llvm.mlir.null : !llvm.ptr<ptr<i8>> %4 = llvm.mlir.null : !llvm.ptr<ptr<i8>>
%5 = llvm.mlir.constant(1 : i32) : !llvm.i32 %5 = llvm.mlir.constant(1 : i32) : i32
%6 = llvm.alloca %5 x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8> %6 = llvm.alloca %5 x i8 : (i32) -> !llvm.ptr<i8>
// CHECK: invoke void @foo(i8* %[[a1]]) // CHECK: invoke void @foo(i8* %[[a1]])
// CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]] // CHECK-NEXT: to label %[[normal:[0-9]+]] unwind label %[[unwind:[0-9]+]]
llvm.invoke @foo(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> () llvm.invoke @foo(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> ()
// CHECK: [[unwind]]: // CHECK: [[unwind]]:
^bb1: ^bb1:
// CHECK: %{{[0-9]+}} = landingpad { i8*, i32 } // CHECK: %{{[0-9]+}} = landingpad { i8*, i32 }
// CHECK-NEXT: catch i8** null // CHECK-NEXT: catch i8** null
// CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*) // CHECK-NEXT: catch i8* bitcast (i8** @_ZTIi to i8*)
// CHECK-NEXT: filter [1 x i8] c"\01" // CHECK-NEXT: filter [1 x i8] c"\01"
%7 = llvm.landingpad (catch %4 : !llvm.ptr<ptr<i8>>) (catch %3 : !llvm.ptr<i8>) (filter %1 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)> %7 = llvm.landingpad (catch %4 : !llvm.ptr<ptr<i8>>) (catch %3 : !llvm.ptr<i8>) (filter %1 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
// CHECK: br label %[[final:[0-9]+]] // CHECK: br label %[[final:[0-9]+]]
llvm.br ^bb3 llvm.br ^bb3
// CHECK: [[normal]]: // CHECK: [[normal]]:
// CHECK-NEXT: ret i32 1 // CHECK-NEXT: ret i32 1
^bb2: // 2 preds: ^bb0, ^bb3 ^bb2: // 2 preds: ^bb0, ^bb3
llvm.return %5 : !llvm.i32 llvm.return %5 : i32
// CHECK: [[final]]: // CHECK: [[final]]:
// CHECK-NEXT: %{{[0-9]+}} = invoke i8* @bar(i8* %[[a1]]) // CHECK-NEXT: %{{[0-9]+}} = invoke i8* @bar(i8* %[[a1]])
// CHECK-NEXT: to label %[[normal]] unwind label %[[unwind]] // CHECK-NEXT: to label %[[normal]] unwind label %[[unwind]]
^bb3: // pred: ^bb1 ^bb3: // pred: ^bb1
%8 = llvm.invoke @bar(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8> %8 = llvm.invoke @bar(%6) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
} }
// CHECK-LABEL: @callFreezeOp // CHECK-LABEL: @callFreezeOp
llvm.func @callFreezeOp(%x : !llvm.i32) { llvm.func @callFreezeOp(%x : i32) {
// CHECK: freeze i32 %{{[0-9]+}} // CHECK: freeze i32 %{{[0-9]+}}
%0 = llvm.freeze %x : !llvm.i32 %0 = llvm.freeze %x : i32
%1 = llvm.mlir.undef : !llvm.i32 %1 = llvm.mlir.undef : i32
// CHECK: freeze i32 undef // CHECK: freeze i32 undef
%2 = llvm.freeze %1 : !llvm.i32 %2 = llvm.freeze %1 : i32
llvm.return llvm.return
} }
// CHECK-LABEL: @boolConstArg // CHECK-LABEL: @boolConstArg
llvm.func @boolConstArg() -> !llvm.i1 { llvm.func @boolConstArg() -> i1 {
// CHECK: ret i1 false // CHECK: ret i1 false
%0 = llvm.mlir.constant(true) : !llvm.i1 %0 = llvm.mlir.constant(true) : i1
%1 = llvm.mlir.constant(false) : !llvm.i1 %1 = llvm.mlir.constant(false) : i1
%2 = llvm.and %0, %1 : !llvm.i1 %2 = llvm.and %0, %1 : i1
llvm.return %2 : !llvm.i1 llvm.return %2 : i1
} }
// CHECK-LABEL: @callFenceInst // CHECK-LABEL: @callFenceInst
llvm.func @callFenceInst() { llvm.func @callFenceInst() {
// CHECK: fence syncscope("agent") release // CHECK: fence syncscope("agent") release
llvm.fence syncscope("agent") release llvm.fence syncscope("agent") release
// CHECK: fence release // CHECK: fence release
llvm.fence release llvm.fence release
Show All 33 Lines
llvm.mlir.global internal constant @taker_of_address() : !llvm.ptr<func<void ()>> { llvm.mlir.global internal constant @taker_of_address() : !llvm.ptr<func<void ()>> {
%0 = llvm.mlir.addressof @address_taken : !llvm.ptr<func<void ()>> %0 = llvm.mlir.addressof @address_taken : !llvm.ptr<func<void ()>>
llvm.return %0 : !llvm.ptr<func<void ()>> llvm.return %0 : !llvm.ptr<func<void ()>>
} }
// ----- // -----
// Check that branch weight attributes are exported properly as metadata. // Check that branch weight attributes are exported properly as metadata.
llvm.func @cond_br_weights(%cond : !llvm.i1, %arg0 : !llvm.i32, %arg1 : !llvm.i32) -> !llvm.i32 { llvm.func @cond_br_weights(%cond : i1, %arg0 : i32, %arg1 : i32) -> i32 {
// CHECK: !prof ![[NODE:[0-9]+]] // CHECK: !prof ![[NODE:[0-9]+]]
llvm.cond_br %cond weights(dense<[5, 10]> : vector<2xi32>), ^bb1, ^bb2 llvm.cond_br %cond weights(dense<[5, 10]> : vector<2xi32>), ^bb1, ^bb2
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %arg0 : !llvm.i32 llvm.return %arg0 : i32
^bb2: // pred: ^bb0 ^bb2: // pred: ^bb0
llvm.return %arg1 : !llvm.i32 llvm.return %arg1 : i32
} }
// CHECK: ![[NODE]] = !{!"branch_weights", i32 5, i32 10} // CHECK: ![[NODE]] = !{!"branch_weights", i32 5, i32 10}
// ----- // -----
llvm.func @volatile_store_and_load() { llvm.func @volatile_store_and_load() {
%val = llvm.mlir.constant(5 : i32) : !llvm.i32 %val = llvm.mlir.constant(5 : i32) : i32
%size = llvm.mlir.constant(1 : i64) : !llvm.i64 %size = llvm.mlir.constant(1 : i64) : i64
%0 = llvm.alloca %size x !llvm.i32 : (!llvm.i64) -> (!llvm.ptr<i32>) %0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr<i32>)
// CHECK: store volatile i32 5, i32* %{{.*}} // CHECK: store volatile i32 5, i32* %{{.*}}
llvm.store volatile %val, %0 : !llvm.ptr<i32> llvm.store volatile %val, %0 : !llvm.ptr<i32>
// CHECK: %{{.*}} = load volatile i32, i32* %{{.*}} // CHECK: %{{.*}} = load volatile i32, i32* %{{.*}}
%1 = llvm.load volatile %0: !llvm.ptr<i32> %1 = llvm.load volatile %0: !llvm.ptr<i32>
llvm.return llvm.return
} }
// ----- // -----
// Check that nontemporal attribute is exported as metadata node. // Check that nontemporal attribute is exported as metadata node.
llvm.func @nontemporal_store_and_load() { llvm.func @nontemporal_store_and_load() {
%val = llvm.mlir.constant(5 : i32) : !llvm.i32 %val = llvm.mlir.constant(5 : i32) : i32
%size = llvm.mlir.constant(1 : i64) : !llvm.i64 %size = llvm.mlir.constant(1 : i64) : i64
%0 = llvm.alloca %size x !llvm.i32 : (!llvm.i64) -> (!llvm.ptr<i32>) %0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr<i32>)
// CHECK: !nontemporal ![[NODE:[0-9]+]] // CHECK: !nontemporal ![[NODE:[0-9]+]]
llvm.store %val, %0 {nontemporal} : !llvm.ptr<i32> llvm.store %val, %0 {nontemporal} : !llvm.ptr<i32>
// CHECK: !nontemporal ![[NODE]] // CHECK: !nontemporal ![[NODE]]
%1 = llvm.load %0 {nontemporal} : !llvm.ptr<i32> %1 = llvm.load %0 {nontemporal} : !llvm.ptr<i32>
llvm.return llvm.return
} }
// CHECK: ![[NODE]] = !{i32 1} // CHECK: ![[NODE]] = !{i32 1}
Show All 27 Lines
// ----- // -----
// CHECK-NOT: "CodeView", i32 1 // CHECK-NOT: "CodeView", i32 1
module attributes {} {} module attributes {} {}
// ----- // -----
// CHECK-LABEL: @useInlineAsm // CHECK-LABEL: @useInlineAsm
llvm.func @useInlineAsm(%arg0: !llvm.i32) { llvm.func @useInlineAsm(%arg0: i32) {
// Constraints string is checked at LLVM InlineAsm instruction construction time. // Constraints string is checked at LLVM InlineAsm instruction construction time.
// So we can't just use "bar" everywhere, number of in/out arguments has to match. // So we can't just use "bar" everywhere, number of in/out arguments has to match.
// CHECK-NEXT: call void asm "foo", "r"(i32 {{.*}}), !dbg !7 // CHECK-NEXT: call void asm "foo", "r"(i32 {{.*}}), !dbg !7
llvm.inline_asm "foo", "r" %arg0 : (!llvm.i32) -> () llvm.inline_asm "foo", "r" %arg0 : (i32) -> ()
// CHECK-NEXT: call i8 asm "foo", "=r,r"(i32 {{.*}}), !dbg !9 // CHECK-NEXT: call i8 asm "foo", "=r,r"(i32 {{.*}}), !dbg !9
%0 = llvm.inline_asm "foo", "=r,r" %arg0 : (!llvm.i32) -> !llvm.i8 %0 = llvm.inline_asm "foo", "=r,r" %arg0 : (i32) -> i8
// CHECK-NEXT: call i8 asm "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !10 // CHECK-NEXT: call i8 asm "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !10
%1 = llvm.inline_asm "foo", "=r,r,r" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %1 = llvm.inline_asm "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: call i8 asm sideeffect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !11 // CHECK-NEXT: call i8 asm sideeffect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !11
%2 = llvm.inline_asm has_side_effects "foo", "=r,r,r" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %2 = llvm.inline_asm has_side_effects "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: call i8 asm alignstack "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !12 // CHECK-NEXT: call i8 asm alignstack "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !12
%3 = llvm.inline_asm is_align_stack "foo", "=r,r,r" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %3 = llvm.inline_asm is_align_stack "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: call i8 asm inteldialect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !13 // CHECK-NEXT: call i8 asm inteldialect "foo", "=r,r,r"(i32 {{.*}}, i32 {{.*}}), !dbg !13
%4 = llvm.inline_asm asm_dialect = "intel" "foo", "=r,r,r" %arg0, %arg0 : (!llvm.i32, !llvm.i32) -> !llvm.i8 %4 = llvm.inline_asm asm_dialect = "intel" "foo", "=r,r,r" %arg0, %arg0 : (i32, i32) -> i8
// CHECK-NEXT: call { i8, i8 } asm "foo", "=r,=r,r"(i32 {{.*}}), !dbg !14 // CHECK-NEXT: call { i8, i8 } asm "foo", "=r,=r,r"(i32 {{.*}}), !dbg !14
%5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (!llvm.i32) -> !llvm.struct<(i8, i8)> %5 = llvm.inline_asm "foo", "=r,=r,r" %arg0 : (i32) -> !llvm.struct<(i8, i8)>
llvm.return llvm.return
} }
// ----- // -----
llvm.func @fastmathFlagsFunc(!llvm.float) -> !llvm.float llvm.func @fastmathFlagsFunc(!llvm.float) -> !llvm.float
Show All 35 Lines// CHECK: {{.*}} = call fast float @fastmathFlagsFunc({{.*}})
%15 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<reassoc>} : (!llvm.float) -> (!llvm.float) %15 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<reassoc>} : (!llvm.float) -> (!llvm.float)
%16 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (!llvm.float) -> (!llvm.float) %16 = llvm.call @fastmathFlagsFunc(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (!llvm.float) -> (!llvm.float)
llvm.return llvm.return
} }
// ----- // -----
// CHECK-LABEL: @switch_args // CHECK-LABEL: @switch_args
llvm.func @switch_args(%arg0: !llvm.i32) { llvm.func @switch_args(%arg0: i32) {
%0 = llvm.mlir.constant(5 : i32) : !llvm.i32 %0 = llvm.mlir.constant(5 : i32) : i32
%1 = llvm.mlir.constant(7 : i32) : !llvm.i32 %1 = llvm.mlir.constant(7 : i32) : i32
%2 = llvm.mlir.constant(11 : i32) : !llvm.i32 %2 = llvm.mlir.constant(11 : i32) : i32
// CHECK: switch i32 %[[SWITCH_arg0:[0-9]+]], label %[[SWITCHDEFAULT_bb1:[0-9]+]] [ // CHECK: switch i32 %[[SWITCH_arg0:[0-9]+]], label %[[SWITCHDEFAULT_bb1:[0-9]+]] [
// CHECK-NEXT: i32 -1, label %[[SWITCHCASE_bb2:[0-9]+]] // CHECK-NEXT: i32 -1, label %[[SWITCHCASE_bb2:[0-9]+]]
// CHECK-NEXT: i32 1, label %[[SWITCHCASE_bb3:[0-9]+]] // CHECK-NEXT: i32 1, label %[[SWITCHCASE_bb3:[0-9]+]]
// CHECK-NEXT: ] // CHECK-NEXT: ]
llvm.switch %arg0, ^bb1 [ llvm.switch %arg0, ^bb1 [
-1: ^bb2(%0 : !llvm.i32), -1: ^bb2(%0 : i32),
1: ^bb3(%1, %2 : !llvm.i32, !llvm.i32) 1: ^bb3(%1, %2 : i32, i32)
] ]
// CHECK: [[SWITCHDEFAULT_bb1]]: // CHECK: [[SWITCHDEFAULT_bb1]]:
// CHECK-NEXT: ret i32 %[[SWITCH_arg0]] // CHECK-NEXT: ret i32 %[[SWITCH_arg0]]
^bb1: // pred: ^bb0 ^bb1: // pred: ^bb0
llvm.return %arg0 : !llvm.i32 llvm.return %arg0 : i32
// CHECK: [[SWITCHCASE_bb2]]: // CHECK: [[SWITCHCASE_bb2]]:
// CHECK-NEXT: phi i32 [ 5, %1 ] // CHECK-NEXT: phi i32 [ 5, %1 ]
// CHECK-NEXT: ret i32 // CHECK-NEXT: ret i32
^bb2(%3: !llvm.i32): // pred: ^bb0 ^bb2(%3: i32): // pred: ^bb0
llvm.return %1 : !llvm.i32 llvm.return %1 : i32
// CHECK: [[SWITCHCASE_bb3]]: // CHECK: [[SWITCHCASE_bb3]]:
// CHECK-NEXT: phi i32 [ 7, %1 ] // CHECK-NEXT: phi i32 [ 7, %1 ]
// CHECK-NEXT: phi i32 [ 11, %1 ] // CHECK-NEXT: phi i32 [ 11, %1 ]
// CHECK-NEXT: ret i32 // CHECK-NEXT: ret i32
^bb3(%4: !llvm.i32, %5: !llvm.i32): // pred: ^bb0 ^bb3(%4: i32, %5: i32): // pred: ^bb0
llvm.return %4 : !llvm.i32 llvm.return %4 : i32
} }
// CHECK-LABEL: @switch_weights // CHECK-LABEL: @switch_weights
llvm.func @switch_weights(%arg0: !llvm.i32) { llvm.func @switch_weights(%arg0: i32) {
%0 = llvm.mlir.constant(19 : i32) : !llvm.i32 %0 = llvm.mlir.constant(19 : i32) : i32
%1 = llvm.mlir.constant(23 : i32) : !llvm.i32 %1 = llvm.mlir.constant(23 : i32) : i32
%2 = llvm.mlir.constant(29 : i32) : !llvm.i32 %2 = llvm.mlir.constant(29 : i32) : i32
// CHECK: !prof ![[SWITCH_WEIGHT_NODE:[0-9]+]] // CHECK: !prof ![[SWITCH_WEIGHT_NODE:[0-9]+]]
llvm.switch %arg0, ^bb1(%0 : !llvm.i32) [ llvm.switch %arg0, ^bb1(%0 : i32) [
9: ^bb2(%1, %2 : !llvm.i32, !llvm.i32), 9: ^bb2(%1, %2 : i32, i32),
99: ^bb3 99: ^bb3
] {branch_weights = dense<[13, 17, 19]> : vector<3xi32>} ] {branch_weights = dense<[13, 17, 19]> : vector<3xi32>}
^bb1(%3: !llvm.i32): // pred: ^bb0 ^bb1(%3: i32): // pred: ^bb0
llvm.return %3 : !llvm.i32 llvm.return %3 : i32
^bb2(%4: !llvm.i32, %5: !llvm.i32): // pred: ^bb0 ^bb2(%4: i32, %5: i32): // pred: ^bb0
llvm.return %5 : !llvm.i32 llvm.return %5 : i32
^bb3: // pred: ^bb0 ^bb3: // pred: ^bb0
llvm.return %arg0 : !llvm.i32 llvm.return %arg0 : i32
} }
// CHECK: ![[SWITCH_WEIGHT_NODE]] = !{!"branch_weights", i32 13, i32 17, i32 19} // CHECK: ![[SWITCH_WEIGHT_NODE]] = !{!"branch_weights", i32 13, i32 17, i32 19}

mlir/test/Target/nvvmir.mlir

// RUN: mlir-translate -mlir-to-nvvmir %s | FileCheck %s // RUN: mlir-translate -mlir-to-nvvmir %s | FileCheck %s
llvm.func @nvvm_special_regs() -> !llvm.i32 { llvm.func @nvvm_special_regs() -> i32 {
// CHECK: %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x() // CHECK: %1 = call i32 @llvm.nvvm.read.ptx.sreg.tid.x()
%1 = nvvm.read.ptx.sreg.tid.x : !llvm.i32 %1 = nvvm.read.ptx.sreg.tid.x : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.tid.y() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.tid.y()
%2 = nvvm.read.ptx.sreg.tid.y : !llvm.i32 %2 = nvvm.read.ptx.sreg.tid.y : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.tid.z() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.tid.z()
%3 = nvvm.read.ptx.sreg.tid.z : !llvm.i32 %3 = nvvm.read.ptx.sreg.tid.z : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.x() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.x()
%4 = nvvm.read.ptx.sreg.ntid.x : !llvm.i32 %4 = nvvm.read.ptx.sreg.ntid.x : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.y() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.y()
%5 = nvvm.read.ptx.sreg.ntid.y : !llvm.i32 %5 = nvvm.read.ptx.sreg.ntid.y : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.z() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ntid.z()
%6 = nvvm.read.ptx.sreg.ntid.z : !llvm.i32 %6 = nvvm.read.ptx.sreg.ntid.z : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.x()
%7 = nvvm.read.ptx.sreg.ctaid.x : !llvm.i32 %7 = nvvm.read.ptx.sreg.ctaid.x : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.y() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.y()
%8 = nvvm.read.ptx.sreg.ctaid.y : !llvm.i32 %8 = nvvm.read.ptx.sreg.ctaid.y : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.z() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.ctaid.z()
%9 = nvvm.read.ptx.sreg.ctaid.z : !llvm.i32 %9 = nvvm.read.ptx.sreg.ctaid.z : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.x() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.x()
%10 = nvvm.read.ptx.sreg.nctaid.x : !llvm.i32 %10 = nvvm.read.ptx.sreg.nctaid.x : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.y() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.y()
%11 = nvvm.read.ptx.sreg.nctaid.y : !llvm.i32 %11 = nvvm.read.ptx.sreg.nctaid.y : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.z() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.nctaid.z()
%12 = nvvm.read.ptx.sreg.nctaid.z : !llvm.i32 %12 = nvvm.read.ptx.sreg.nctaid.z : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.warpsize() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.warpsize()
%13 = nvvm.read.ptx.sreg.warpsize : !llvm.i32 %13 = nvvm.read.ptx.sreg.warpsize : i32
// CHECK: call i32 @llvm.nvvm.read.ptx.sreg.laneid() // CHECK: call i32 @llvm.nvvm.read.ptx.sreg.laneid()
%14 = nvvm.read.ptx.sreg.laneid : !llvm.i32 %14 = nvvm.read.ptx.sreg.laneid : i32
llvm.return %1 : !llvm.i32 llvm.return %1 : i32
} }
llvm.func @llvm.nvvm.barrier0() { llvm.func @llvm.nvvm.barrier0() {
// CHECK: call void @llvm.nvvm.barrier0() // CHECK: call void @llvm.nvvm.barrier0()
nvvm.barrier0 nvvm.barrier0
llvm.return llvm.return
} }
llvm.func @nvvm_shfl( llvm.func @nvvm_shfl(
%0 : !llvm.i32, %1 : !llvm.i32, %2 : !llvm.i32, %0 : i32, %1 : i32, %2 : i32,
%3 : !llvm.i32, %4 : !llvm.float) -> !llvm.i32 { %3 : i32, %4 : !llvm.float) -> i32 {
// CHECK: call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call i32 @llvm.nvvm.shfl.sync.bfly.i32(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%6 = nvvm.shfl.sync.bfly %0, %3, %1, %2 : !llvm.i32 %6 = nvvm.shfl.sync.bfly %0, %3, %1, %2 : i32
// CHECK: call float @llvm.nvvm.shfl.sync.bfly.f32(i32 %{{.*}}, float %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call float @llvm.nvvm.shfl.sync.bfly.f32(i32 %{{.*}}, float %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%7 = nvvm.shfl.sync.bfly %0, %4, %1, %2 : !llvm.float %7 = nvvm.shfl.sync.bfly %0, %4, %1, %2 : !llvm.float
llvm.return %6 : !llvm.i32 llvm.return %6 : i32
} }
llvm.func @nvvm_shfl_pred( llvm.func @nvvm_shfl_pred(
%0 : !llvm.i32, %1 : !llvm.i32, %2 : !llvm.i32, %0 : i32, %1 : i32, %2 : i32,
%3 : !llvm.i32, %4 : !llvm.float) -> !llvm.struct<(i32, i1)> { %3 : i32, %4 : !llvm.float) -> !llvm.struct<(i32, i1)> {
// CHECK: call { i32, i1 } @llvm.nvvm.shfl.sync.bfly.i32p(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call { i32, i1 } @llvm.nvvm.shfl.sync.bfly.i32p(i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%6 = nvvm.shfl.sync.bfly %0, %3, %1, %2 {return_value_and_is_valid} : !llvm.struct<(i32, i1)> %6 = nvvm.shfl.sync.bfly %0, %3, %1, %2 {return_value_and_is_valid} : !llvm.struct<(i32, i1)>
// CHECK: call { float, i1 } @llvm.nvvm.shfl.sync.bfly.f32p(i32 %{{.*}}, float %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call { float, i1 } @llvm.nvvm.shfl.sync.bfly.f32p(i32 %{{.*}}, float %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%7 = nvvm.shfl.sync.bfly %0, %4, %1, %2 {return_value_and_is_valid} : !llvm.struct<(float, i1)> %7 = nvvm.shfl.sync.bfly %0, %4, %1, %2 {return_value_and_is_valid} : !llvm.struct<(float, i1)>
llvm.return %6 : !llvm.struct<(i32, i1)> llvm.return %6 : !llvm.struct<(i32, i1)>
} }
llvm.func @nvvm_vote(%0 : !llvm.i32, %1 : !llvm.i1) -> !llvm.i32 { llvm.func @nvvm_vote(%0 : i32, %1 : i1) -> i32 {
// CHECK: call i32 @llvm.nvvm.vote.ballot.sync(i32 %{{.*}}, i1 %{{.*}}) // CHECK: call i32 @llvm.nvvm.vote.ballot.sync(i32 %{{.*}}, i1 %{{.*}})
%3 = nvvm.vote.ballot.sync %0, %1 : !llvm.i32 %3 = nvvm.vote.ballot.sync %0, %1 : i32
llvm.return %3 : !llvm.i32 llvm.return %3 : i32
} }
llvm.func @nvvm_mma(%a0 : !llvm.vec<2 x half>, %a1 : !llvm.vec<2 x half>, llvm.func @nvvm_mma(%a0 : !llvm.vec<2 x half>, %a1 : !llvm.vec<2 x half>,
%b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>, %b0 : !llvm.vec<2 x half>, %b1 : !llvm.vec<2 x half>,
%c0 : !llvm.float, %c1 : !llvm.float, %c2 : !llvm.float, %c3 : !llvm.float, %c0 : !llvm.float, %c1 : !llvm.float, %c2 : !llvm.float, %c3 : !llvm.float,
%c4 : !llvm.float, %c5 : !llvm.float, %c6 : !llvm.float, %c7 : !llvm.float) { %c4 : !llvm.float, %c5 : !llvm.float, %c6 : !llvm.float, %c7 : !llvm.float) {
// CHECK: call { float, float, float, float, float, float, float, float } @llvm.nvvm.mma.m8n8k4.row.col.f32.f32 // CHECK: call { float, float, float, float, float, float, float, float } @llvm.nvvm.mma.m8n8k4.row.col.f32.f32
%0 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="row", blayout="col"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, float, float, float, float, float, float, float)> %0 = nvvm.mma.sync %a0, %a1, %b0, %b1, %c0, %c1, %c2, %c3, %c4, %c5, %c6, %c7 {alayout="row", blayout="col"} : (!llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.vec<2 x half>, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float, !llvm.float) -> !llvm.struct<(float, float, float, float, float, float, float, float)>
Show All 12 Lines

mlir/test/Target/openmp-llvm.mlir

Show All 13 Linesllvm.func @test_stand_alone_directives() {
// CHECK-NEXT: [[RET_VAL:%.*]] = call i32 @__kmpc_omp_taskyield(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD2]], i32 0) // CHECK-NEXT: [[RET_VAL:%.*]] = call i32 @__kmpc_omp_taskyield(%struct.ident_t* @{{[0-9]+}}, i32 [[OMP_THREAD2]], i32 0)
omp.taskyield omp.taskyield
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: define void @test_flush_construct(i32 %0) // CHECK-LABEL: define void @test_flush_construct(i32 %0)
llvm.func @test_flush_construct(%arg0: !llvm.i32) { llvm.func @test_flush_construct(%arg0: i32) {
// CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}} // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
omp.flush omp.flush
// CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}} // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
omp.flush (%arg0 : !llvm.i32) omp.flush (%arg0 : i32)
// CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}} // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
omp.flush (%arg0, %arg0 : !llvm.i32, !llvm.i32) omp.flush (%arg0, %arg0 : i32, i32)
%0 = llvm.mlir.constant(1 : i64) : !llvm.i64 %0 = llvm.mlir.constant(1 : i64) : i64
// CHECK: alloca {{.*}} align 4 // CHECK: alloca {{.*}} align 4
%1 = llvm.alloca %0 x !llvm.i32 {in_type = i32, name = "a"} : (!llvm.i64) -> !llvm.ptr<i32> %1 = llvm.alloca %0 x i32 {in_type = i32, name = "a"} : (i64) -> !llvm.ptr<i32>
// CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}} // CHECK: call void @__kmpc_flush(%struct.ident_t* @{{[0-9]+}}
omp.flush omp.flush
// CHECK: load i32, i32* // CHECK: load i32, i32*
%2 = llvm.load %1 : !llvm.ptr<i32> %2 = llvm.load %1 : !llvm.ptr<i32>
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
llvm.return llvm.return
} }
// CHECK-LABEL: define void @test_omp_parallel_1() // CHECK-LABEL: define void @test_omp_parallel_1()
llvm.func @test_omp_parallel_1() -> () { llvm.func @test_omp_parallel_1() -> () {
// CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_1:.*]] to {{.*}} // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_1:.*]] to {{.*}}
omp.parallel { omp.parallel {
omp.barrier omp.barrier
omp.terminator omp.terminator
} }
llvm.return llvm.return
} }
// CHECK: define internal void @[[OMP_OUTLINED_FN_1]] // CHECK: define internal void @[[OMP_OUTLINED_FN_1]]
// CHECK: call void @__kmpc_barrier // CHECK: call void @__kmpc_barrier
llvm.func @body(!llvm.i64) llvm.func @body(i64)
// CHECK-LABEL: define void @test_omp_parallel_2() // CHECK-LABEL: define void @test_omp_parallel_2()
llvm.func @test_omp_parallel_2() -> () { llvm.func @test_omp_parallel_2() -> () {
// CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_2:.*]] to {{.*}} // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_2:.*]] to {{.*}}
omp.parallel { omp.parallel {
^bb0: ^bb0:
%0 = llvm.mlir.constant(1 : index) : !llvm.i64 %0 = llvm.mlir.constant(1 : index) : i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64 %1 = llvm.mlir.constant(42 : index) : i64
llvm.call @body(%0) : (!llvm.i64) -> () llvm.call @body(%0) : (i64) -> ()
llvm.call @body(%1) : (!llvm.i64) -> () llvm.call @body(%1) : (i64) -> ()
llvm.br ^bb1 llvm.br ^bb1
^bb1: ^bb1:
%2 = llvm.add %0, %1 : !llvm.i64 %2 = llvm.add %0, %1 : i64
llvm.call @body(%2) : (!llvm.i64) -> () llvm.call @body(%2) : (i64) -> ()
omp.terminator omp.terminator
} }
llvm.return llvm.return
} }
// CHECK: define internal void @[[OMP_OUTLINED_FN_2]] // CHECK: define internal void @[[OMP_OUTLINED_FN_2]]
// CHECK-LABEL: omp.par.region: // CHECK-LABEL: omp.par.region:
// CHECK: br label %omp.par.region1 // CHECK: br label %omp.par.region1
// CHECK-LABEL: omp.par.region1: // CHECK-LABEL: omp.par.region1:
// CHECK: call void @body(i64 1) // CHECK: call void @body(i64 1)
// CHECK: call void @body(i64 42) // CHECK: call void @body(i64 42)
// CHECK: br label %omp.par.region2 // CHECK: br label %omp.par.region2
// CHECK-LABEL: omp.par.region2: // CHECK-LABEL: omp.par.region2:
// CHECK: call void @body(i64 43) // CHECK: call void @body(i64 43)
// CHECK: br label %omp.par.pre_finalize // CHECK: br label %omp.par.pre_finalize
// CHECK: define void @test_omp_parallel_num_threads_1(i32 %[[NUM_THREADS_VAR_1:.*]]) // CHECK: define void @test_omp_parallel_num_threads_1(i32 %[[NUM_THREADS_VAR_1:.*]])
llvm.func @test_omp_parallel_num_threads_1(%arg0: !llvm.i32) -> () { llvm.func @test_omp_parallel_num_threads_1(%arg0: i32) -> () {
// CHECK: %[[GTN_NUM_THREADS_VAR_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_1:.*]]) // CHECK: %[[GTN_NUM_THREADS_VAR_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_1:.*]])
// CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_1]], i32 %[[GTN_NUM_THREADS_VAR_1]], i32 %[[NUM_THREADS_VAR_1]]) // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_1]], i32 %[[GTN_NUM_THREADS_VAR_1]], i32 %[[NUM_THREADS_VAR_1]])
// CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_1:.*]] to {{.*}} // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_1:.*]] to {{.*}}
omp.parallel num_threads(%arg0: !llvm.i32) { omp.parallel num_threads(%arg0: i32) {
omp.barrier omp.barrier
omp.terminator omp.terminator
} }
llvm.return llvm.return
} }
// CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_1]] // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_1]]
// CHECK: call void @__kmpc_barrier // CHECK: call void @__kmpc_barrier
// CHECK: define void @test_omp_parallel_num_threads_2() // CHECK: define void @test_omp_parallel_num_threads_2()
llvm.func @test_omp_parallel_num_threads_2() -> () { llvm.func @test_omp_parallel_num_threads_2() -> () {
%0 = llvm.mlir.constant(4 : index) : !llvm.i32 %0 = llvm.mlir.constant(4 : index) : i32
// CHECK: %[[GTN_NUM_THREADS_VAR_2:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_2:.*]]) // CHECK: %[[GTN_NUM_THREADS_VAR_2:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_2:.*]])
// CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_2]], i32 %[[GTN_NUM_THREADS_VAR_2]], i32 4) // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_2]], i32 %[[GTN_NUM_THREADS_VAR_2]], i32 4)
// CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_2:.*]] to {{.*}} // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_2:.*]] to {{.*}}
omp.parallel num_threads(%0: !llvm.i32) { omp.parallel num_threads(%0: i32) {
omp.barrier omp.barrier
omp.terminator omp.terminator
} }
llvm.return llvm.return
} }
// CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_2]] // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_2]]
// CHECK: call void @__kmpc_barrier // CHECK: call void @__kmpc_barrier
// CHECK: define void @test_omp_parallel_num_threads_3() // CHECK: define void @test_omp_parallel_num_threads_3()
llvm.func @test_omp_parallel_num_threads_3() -> () { llvm.func @test_omp_parallel_num_threads_3() -> () {
%0 = llvm.mlir.constant(4 : index) : !llvm.i32 %0 = llvm.mlir.constant(4 : index) : i32
// CHECK: %[[GTN_NUM_THREADS_VAR_3_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_3_1:.*]]) // CHECK: %[[GTN_NUM_THREADS_VAR_3_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_3_1:.*]])
// CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_3_1]], i32 %[[GTN_NUM_THREADS_VAR_3_1]], i32 4) // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_3_1]], i32 %[[GTN_NUM_THREADS_VAR_3_1]], i32 4)
// CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_3_1:.*]] to {{.*}} // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_3_1:.*]] to {{.*}}
omp.parallel num_threads(%0: !llvm.i32) { omp.parallel num_threads(%0: i32) {
omp.barrier omp.barrier
omp.terminator omp.terminator
} }
%1 = llvm.mlir.constant(8 : index) : !llvm.i32 %1 = llvm.mlir.constant(8 : index) : i32
// CHECK: %[[GTN_NUM_THREADS_VAR_3_2:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_3_2:.*]]) // CHECK: %[[GTN_NUM_THREADS_VAR_3_2:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[GTN_SI_VAR_3_2:.*]])
// CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_3_2]], i32 %[[GTN_NUM_THREADS_VAR_3_2]], i32 8) // CHECK: call void @__kmpc_push_num_threads(%struct.ident_t* @[[GTN_SI_VAR_3_2]], i32 %[[GTN_NUM_THREADS_VAR_3_2]], i32 8)
// CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_3_2:.*]] to {{.*}} // CHECK: call void{{.*}}@__kmpc_fork_call{{.*}}@[[OMP_OUTLINED_FN_NUM_THREADS_3_2:.*]] to {{.*}}
omp.parallel num_threads(%1: !llvm.i32) { omp.parallel num_threads(%1: i32) {
omp.barrier omp.barrier
omp.terminator omp.terminator
} }
llvm.return llvm.return
} }
// CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_2]] // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_2]]
// CHECK: call void @__kmpc_barrier // CHECK: call void @__kmpc_barrier
// CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_1]] // CHECK: define internal void @[[OMP_OUTLINED_FN_NUM_THREADS_3_1]]
// CHECK: call void @__kmpc_barrier // CHECK: call void @__kmpc_barrier
// CHECK: define void @test_omp_parallel_if_1(i32 %[[IF_VAR_1:.*]]) // CHECK: define void @test_omp_parallel_if_1(i32 %[[IF_VAR_1:.*]])
llvm.func @test_omp_parallel_if_1(%arg0: !llvm.i32) -> () { llvm.func @test_omp_parallel_if_1(%arg0: i32) -> () {
// CHECK: %[[IF_COND_VAR_1:.*]] = icmp slt i32 %[[IF_VAR_1]], 0 // CHECK: %[[IF_COND_VAR_1:.*]] = icmp slt i32 %[[IF_VAR_1]], 0
%0 = llvm.mlir.constant(0 : index) : !llvm.i32 %0 = llvm.mlir.constant(0 : index) : i32
%1 = llvm.icmp "slt" %arg0, %0 : !llvm.i32 %1 = llvm.icmp "slt" %arg0, %0 : i32
// CHECK: %[[GTN_IF_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[SI_VAR_IF_1:.*]]) // CHECK: %[[GTN_IF_1:.*]] = call i32 @__kmpc_global_thread_num(%struct.ident_t* @[[SI_VAR_IF_1:.*]])
// CHECK: br i1 %[[IF_COND_VAR_1]], label %[[IF_COND_TRUE_BLOCK_1:.*]], label %[[IF_COND_FALSE_BLOCK_1:.*]] // CHECK: br i1 %[[IF_COND_VAR_1]], label %[[IF_COND_TRUE_BLOCK_1:.*]], label %[[IF_COND_FALSE_BLOCK_1:.*]]
// CHECK: [[IF_COND_TRUE_BLOCK_1]]: // CHECK: [[IF_COND_TRUE_BLOCK_1]]:
// CHECK: br label %[[OUTLINED_CALL_IF_BLOCK_1:.*]] // CHECK: br label %[[OUTLINED_CALL_IF_BLOCK_1:.*]]
// CHECK: [[OUTLINED_CALL_IF_BLOCK_1]]: // CHECK: [[OUTLINED_CALL_IF_BLOCK_1]]:
// CHECK: call void {{.*}} @__kmpc_fork_call(%struct.ident_t* @[[SI_VAR_IF_1]], {{.*}} @[[OMP_OUTLINED_FN_IF_1:.*]] to void // CHECK: call void {{.*}} @__kmpc_fork_call(%struct.ident_t* @[[SI_VAR_IF_1]], {{.*}} @[[OMP_OUTLINED_FN_IF_1:.*]] to void
// CHECK: br label %[[OUTLINED_EXIT_IF_1:.*]] // CHECK: br label %[[OUTLINED_EXIT_IF_1:.*]]
// CHECK: [[OUTLINED_EXIT_IF_1]]: // CHECK: [[OUTLINED_EXIT_IF_1]]:
// CHECK: br label %[[OUTLINED_EXIT_IF_2:.*]] // CHECK: br label %[[OUTLINED_EXIT_IF_2:.*]]
// CHECK: [[OUTLINED_EXIT_IF_2]]: // CHECK: [[OUTLINED_EXIT_IF_2]]:
// CHECK: br label %[[RETURN_BLOCK_IF_1:.*]] // CHECK: br label %[[RETURN_BLOCK_IF_1:.*]]
// CHECK: [[IF_COND_FALSE_BLOCK_1]]: // CHECK: [[IF_COND_FALSE_BLOCK_1]]:
// CHECK: call void @__kmpc_serialized_parallel(%struct.ident_t* @[[SI_VAR_IF_1]], i32 %[[GTN_IF_1]]) // CHECK: call void @__kmpc_serialized_parallel(%struct.ident_t* @[[SI_VAR_IF_1]], i32 %[[GTN_IF_1]])
// CHECK: call void @[[OMP_OUTLINED_FN_IF_1]] // CHECK: call void @[[OMP_OUTLINED_FN_IF_1]]
// CHECK: call void @__kmpc_end_serialized_parallel(%struct.ident_t* @[[SI_VAR_IF_1]], i32 %[[GTN_IF_1]]) // CHECK: call void @__kmpc_end_serialized_parallel(%struct.ident_t* @[[SI_VAR_IF_1]], i32 %[[GTN_IF_1]])
// CHECK: br label %[[RETURN_BLOCK_IF_1]] // CHECK: br label %[[RETURN_BLOCK_IF_1]]
omp.parallel if(%1 : !llvm.i1) { omp.parallel if(%1 : i1) {
omp.barrier omp.barrier
omp.terminator omp.terminator
} }
// CHECK: [[RETURN_BLOCK_IF_1]]: // CHECK: [[RETURN_BLOCK_IF_1]]:
// CHECK: ret void // CHECK: ret void
llvm.return llvm.return
} }
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
// CHECK: @[[$parallel_loc:.*]] = private unnamed_addr constant {{.*}} c";LLVMDialectModule;wsloop_simple;{{[0-9]+}};{{[0-9]+}};;\00" // CHECK: @[[$parallel_loc:.*]] = private unnamed_addr constant {{.*}} c";LLVMDialectModule;wsloop_simple;{{[0-9]+}};{{[0-9]+}};;\00"
// CHECK: @[[$parallel_loc_struct:.*]] = private unnamed_addr constant %struct.ident_t {{.*}} @[[$parallel_loc]], {{.*}} // CHECK: @[[$parallel_loc_struct:.*]] = private unnamed_addr constant %struct.ident_t {{.*}} @[[$parallel_loc]], {{.*}}
// CHECK: @[[$wsloop_loc:.*]] = private unnamed_addr constant {{.*}} c";LLVMDialectModule;wsloop_simple;{{[0-9]+}};{{[0-9]+}};;\00" // CHECK: @[[$wsloop_loc:.*]] = private unnamed_addr constant {{.*}} c";LLVMDialectModule;wsloop_simple;{{[0-9]+}};{{[0-9]+}};;\00"
// CHECK: @[[$wsloop_loc_struct:.*]] = private unnamed_addr constant %struct.ident_t {{.*}} @[[$wsloop_loc]], {{.*}} // CHECK: @[[$wsloop_loc_struct:.*]] = private unnamed_addr constant %struct.ident_t {{.*}} @[[$wsloop_loc]], {{.*}}
// CHECK-LABEL: @wsloop_simple // CHECK-LABEL: @wsloop_simple
llvm.func @wsloop_simple(%arg0: !llvm.ptr<float>) { llvm.func @wsloop_simple(%arg0: !llvm.ptr<float>) {
%0 = llvm.mlir.constant(42 : index) : !llvm.i64 %0 = llvm.mlir.constant(42 : index) : i64
%1 = llvm.mlir.constant(10 : index) : !llvm.i64 %1 = llvm.mlir.constant(10 : index) : i64
%2 = llvm.mlir.constant(1 : index) : !llvm.i64 %2 = llvm.mlir.constant(1 : index) : i64
omp.parallel { omp.parallel {
"omp.wsloop"(%1, %0, %2) ( { "omp.wsloop"(%1, %0, %2) ( {
^bb0(%arg1: !llvm.i64): ^bb0(%arg1: i64):
// The form of the emitted IR is controlled by OpenMPIRBuilder and // The form of the emitted IR is controlled by OpenMPIRBuilder and
// tested there. Just check that the right functions are called. // tested there. Just check that the right functions are called.
// CHECK: call i32 @__kmpc_global_thread_num // CHECK: call i32 @__kmpc_global_thread_num
// CHECK: call void @__kmpc_for_static_init_{{.*}}(%struct.ident_t* @[[$wsloop_loc_struct]], // CHECK: call void @__kmpc_for_static_init_{{.*}}(%struct.ident_t* @[[$wsloop_loc_struct]],
%3 = llvm.mlir.constant(2.000000e+00 : f32) : !llvm.float %3 = llvm.mlir.constant(2.000000e+00 : f32) : !llvm.float
%4 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %4 = llvm.getelementptr %arg0[%arg1] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %3, %4 : !llvm.ptr<float> llvm.store %3, %4 : !llvm.ptr<float>
omp.yield omp.yield
// CHECK: call void @__kmpc_for_static_fini(%struct.ident_t* @[[$wsloop_loc_struct]], // CHECK: call void @__kmpc_for_static_fini(%struct.ident_t* @[[$wsloop_loc_struct]],
}) {operand_segment_sizes = dense<[1, 1, 1, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (!llvm.i64, !llvm.i64, !llvm.i64) -> () }) {operand_segment_sizes = dense<[1, 1, 1, 0, 0, 0, 0, 0, 0]> : vector<9xi32>} : (i64, i64, i64) -> ()
omp.terminator omp.terminator
} }
llvm.return llvm.return
} }

mlir/test/Target/rocdl.mlir

// RUN: mlir-translate -mlir-to-rocdlir %s | FileCheck %s // RUN: mlir-translate -mlir-to-rocdlir %s | FileCheck %s
llvm.func @rocdl_special_regs() -> !llvm.i32 { llvm.func @rocdl_special_regs() -> i32 {
// CHECK-LABEL: rocdl_special_regs // CHECK-LABEL: rocdl_special_regs
// CHECK: call i32 @llvm.amdgcn.workitem.id.x() // CHECK: call i32 @llvm.amdgcn.workitem.id.x()
%1 = rocdl.workitem.id.x : !llvm.i32 %1 = rocdl.workitem.id.x : i32
// CHECK: call i32 @llvm.amdgcn.workitem.id.y() // CHECK: call i32 @llvm.amdgcn.workitem.id.y()
%2 = rocdl.workitem.id.y : !llvm.i32 %2 = rocdl.workitem.id.y : i32
// CHECK: call i32 @llvm.amdgcn.workitem.id.z() // CHECK: call i32 @llvm.amdgcn.workitem.id.z()
%3 = rocdl.workitem.id.z : !llvm.i32 %3 = rocdl.workitem.id.z : i32
// CHECK: call i32 @llvm.amdgcn.workgroup.id.x() // CHECK: call i32 @llvm.amdgcn.workgroup.id.x()
%4 = rocdl.workgroup.id.x : !llvm.i32 %4 = rocdl.workgroup.id.x : i32
// CHECK: call i32 @llvm.amdgcn.workgroup.id.y() // CHECK: call i32 @llvm.amdgcn.workgroup.id.y()
%5 = rocdl.workgroup.id.y : !llvm.i32 %5 = rocdl.workgroup.id.y : i32
// CHECK: call i32 @llvm.amdgcn.workgroup.id.z() // CHECK: call i32 @llvm.amdgcn.workgroup.id.z()
%6 = rocdl.workgroup.id.z : !llvm.i32 %6 = rocdl.workgroup.id.z : i32
// CHECK: call i64 @__ockl_get_local_size(i32 0) // CHECK: call i64 @__ockl_get_local_size(i32 0)
%7 = rocdl.workgroup.dim.x : !llvm.i64 %7 = rocdl.workgroup.dim.x : i64
// CHECK: call i64 @__ockl_get_local_size(i32 1) // CHECK: call i64 @__ockl_get_local_size(i32 1)
%8 = rocdl.workgroup.dim.y : !llvm.i64 %8 = rocdl.workgroup.dim.y : i64
// CHECK: call i64 @__ockl_get_local_size(i32 2) // CHECK: call i64 @__ockl_get_local_size(i32 2)
%9 = rocdl.workgroup.dim.z : !llvm.i64 %9 = rocdl.workgroup.dim.z : i64
// CHECK: call i64 @__ockl_get_global_size(i32 0) // CHECK: call i64 @__ockl_get_global_size(i32 0)
%10 = rocdl.grid.dim.x : !llvm.i64 %10 = rocdl.grid.dim.x : i64
// CHECK: call i64 @__ockl_get_global_size(i32 1) // CHECK: call i64 @__ockl_get_global_size(i32 1)
%11 = rocdl.grid.dim.y : !llvm.i64 %11 = rocdl.grid.dim.y : i64
// CHECK: call i64 @__ockl_get_global_size(i32 2) // CHECK: call i64 @__ockl_get_global_size(i32 2)
%12 = rocdl.grid.dim.z : !llvm.i64 %12 = rocdl.grid.dim.z : i64
llvm.return %1 : !llvm.i32 llvm.return %1 : i32
} }
llvm.func @kernel_func() attributes {gpu.kernel} { llvm.func @kernel_func() attributes {gpu.kernel} {
// CHECK-LABEL: amdgpu_kernel void @kernel_func // CHECK-LABEL: amdgpu_kernel void @kernel_func
llvm.return llvm.return
} }
llvm.func @rocdl.barrier() { llvm.func @rocdl.barrier() {
// CHECK: fence syncscope("workgroup") release // CHECK: fence syncscope("workgroup") release
// CHECK-NEXT: call void @llvm.amdgcn.s.barrier() // CHECK-NEXT: call void @llvm.amdgcn.s.barrier()
// CHECK-NEXT: fence syncscope("workgroup") acquire // CHECK-NEXT: fence syncscope("workgroup") acquire
rocdl.barrier rocdl.barrier
llvm.return llvm.return
} }
llvm.func @rocdl.xdlops(%arg0 : !llvm.float, %arg1 : !llvm.float, llvm.func @rocdl.xdlops(%arg0 : !llvm.float, %arg1 : !llvm.float,
%arg2 : !llvm.vec<32 x float>, %arg3 : !llvm.i32, %arg2 : !llvm.vec<32 x float>, %arg3 : i32,
%arg4 : !llvm.vec<16 x float>, %arg5 : !llvm.vec<4 x float>, %arg4 : !llvm.vec<16 x float>, %arg5 : !llvm.vec<4 x float>,
%arg6 : !llvm.vec<4 x half>, %arg7 : !llvm.vec<32 x i32>, %arg6 : !llvm.vec<4 x half>, %arg7 : !llvm.vec<32 x i32>,
%arg8 : !llvm.vec<16 x i32>, %arg9 : !llvm.vec<4 x i32>, %arg8 : !llvm.vec<16 x i32>, %arg9 : !llvm.vec<4 x i32>,
%arg10 : !llvm.vec<2 x i16>) -> !llvm.vec<32 x float> { %arg10 : !llvm.vec<2 x i16>) -> !llvm.vec<32 x float> {
// CHECK-LABEL: rocdl.xdlops // CHECK-LABEL: rocdl.xdlops
// CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x1f32(float %{{.*}}, float %{{.*}}, <32 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x1f32(float %{{.*}}, float %{{.*}}, <32 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r0 = rocdl.mfma.f32.32x32x1f32 %arg0, %arg1, %arg2, %arg3, %arg3, %arg3 : %r0 = rocdl.mfma.f32.32x32x1f32 %arg0, %arg1, %arg2, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<32 x float>, (!llvm.float, !llvm.float, !llvm.vec<32 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> i32, i32, i32) -> !llvm.vec<32 x float>
// CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x1f32(float %{{.*}}, float %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x1f32(float %{{.*}}, float %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r1 = rocdl.mfma.f32.16x16x1f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 : %r1 = rocdl.mfma.f32.16x16x1f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<16 x float>, (!llvm.float, !llvm.float, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x4f32(float %{{.*}}, float %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x4f32(float %{{.*}}, float %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r2 = rocdl.mfma.f32.16x16x4f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 : %r2 = rocdl.mfma.f32.16x16x4f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<4 x float>, (!llvm.float, !llvm.float, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x1f32(float %{{.*}}, float %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x1f32(float %{{.*}}, float %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r3 = rocdl.mfma.f32.4x4x1f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 : %r3 = rocdl.mfma.f32.4x4x1f32 %arg0, %arg1, %arg5, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<4 x float>, (!llvm.float, !llvm.float, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x2f32(float %{{.*}}, float %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x2f32(float %{{.*}}, float %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r4= rocdl.mfma.f32.32x32x2f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 : %r4= rocdl.mfma.f32.32x32x2f32 %arg0, %arg1, %arg4, %arg3, %arg3, %arg3 :
(!llvm.float, !llvm.float, !llvm.vec<16 x float>, (!llvm.float, !llvm.float, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <32 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <32 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r5 = rocdl.mfma.f32.32x32x4f16 %arg6, %arg6, %arg2, %arg3, %arg3, %arg3 : %r5 = rocdl.mfma.f32.32x32x4f16 %arg6, %arg6, %arg2, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<32 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<32 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> i32, i32, i32) -> !llvm.vec<32 x float>
// CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r6 = rocdl.mfma.f32.16x16x4f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 : %r6 = rocdl.mfma.f32.16x16x4f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x4f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r7 = rocdl.mfma.f32.4x4x4f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 : %r7 = rocdl.mfma.f32.4x4x4f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x8f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x8f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r8 = rocdl.mfma.f32.32x32x8f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 : %r8 = rocdl.mfma.f32.32x32x8f16 %arg6, %arg6, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x16f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x16f16(<4 x half> %{{.*}}, <4 x half> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r9 = rocdl.mfma.f32.16x16x16f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 : %r9 = rocdl.mfma.f32.16x16x16f16 %arg6, %arg6, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>, (!llvm.vec<4 x half>, !llvm.vec<4 x half>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: call <32 x i32> @llvm.amdgcn.mfma.i32.32x32x4i8(i32 %{{.*}}, i32 %{{.*}}, <32 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <32 x i32> @llvm.amdgcn.mfma.i32.32x32x4i8(i32 %{{.*}}, i32 %{{.*}}, <32 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r10 = rocdl.mfma.i32.32x32x4i8 %arg3, %arg3, %arg7, %arg3, %arg3, %arg3 : %r10 = rocdl.mfma.i32.32x32x4i8 %arg3, %arg3, %arg7, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<32 x i32>, (i32, i32, !llvm.vec<32 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x i32> i32, i32, i32) -> !llvm.vec<32 x i32>
// CHECK: call <16 x i32> @llvm.amdgcn.mfma.i32.16x16x4i8(i32 %{{.*}}, i32 %{{.*}}, <16 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x i32> @llvm.amdgcn.mfma.i32.16x16x4i8(i32 %{{.*}}, i32 %{{.*}}, <16 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r11 = rocdl.mfma.i32.16x16x4i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 : %r11 = rocdl.mfma.i32.16x16x4i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<16 x i32>, (i32, i32, !llvm.vec<16 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x i32> i32, i32, i32) -> !llvm.vec<16 x i32>
// CHECK: call <4 x i32> @llvm.amdgcn.mfma.i32.4x4x4i8(i32 %{{.*}}, i32 %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x i32> @llvm.amdgcn.mfma.i32.4x4x4i8(i32 %{{.*}}, i32 %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r12 = rocdl.mfma.i32.4x4x4i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 : %r12 = rocdl.mfma.i32.4x4x4i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<4 x i32>, (i32, i32, !llvm.vec<4 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x i32> i32, i32, i32) -> !llvm.vec<4 x i32>
// CHECK: call <16 x i32> @llvm.amdgcn.mfma.i32.32x32x8i8(i32 %{{.*}}, i32 %{{.*}}, <16 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x i32> @llvm.amdgcn.mfma.i32.32x32x8i8(i32 %{{.*}}, i32 %{{.*}}, <16 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r13 = rocdl.mfma.i32.32x32x8i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 : %r13 = rocdl.mfma.i32.32x32x8i8 %arg3, %arg3, %arg8, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<16 x i32>, (i32, i32, !llvm.vec<16 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x i32> i32, i32, i32) -> !llvm.vec<16 x i32>
// CHECK: call <4 x i32> @llvm.amdgcn.mfma.i32.16x16x16i8(i32 %{{.*}}, i32 %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x i32> @llvm.amdgcn.mfma.i32.16x16x16i8(i32 %{{.*}}, i32 %{{.*}}, <4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r14 = rocdl.mfma.i32.16x16x16i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 : %r14 = rocdl.mfma.i32.16x16x16i8 %arg3, %arg3, %arg9, %arg3, %arg3, %arg3 :
(!llvm.i32, !llvm.i32, !llvm.vec<4 x i32>, (i32, i32, !llvm.vec<4 x i32>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x i32> i32, i32, i32) -> !llvm.vec<4 x i32>
// CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <32 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <32 x float> @llvm.amdgcn.mfma.f32.32x32x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <32 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r15 = rocdl.mfma.f32.32x32x2bf16 %arg10, %arg10, %arg2, %arg3, %arg3, %arg3 : %r15 = rocdl.mfma.f32.32x32x2bf16 %arg10, %arg10, %arg2, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<32 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<32 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<32 x float> i32, i32, i32) -> !llvm.vec<32 x float>
// CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.16x16x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r16 = rocdl.mfma.f32.16x16x2bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 : %r16 = rocdl.mfma.f32.16x16x2bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.4x4x2bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r17 = rocdl.mfma.f32.4x4x2bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 : %r17 = rocdl.mfma.f32.4x4x2bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
// CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x4bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <16 x float> @llvm.amdgcn.mfma.f32.32x32x4bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <16 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r18 = rocdl.mfma.f32.32x32x4bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 : %r18 = rocdl.mfma.f32.32x32x4bf16 %arg10, %arg10, %arg4, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<16 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<16 x float> i32, i32, i32) -> !llvm.vec<16 x float>
// CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x8bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.mfma.f32.16x16x8bf16(<2 x i16> %{{.*}}, <2 x i16> %{{.*}}, <4 x float> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i32 %{{.*}})
%r19 = rocdl.mfma.f32.16x16x8bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 : %r19 = rocdl.mfma.f32.16x16x8bf16 %arg10, %arg10, %arg5, %arg3, %arg3, %arg3 :
(!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>, (!llvm.vec<2 x i16>, !llvm.vec<2 x i16>, !llvm.vec<4 x float>,
!llvm.i32, !llvm.i32, !llvm.i32) -> !llvm.vec<4 x float> i32, i32, i32) -> !llvm.vec<4 x float>
llvm.return %r0 : !llvm.vec<32 x float> llvm.return %r0 : !llvm.vec<32 x float>
} }
llvm.func @rocdl.mubuf(%rsrc : !llvm.vec<4 x i32>, %vindex : !llvm.i32, llvm.func @rocdl.mubuf(%rsrc : !llvm.vec<4 x i32>, %vindex : i32,
%offset : !llvm.i32, %glc : !llvm.i1, %offset : i32, %glc : i1,
%slc : !llvm.i1, %vdata1 : !llvm.vec<1 x float>, %slc : i1, %vdata1 : !llvm.vec<1 x float>,
%vdata2 : !llvm.vec<2 x float>, %vdata4 : !llvm.vec<4 x float>) { %vdata2 : !llvm.vec<2 x float>, %vdata4 : !llvm.vec<4 x float>) {
// CHECK-LABEL: rocdl.mubuf // CHECK-LABEL: rocdl.mubuf
// CHECK: call <1 x float> @llvm.amdgcn.buffer.load.v1f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 %{{.*}}, i1 %{{.*}}) // CHECK: call <1 x float> @llvm.amdgcn.buffer.load.v1f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 %{{.*}}, i1 %{{.*}})
%r1 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<1 x float> %r1 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<1 x float>
// CHECK: call <2 x float> @llvm.amdgcn.buffer.load.v2f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 %{{.*}}, i1 %{{.*}}) // CHECK: call <2 x float> @llvm.amdgcn.buffer.load.v2f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 %{{.*}}, i1 %{{.*}})
%r2 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<2 x float> %r2 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<2 x float>
// CHECK: call <4 x float> @llvm.amdgcn.buffer.load.v4f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 %{{.*}}, i1 %{{.*}}) // CHECK: call <4 x float> @llvm.amdgcn.buffer.load.v4f32(<4 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}, i1 %{{.*}}, i1 %{{.*}})
%r4 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<4 x float> %r4 = rocdl.buffer.load %rsrc, %vindex, %offset, %glc, %slc : !llvm.vec<4 x float>
Show All 11 Lines

mlir/test/Transforms/test-convert-call-op.mlir

// RUN: mlir-opt %s -test-convert-call-op | FileCheck %s // RUN: mlir-opt %s -test-convert-call-op | FileCheck %s
// CHECK-LABEL: llvm.func @callee(!llvm.ptr<i8>) -> !llvm.i32 // CHECK-LABEL: llvm.func @callee(!llvm.ptr<i8>) -> i32
func private @callee(!test.test_type) -> i32 func private @callee(!test.test_type) -> i32
// CHECK-NEXT: llvm.func @caller() -> !llvm.i32 // CHECK-NEXT: llvm.func @caller() -> i32
func @caller() -> i32 { func @caller() -> i32 {
%arg = "test.type_producer"() : () -> !test.test_type %arg = "test.type_producer"() : () -> !test.test_type
%out = call @callee(%arg) : (!test.test_type) -> i32 %out = call @callee(%arg) : (!test.test_type) -> i32
return %out : i32 return %out : i32
} }
// CHECK-NEXT: [[ARG:%.*]] = llvm.mlir.null : !llvm.ptr<i8> // CHECK-NEXT: [[ARG:%.*]] = llvm.mlir.null : !llvm.ptr<i8>
// CHECK-NEXT: [[OUT:%.*]] = llvm.call @callee([[ARG]]) // CHECK-NEXT: [[OUT:%.*]] = llvm.call @callee([[ARG]])
// CHECK-SAME: : (!llvm.ptr<i8>) -> !llvm.i32 // CHECK-SAME: : (!llvm.ptr<i8>) -> i32

mlir/test/lib/Transforms/TestConvertCallOp.cpp

Show All 39 Linespublic:
} }
void runOnOperation() override { void runOnOperation() override {
ModuleOp m = getOperation(); ModuleOp m = getOperation();
// Populate type conversions. // Populate type conversions.
LLVMTypeConverter type_converter(m.getContext()); LLVMTypeConverter type_converter(m.getContext());
type_converter.addConversion([&](test::TestType type) { type_converter.addConversion([&](test::TestType type) {
return LLVM::LLVMPointerType::get( return LLVM::LLVMPointerType::get(IntegerType::get(m.getContext(), 8));
LLVM::LLVMIntegerType::get(m.getContext(), 8));
}); });
// Populate patterns. // Populate patterns.
OwningRewritePatternList patterns; OwningRewritePatternList patterns;
populateStdToLLVMConversionPatterns(type_converter, patterns); populateStdToLLVMConversionPatterns(type_converter, patterns);
patterns.insert<TestTypeProducerOpConverter>(type_converter); patterns.insert<TestTypeProducerOpConverter>(type_converter);
// Set target. // Set target.
Show All 22 Lines

mlir/test/mlir-cpu-runner/bare_ptr_call_conv.mlir

Show All 20 Lines scf.for %arg2 = %c0 to %c2 step %c1 {
%3 = addf %1, %cst_0 : f32 %3 = addf %1, %cst_0 : f32
store %3, %arg1[%arg2] : memref<2xf32> store %3, %arg1[%arg2] : memref<2xf32>
// CHECK-NEXT: 4, 4 // CHECK-NEXT: 4, 4
} }
return return
} }
// External declarations. // External declarations.
llvm.func @malloc(!llvm.i64) -> !llvm.ptr<i8> llvm.func @malloc(i64) -> !llvm.ptr<i8>
llvm.func @free(!llvm.ptr<i8>) llvm.func @free(!llvm.ptr<i8>)
func private @printF32(%arg0: f32) func private @printF32(%arg0: f32)
func private @printComma() func private @printComma()
func private @printNewline() func private @printNewline()
func @main() func @main()
{ {
%c2 = constant 2 : index %c2 = constant 2 : index
Show All 31 Lines

mlir/test/mlir-cpu-runner/simple.mlir

Show All 9 Lines
// RUN: rm %t.o // RUN: rm %t.o
// RUN: mlir-cpu-runner %s -dump-object-file -object-filename=%T/test.o | FileCheck %s // RUN: mlir-cpu-runner %s -dump-object-file -object-filename=%T/test.o | FileCheck %s
// RUN: ls %T/test.o // RUN: ls %T/test.o
// RUN: rm %T/test.o // RUN: rm %T/test.o
// Declarations of C library functions. // Declarations of C library functions.
llvm.func @fabsf(!llvm.float) -> !llvm.float llvm.func @fabsf(!llvm.float) -> !llvm.float
llvm.func @malloc(!llvm.i64) -> !llvm.ptr<i8> llvm.func @malloc(i64) -> !llvm.ptr<i8>
llvm.func @free(!llvm.ptr<i8>) llvm.func @free(!llvm.ptr<i8>)
// Check that a simple function with a nested call works. // Check that a simple function with a nested call works.
llvm.func @main() -> !llvm.float { llvm.func @main() -> !llvm.float {
%0 = llvm.mlir.constant(-4.200000e+02 : f32) : !llvm.float %0 = llvm.mlir.constant(-4.200000e+02 : f32) : !llvm.float
%1 = llvm.call @fabsf(%0) : (!llvm.float) -> !llvm.float %1 = llvm.call @fabsf(%0) : (!llvm.float) -> !llvm.float
llvm.return %1 : !llvm.float llvm.return %1 : !llvm.float
} }
// CHECK: 4.200000e+02 // CHECK: 4.200000e+02
// Helper typed functions wrapping calls to "malloc" and "free". // Helper typed functions wrapping calls to "malloc" and "free".
llvm.func @allocation() -> !llvm.ptr<float> { llvm.func @allocation() -> !llvm.ptr<float> {
%0 = llvm.mlir.constant(4 : index) : !llvm.i64 %0 = llvm.mlir.constant(4 : index) : i64
%1 = llvm.call @malloc(%0) : (!llvm.i64) -> !llvm.ptr<i8> %1 = llvm.call @malloc(%0) : (i64) -> !llvm.ptr<i8>
%2 = llvm.bitcast %1 : !llvm.ptr<i8> to !llvm.ptr<float> %2 = llvm.bitcast %1 : !llvm.ptr<i8> to !llvm.ptr<float>
llvm.return %2 : !llvm.ptr<float> llvm.return %2 : !llvm.ptr<float>
} }
llvm.func @deallocation(%arg0: !llvm.ptr<float>) { llvm.func @deallocation(%arg0: !llvm.ptr<float>) {
%0 = llvm.bitcast %arg0 : !llvm.ptr<float> to !llvm.ptr<i8> %0 = llvm.bitcast %arg0 : !llvm.ptr<float> to !llvm.ptr<i8>
llvm.call @free(%0) : (!llvm.ptr<i8>) -> () llvm.call @free(%0) : (!llvm.ptr<i8>) -> ()
llvm.return llvm.return
} }
// Check that allocation and deallocation works, and that a custom entry point // Check that allocation and deallocation works, and that a custom entry point
// works. // works.
llvm.func @foo() -> !llvm.float { llvm.func @foo() -> !llvm.float {
%0 = llvm.call @allocation() : () -> !llvm.ptr<float> %0 = llvm.call @allocation() : () -> !llvm.ptr<float>
%1 = llvm.mlir.constant(0 : index) : !llvm.i64 %1 = llvm.mlir.constant(0 : index) : i64
%2 = llvm.mlir.constant(1.234000e+03 : f32) : !llvm.float %2 = llvm.mlir.constant(1.234000e+03 : f32) : !llvm.float
%3 = llvm.getelementptr %0[%1] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %3 = llvm.getelementptr %0[%1] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
llvm.store %2, %3 : !llvm.ptr<float> llvm.store %2, %3 : !llvm.ptr<float>
%4 = llvm.getelementptr %0[%1] : (!llvm.ptr<float>, !llvm.i64) -> !llvm.ptr<float> %4 = llvm.getelementptr %0[%1] : (!llvm.ptr<float>, i64) -> !llvm.ptr<float>
%5 = llvm.load %4 : !llvm.ptr<float> %5 = llvm.load %4 : !llvm.ptr<float>
llvm.call @deallocation(%0) : (!llvm.ptr<float>) -> () llvm.call @deallocation(%0) : (!llvm.ptr<float>) -> ()
llvm.return %5 : !llvm.float llvm.return %5 : !llvm.float
} }
// NOMAIN: 1.234000e+03 // NOMAIN: 1.234000e+03
// Check that i32 return type works // Check that i32 return type works
llvm.func @int32_main() -> !llvm.i32 { llvm.func @int32_main() -> i32 {
%0 = llvm.mlir.constant(42 : i32) : !llvm.i32 %0 = llvm.mlir.constant(42 : i32) : i32
llvm.return %0 : !llvm.i32 llvm.return %0 : i32
} }
// INT32MAIN: 42 // INT32MAIN: 42
// Check that i64 return type works // Check that i64 return type works
llvm.func @int64_main() -> !llvm.i64 { llvm.func @int64_main() -> i64 {
%0 = llvm.mlir.constant(42 : i64) : !llvm.i64 %0 = llvm.mlir.constant(42 : i64) : i64
llvm.return %0 : !llvm.i64 llvm.return %0 : i64
} }
// INT64MAIN: 42 // INT64MAIN: 42