This is an archive of the discontinued LLVM Phabricator instance.

Differential D97917

[MLIR][SPIRV] Rename `spv.constant` to `spv.Constant`.
ClosedPublic

Authored by ergawy on Mar 4 2021, 12:16 AM.

Details

Reviewers
mravishankar
antiagainst
ftynse
herhut
Commits
rG5abdca47b3aa: [MLIR][SPIRV] Rename `spv.constant` to `spv.Constant`.
Summary

To unify the naming scheme across all ops in the SPIR-V dialect, we are
moving from spv.camelCase to spv.CamelCase everywhere.

Diff Detail

Event Timeline

ergawy created this revision.Mar 4 2021, 12:16 AM
Herald added a reviewer: mravishankar. · View Herald TranscriptMar 4 2021, 12:16 AM
Herald added a reviewer: antiagainst. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added subscribers: cota, mravishankar, teijeong and 19 others. · View Herald Transcript
ergawy requested review of this revision.Mar 4 2021, 12:16 AM
Herald added a reviewer: herhut. · View Herald TranscriptMar 4 2021, 12:16 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
Harbormaster completed remote builds in B91984: Diff 328044.Mar 4 2021, 8:15 AM
antiagainst accepted this revision.Mar 4 2021, 1:13 PM

Awesome, thanks!

This revision is now accepted and ready to land.Mar 4 2021, 1:13 PM
Closed by commit rG5abdca47b3aa: [MLIR][SPIRV] Rename `spv.constant` to `spv.Constant`. (authored by ergawy, committed by antiagainst). · Explain WhyMar 4 2021, 1:16 PM
This revision was automatically updated to reflect the committed changes.
antiagainst added a commit: rG5abdca47b3aa: [MLIR][SPIRV] Rename `spv.constant` to `spv.Constant`..

Revision Contents

PathSize
mlir/
docs/
Dialects/
26 lines
20 lines
include/
mlir/
Dialect/
SPIRV/
IR/
4 lines
20 lines
18 lines
lib/
Conversion/
StandardToSPIRV/
4 lines
Dialect/
SPIRV/
IR/
4 lines
6 lines
Target/
SPIRV/
Deserialization/
2 lines
test/
Conversion/
GPUToSPIRV/
6 lines
8 lines
GPUToVulkan/
2 lines
LinalgToSPIRV/
2 lines
SCFToSPIRV/
28 lines
8 lines
SPIRVToLLVM/
28 lines
24 lines
6 lines
StandardToSPIRV/
204 lines
Dialect/
SPIRV/
IR/
2 lines
64 lines
2 lines
40 lines
14 lines
16 lines
74 lines
Transforms/
2 lines
10 lines
258 lines
48 lines
26 lines
2 lines
Target/
SPIRV/
176 lines
2 lines
12 lines
6 lines
2 lines
10 lines
24 lines
8 lines
4 lines
52 lines
16 lines
6 lines
2 lines

Diff 328044

mlir/docs/Dialects/SPIR-V.md

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
* Ops that directly mirror instructions in the specification have `CamelCase` * Ops that directly mirror instructions in the specification have `CamelCase`
names that are the same as the instruction opnames (without the `Op` names that are the same as the instruction opnames (without the `Op`
prefix). For example, `spv.FMul` is a direct mirror of `OpFMul` in the prefix). For example, `spv.FMul` is a direct mirror of `OpFMul` in the
specification. Such an op will be serialized into and deserialized from one specification. Such an op will be serialized into and deserialized from one
SPIR-V instruction. SPIR-V instruction.
* Ops with `snake_case` names are those that have different representation * Ops with `snake_case` names are those that have different representation
from corresponding instructions (or concepts) in the specification. These from corresponding instructions (or concepts) in the specification. These
ops are mostly for defining the SPIR-V structure. For example, `spv.module` ops are mostly for defining the SPIR-V structure. For example, `spv.module`
and `spv.constant`. They may correspond to one or more instructions during and `spv.Constant`. They may correspond to one or more instructions during
(de)serialization. (de)serialization.
* Ops with `mlir.snake_case` names are those that have no corresponding * Ops with `mlir.snake_case` names are those that have no corresponding
instructions (or concepts) in the binary format. They are introduced to instructions (or concepts) in the binary format. They are introduced to
satisfy MLIR structural requirements. For example, `spv.mlir.endmodule` and satisfy MLIR structural requirements. For example, `spv.mlir.endmodule` and
`spv.mlir.merge`. They map to no instructions during (de)serialization. `spv.mlir.merge`. They map to no instructions during (de)serialization.
(TODO: consider merging the last two cases and adopting `spv.mlir.` prefix for (TODO: consider merging the last two cases and adopting `spv.mlir.` prefix for
them.) them.)
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
* Types are represented using MLIR builtin types and SPIR-V dialect specific * Types are represented using MLIR builtin types and SPIR-V dialect specific
types. There are no type declaration ops in the SPIR-V dialect. More types. There are no type declaration ops in the SPIR-V dialect. More
discussions can be found in the [Types](#types) section later. discussions can be found in the [Types](#types) section later.
#### Unify and localize constants #### Unify and localize constants
* Various normal constant instructions are represented by the same * Various normal constant instructions are represented by the same
`spv.constant` op. Those instructions are just for constants of different `spv.Constant` op. Those instructions are just for constants of different
types; using one op to represent them reduces IR verbosity and makes types; using one op to represent them reduces IR verbosity and makes
transformations less tedious. transformations less tedious.
* Normal constants are not placed in `spv.module`'s region; they are localized * Normal constants are not placed in `spv.module`'s region; they are localized
into functions. This is to make functions in the SPIR-V dialect to be into functions. This is to make functions in the SPIR-V dialect to be
isolated and explicit capturing. Constants are cheap to duplicate given isolated and explicit capturing. Constants are cheap to duplicate given
attributes are made unique in `MLIRContext`. attributes are made unique in `MLIRContext`.
#### Adopt symbol-based global variables and specialization constant #### Adopt symbol-based global variables and specialization constant
▲ Show 20 Lines • Show All 292 Lines • ▼ Show 20 Lines
... ...
%3 = OpVariable %i32 Function 42 %3 = OpVariable %i32 Function 42
%4 = OpIAdd %i32 %c42 %c42 %4 = OpIAdd %i32 %c42 %c42
``` ```
can be represented in the dialect as can be represented in the dialect as
```mlir ```mlir
%0 = "spv.constant"() { value = 42 : i32 } : () -> i32 %0 = "spv.Constant"() { value = 42 : i32 } : () -> i32
%1 = "spv.Variable"(%0) { storage_class = "Function" } : (i32) -> !spv.ptr<i32, Function> %1 = "spv.Variable"(%0) { storage_class = "Function" } : (i32) -> !spv.ptr<i32, Function>
%2 = "spv.IAdd"(%0, %0) : (i32, i32) -> i32 %2 = "spv.IAdd"(%0, %0) : (i32, i32) -> i32
``` ```
Operation documentation is written in each op's Op Definition Spec using Operation documentation is written in each op's Op Definition Spec using
TableGen. A markdown version of the doc can be generated using TableGen. A markdown version of the doc can be generated using
`mlir-tblgen -gen-doc` and is attached in the `mlir-tblgen -gen-doc` and is attached in the
[Operation definitions](#operation-definitions) section. [Operation definitions](#operation-definitions) section.
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Linesvoid loop(bool cond) {
// ... // ...
} }
``` ```
It will be represented as It will be represented as
```mlir ```mlir
func @selection(%cond: i1) -> () { func @selection(%cond: i1) -> () {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%two = spv.constant 2: i32 %two = spv.Constant 2: i32
%x = spv.Variable init(%zero) : !spv.ptr<i32, Function> %x = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
^then: ^then:
spv.Store "Function" %x, %one : i32 spv.Store "Function" %x, %one : i32
spv.Branch ^merge spv.Branch ^merge
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linesvoid loop(int count) {
} }
} }
``` ```
It will be represented as It will be represented as
```mlir ```mlir
func @loop(%count : i32) -> () { func @loop(%count : i32) -> () {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.loop { spv.loop {
spv.Branch ^header spv.Branch ^header
^header: ^header:
%val0 = spv.Load "Function" %var : i32 %val0 = spv.Load "Function" %var : i32
%cmp = spv.SLessThan %val0, %count : i32 %cmp = spv.SLessThan %val0, %count : i32
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
It will be represented as: It will be represented as:
```mlir ```mlir
func @foo() -> () { func @foo() -> () {
%var = spv.Variable : !spv.ptr<i32, Function> %var = spv.Variable : !spv.ptr<i32, Function>
spv.selection { spv.selection {
%true = spv.constant true %true = spv.Constant true
spv.BranchConditional %true, ^true, ^false spv.BranchConditional %true, ^true, ^false
^true: ^true:
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
spv.Branch ^phi(%zero: i32) spv.Branch ^phi(%zero: i32)
^false: ^false:
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
spv.Branch ^phi(%one: i32) spv.Branch ^phi(%one: i32)
^phi(%arg: i32): ^phi(%arg: i32):
spv.Store "Function" %var, %arg : i32 spv.Store "Function" %var, %arg : i32
spv.Return spv.Return
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
▲ Show 20 Lines • Show All 207 Lines • ▼ Show 20 Lines
A few transformations are performed in the process of serialization because of A few transformations are performed in the process of serialization because of
the representational differences between SPIR-V dialect and binary format: the representational differences between SPIR-V dialect and binary format:
* Attributes on `spv.module` are emitted as their corresponding SPIR-V * Attributes on `spv.module` are emitted as their corresponding SPIR-V
instructions. instructions.
* Types are serialized into `OpType*` instructions in the SPIR-V binary module * Types are serialized into `OpType*` instructions in the SPIR-V binary module
section for types, constants, and global variables. section for types, constants, and global variables.
* `spv.constant`s are unified and placed in the SPIR-V binary module section * `spv.Constant`s are unified and placed in the SPIR-V binary module section
for types, constants, and global variables. for types, constants, and global variables.
* Attributes on ops, if not part of the op's binary encoding, are emitted as * Attributes on ops, if not part of the op's binary encoding, are emitted as
`OpDecorate*` instructions in the SPIR-V binary module section for `OpDecorate*` instructions in the SPIR-V binary module section for
decorations. decorations.
* `spv.selection`s and `spv.loop`s are emitted as basic blocks with `Op*Merge` * `spv.selection`s and `spv.loop`s are emitted as basic blocks with `Op*Merge`
instructions in the header block as required by the binary format. instructions in the header block as required by the binary format.
* Block arguments are materialized as `OpPhi` instructions at the beginning of * Block arguments are materialized as `OpPhi` instructions at the beginning of
the corresponding blocks. the corresponding blocks.
Similarly, a few transformations are performed during deserialization: Similarly, a few transformations are performed during deserialization:
* Instructions for execution environment requirements (extensions, * Instructions for execution environment requirements (extensions,
capabilities, extended instruction sets, etc.) will be placed as attributes capabilities, extended instruction sets, etc.) will be placed as attributes
on `spv.module`. on `spv.module`.
* `OpType*` instructions will be converted into proper `mlir::Type`s. * `OpType*` instructions will be converted into proper `mlir::Type`s.
* `OpConstant*` instructions are materialized as `spv.constant` at each use * `OpConstant*` instructions are materialized as `spv.Constant` at each use
site. site.
* `OpVariable` instructions will be converted to `spv.globalVariable` ops if * `OpVariable` instructions will be converted to `spv.globalVariable` ops if
in module-level; otherwise they will be converted into `spv.Variable` ops. in module-level; otherwise they will be converted into `spv.Variable` ops.
* Every use of a module-level `OpVariable` instruction will materialize a * Every use of a module-level `OpVariable` instruction will materialize a
`spv.mlir.addressof` op to turn the symbol of the corresponding `spv.mlir.addressof` op to turn the symbol of the corresponding
`spv.globalVariable` into an SSA value. `spv.globalVariable` into an SSA value.
* Every use of a `OpSpecConstant` instruction will materialize a * Every use of a `OpSpecConstant` instruction will materialize a
`spv.mlir.referenceof` op to turn the symbol of the corresponding `spv.mlir.referenceof` op to turn the symbol of the corresponding
▲ Show 20 Lines • Show All 457 Lines • Show Last 20 Lines

mlir/docs/SPIRVToLLVMDialectConversion.md

Show First 20 Lines • Show All 428 Lines • ▼ Show 20 Lines
#### `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) : i32 %0 = llvm.mlir.constant(0 : i32) : i32
%el = llvm.getelementptr %var[%0, %i, %i] : (!llvm.ptr<struct<packed (f32, array<4 x f32>)>>, i32, i32, i32) %el = llvm.getelementptr %var[%0, %i, %i] : (!llvm.ptr<struct<packed (f32, array<4 x f32>)>>, i32, i32, i32)
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
Per SPIR-V dialect spec, `spv.Variable` allocates an object in memory, resulting Per SPIR-V dialect spec, `spv.Variable` allocates an object in memory, resulting
in a pointer to it, which can be used with `spv.Load` and `spv.Store`. It is in a pointer to it, which can be used with `spv.Load` and `spv.Store`. It is
also a function-level variable. also a function-level variable.
`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) : i32 %size = llvm.mlir.constant(1 : i32) : i32
%res = spv.Variable : !spv.ptr<vector<3xf32>, Function> => %res = llvm.alloca %size x vector<3xf32> : (i32) -> !llvm.ptr<vec<3 x f32>> %res = spv.Variable : !spv.ptr<vector<3xf32>, Function> => %res = llvm.alloca %size x vector<3xf32> : (i32) -> !llvm.ptr<vec<3 x f32>>
// Conversion of VariableOp with initialization // Conversion of VariableOp with initialization
%c = llvm.mlir.constant(0 : i64) : i64 %c = llvm.mlir.constant(0 : i64) : i64
%c = spv.constant 0 : i64 %size = llvm.mlir.constant(1 : i32) : 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 i64 : (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 29 Lines
// Shift without extension // Shift without extension
%res0 = spv.ShiftRightArithmetic %0, %2 : i32, i32 => %res0 = llvm.ashr %0, %2 : i32 %res0 = spv.ShiftRightArithmetic %0, %2 : i32, i32 => %res0 = llvm.ashr %0, %2 : i32
// Shift with extension // Shift with extension
%ext = llvm.sext %1 : i16 to i32 %ext = llvm.sext %1 : i16 to i32
%res1 = spv.ShiftRightArithmetic %0, %1 : i32, i16 => %res1 = llvm.ashr %0, %ext: 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
`spv.constant` is mapped to `llvm.mlir.constant`. This is a straightforward `spv.Constant` is mapped to `llvm.mlir.constant`. This is a straightforward
conversion pattern with a special case when the argument is signed or unsigned. conversion pattern with a special case when the argument is signed or unsigned.
#### Special case #### Special case
SPIR-V constant can be a signed or unsigned integer. Since LLVM Dialect does not SPIR-V constant can be a signed or unsigned integer. Since LLVM Dialect does not
have signedness semantics, this case should be handled separately. have signedness semantics, this case should be handled separately.
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) : 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>) : vector<3xi32> // %1 = llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : vector<3xi32>
%1 = spv.constant dense<[2, 3, 4]> : vector<3xui32> %1 = spv.Constant dense<[2, 3, 4]> : vector<3xui32>
``` ```
### Not implemented ops ### Not implemented ops
There is no support of the following ops: There is no support of the following ops:
* All atomic ops * All atomic ops
* All group ops * All group ops
▲ Show 20 Lines • Show All 44 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) : 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) : 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 250 Lines • Show Last 20 Lines

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMemoryOps.td

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines let description = [{
access-chain-op ::= ssa-id `=` `spv.AccessChain` ssa-use access-chain-op ::= ssa-id `=` `spv.AccessChain` ssa-use
`[` ssa-use (',' ssa-use)* `]` `[` ssa-use (',' ssa-use)* `]`
`:` pointer-type `:` pointer-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%0 = "spv.constant"() { value = 1: i32} : () -> i32 %0 = "spv.Constant"() { value = 1: i32} : () -> 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>
%2 = spv.AccessChain %1[%0] : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function> %2 = spv.AccessChain %1[%0] : !spv.ptr<!spv.struct<f32, !spv.array<4xf32>>, Function>
%3 = spv.Load "Function" %2 ["Volatile"] : !spv.array<4xf32> %3 = spv.Load "Function" %2 ["Volatile"] : !spv.array<4xf32>
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SPV_AnyPtr:$base_ptr, SPV_AnyPtr:$base_ptr,
▲ Show 20 Lines • Show All 201 Lines • ▼ Show 20 Lines variable-op ::= ssa-id `=` `spv.Variable` (`init(` ssa-use `)`)?
attribute-dict? `:` spirv-pointer-type attribute-dict? `:` spirv-pointer-type
``` ```
where `init` specifies initializer. where `init` specifies initializer.
#### Example: #### Example:
```mlir ```mlir
%0 = spv.constant ... %0 = spv.Constant ...
%1 = spv.Variable : !spv.ptr<f32, Function> %1 = spv.Variable : !spv.ptr<f32, Function>
%2 = spv.Variable init(%0): !spv.ptr<f32, Function> %2 = spv.Variable init(%0): !spv.ptr<f32, Function>
``` ```
}]; }];
let arguments = (ins let arguments = (ins
SPV_StorageClassAttr:$storage_class, SPV_StorageClassAttr:$storage_class,
Show All 9 Lines

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td

Show First 20 Lines • Show All 248 Lines • ▼ Show 20 Lines let description = [{
non-uniform-fadd-op ::= ssa-id `=` `spv.GroupNonUniformFAdd` scope operation non-uniform-fadd-op ::= ssa-id `=` `spv.GroupNonUniformFAdd` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` float-scalar-vector-type `:` float-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : f32 %scalar = ... : f32
%vector = ... : vector<4xf32> %vector = ... : vector<4xf32>
%0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %scalar : f32 %0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %scalar : f32
%1 = spv.GroupNonUniformFAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32> %1 = spv.GroupNonUniformFAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
``` ```
}]; }];
let availability = [ let availability = [
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines let description = [{
non-uniform-fmax-op ::= ssa-id `=` `spv.GroupNonUniformFMax` scope operation non-uniform-fmax-op ::= ssa-id `=` `spv.GroupNonUniformFMax` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` float-scalar-vector-type `:` float-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : f32 %scalar = ... : f32
%vector = ... : vector<4xf32> %vector = ... : vector<4xf32>
%0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %scalar : f32 %0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %scalar : f32
%1 = spv.GroupNonUniformFMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32> %1 = spv.GroupNonUniformFMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
``` ```
}]; }];
let availability = [ let availability = [
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines let description = [{
non-uniform-fmin-op ::= ssa-id `=` `spv.GroupNonUniformFMin` scope operation non-uniform-fmin-op ::= ssa-id `=` `spv.GroupNonUniformFMin` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` float-scalar-vector-type `:` float-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : f32 %scalar = ... : f32
%vector = ... : vector<4xf32> %vector = ... : vector<4xf32>
%0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %scalar : f32 %0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %scalar : f32
%1 = spv.GroupNonUniformFMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32> %1 = spv.GroupNonUniformFMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
``` ```
}]; }];
let availability = [ let availability = [
Show All 40 Lines let description = [{
non-uniform-fmul-op ::= ssa-id `=` `spv.GroupNonUniformFMul` scope operation non-uniform-fmul-op ::= ssa-id `=` `spv.GroupNonUniformFMul` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` float-scalar-vector-type `:` float-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : f32 %scalar = ... : f32
%vector = ... : vector<4xf32> %vector = ... : vector<4xf32>
%0 = spv.GroupNonUniformFMul "Workgroup" "Reduce" %scalar : f32 %0 = spv.GroupNonUniformFMul "Workgroup" "Reduce" %scalar : f32
%1 = spv.GroupNonUniformFMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32> %1 = spv.GroupNonUniformFMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xf32>
``` ```
}]; }];
let availability = [ let availability = [
Show All 38 Lines let description = [{
non-uniform-iadd-op ::= ssa-id `=` `spv.GroupNonUniformIAdd` scope operation non-uniform-iadd-op ::= ssa-id `=` `spv.GroupNonUniformIAdd` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` integer-scalar-vector-type `:` integer-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : i32 %scalar = ... : i32
%vector = ... : vector<4xi32> %vector = ... : vector<4xi32>
%0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %scalar : i32 %0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %scalar : i32
%1 = spv.GroupNonUniformIAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32> %1 = spv.GroupNonUniformIAdd "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
``` ```
}]; }];
let availability = [ let availability = [
Show All 38 Lines let description = [{
non-uniform-imul-op ::= ssa-id `=` `spv.GroupNonUniformIMul` scope operation non-uniform-imul-op ::= ssa-id `=` `spv.GroupNonUniformIMul` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` integer-scalar-vector-type `:` integer-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : i32 %scalar = ... : i32
%vector = ... : vector<4xi32> %vector = ... : vector<4xi32>
%0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %scalar : i32 %0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %scalar : i32
%1 = spv.GroupNonUniformIMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32> %1 = spv.GroupNonUniformIMul "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
``` ```
}]; }];
let availability = [ let availability = [
Show All 40 Lines let description = [{
non-uniform-smax-op ::= ssa-id `=` `spv.GroupNonUniformSMax` scope operation non-uniform-smax-op ::= ssa-id `=` `spv.GroupNonUniformSMax` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` integer-scalar-vector-type `:` integer-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : i32 %scalar = ... : i32
%vector = ... : vector<4xi32> %vector = ... : vector<4xi32>
%0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %scalar : i32 %0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %scalar : i32
%1 = spv.GroupNonUniformSMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32> %1 = spv.GroupNonUniformSMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
``` ```
}]; }];
let availability = [ let availability = [
Show All 40 Lines let description = [{
non-uniform-smin-op ::= ssa-id `=` `spv.GroupNonUniformSMin` scope operation non-uniform-smin-op ::= ssa-id `=` `spv.GroupNonUniformSMin` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` integer-scalar-vector-type `:` integer-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : i32 %scalar = ... : i32
%vector = ... : vector<4xi32> %vector = ... : vector<4xi32>
%0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %scalar : i32 %0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %scalar : i32
%1 = spv.GroupNonUniformSMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32> %1 = spv.GroupNonUniformSMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
``` ```
}]; }];
let availability = [ let availability = [
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines let description = [{
non-uniform-umax-op ::= ssa-id `=` `spv.GroupNonUniformUMax` scope operation non-uniform-umax-op ::= ssa-id `=` `spv.GroupNonUniformUMax` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` integer-scalar-vector-type `:` integer-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : i32 %scalar = ... : i32
%vector = ... : vector<4xi32> %vector = ... : vector<4xi32>
%0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %scalar : i32 %0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %scalar : i32
%1 = spv.GroupNonUniformUMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32> %1 = spv.GroupNonUniformUMax "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
``` ```
}]; }];
let availability = [ let availability = [
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines let description = [{
non-uniform-umin-op ::= ssa-id `=` `spv.GroupNonUniformUMin` scope operation non-uniform-umin-op ::= ssa-id `=` `spv.GroupNonUniformUMin` scope operation
ssa-use ( `cluster_size` `(` ssa_use `)` )? ssa-use ( `cluster_size` `(` ssa_use `)` )?
`:` integer-scalar-vector-type `:` integer-scalar-vector-type
``` ```
#### Example: #### Example:
```mlir ```mlir
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
%scalar = ... : i32 %scalar = ... : i32
%vector = ... : vector<4xi32> %vector = ... : vector<4xi32>
%0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %scalar : i32 %0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %scalar : i32
%1 = spv.GroupNonUniformUMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32> %1 = spv.GroupNonUniformUMin "Subgroup" "ClusteredReduce" %vector cluster_size(%four) : vector<4xi32>
``` ```
}]; }];
let availability = [ let availability = [
Show All 10 Lines

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesdef SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> {
let builders = [OpBuilderDAG<(ins "spirv::GlobalVariableOp":$var)>]; let builders = [OpBuilderDAG<(ins "spirv::GlobalVariableOp":$var)>];
let assemblyFormat = "$variable attr-dict `:` type($pointer)"; let assemblyFormat = "$variable attr-dict `:` type($pointer)";
} }
// ----- // -----
def SPV_ConstantOp : SPV_Op<"constant", [ConstantLike, NoSideEffect]> { def SPV_ConstantOp : SPV_Op<"Constant", [ConstantLike, NoSideEffect]> {
let summary = "The op that declares a SPIR-V normal constant"; let summary = "The op that declares a SPIR-V normal constant";
let description = [{ let description = [{
This op declares a SPIR-V normal constant. SPIR-V has multiple constant This op declares a SPIR-V normal constant. SPIR-V has multiple constant
instructions covering different constant types: instructions covering different constant types:
* `OpConstantTrue` and `OpConstantFalse` for boolean constants * `OpConstantTrue` and `OpConstantFalse` for boolean constants
* `OpConstant` for scalar constants * `OpConstant` for scalar constants
* `OpConstantComposite` for composite constants * `OpConstantComposite` for composite constants
* `OpConstantNull` for null constants * `OpConstantNull` for null constants
* ... * ...
Having such a plethora of constant instructions renders IR transformations Having such a plethora of constant instructions renders IR transformations
more tedious. Therefore, we use a single `spv.constant` op to represent more tedious. Therefore, we use a single `spv.Constant` op to represent
them all. Note that conversion between those SPIR-V constant instructions them all. Note that conversion between those SPIR-V constant instructions
and this op is purely mechanical; so it can be scoped to the binary and this op is purely mechanical; so it can be scoped to the binary
(de)serialization process. (de)serialization process.
<!-- End of AutoGen section --> <!-- End of AutoGen section -->
``` ```
spv-constant-op ::= ssa-id `=` `spv.constant` attribute-value spv.Constant-op ::= ssa-id `=` `spv.Constant` attribute-value
(`:` spirv-type)? (`:` spirv-type)?
``` ```
#### Example: #### Example:
```mlir ```mlir
%0 = spv.constant true %0 = spv.Constant true
%1 = spv.constant dense<[2, 3]> : vector<2xf32> %1 = spv.Constant dense<[2, 3]> : vector<2xf32>
%2 = spv.constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>> %2 = spv.Constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>>
``` ```
TODO: support constant structs TODO: support constant structs
}]; }];
let arguments = (ins let arguments = (ins
AnyAttr:$value AnyAttr:$value
); );
▲ Show 20 Lines • Show All 457 Lines • ▼ Show 20 Linesdef SPV_SpecConstantOp : SPV_Op<"specConstant", [InModuleScope, Symbol]> {
let description = [{ let description = [{
This op declares a SPIR-V scalar specialization constant. SPIR-V has This op declares a SPIR-V scalar specialization constant. SPIR-V has
multiple constant instructions covering different scalar types: multiple constant instructions covering different scalar types:
* `OpSpecConstantTrue` and `OpSpecConstantFalse` for boolean constants * `OpSpecConstantTrue` and `OpSpecConstantFalse` for boolean constants
* `OpSpecConstant` for scalar constants * `OpSpecConstant` for scalar constants
Similar as `spv.constant`, this op represents all of the above cases. Similar as `spv.Constant`, this op represents all of the above cases.
`OpSpecConstantComposite` and `OpSpecConstantOp` are modelled with `OpSpecConstantComposite` and `OpSpecConstantOp` are modelled with
separate ops. separate ops.
<!-- End of AutoGen section --> <!-- End of AutoGen section -->
``` ```
spv-spec-constant-op ::= `spv.specConstant` symbol-ref-id spv-spec-constant-op ::= `spv.specConstant` symbol-ref-id
`spec_id(` integer `)` `spec_id(` integer `)`
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines let description = [{
- OpSLessThanEqual - OpSLessThanEqual
- OpUGreaterThanEqual, - OpUGreaterThanEqual,
- OpSGreaterThanEqual - OpSGreaterThanEqual
TODO Add capability-specific ops when supported. TODO Add capability-specific ops when supported.
#### Example: #### Example:
```mlir ```mlir
%0 = spv.constant 1: i32 %0 = spv.Constant 1: i32
%1 = spv.constant 1: i32 %1 = spv.Constant 1: i32
%2 = spv.SpecConstantOperation wraps "spv.IAdd"(%0, %1) : (i32, i32) -> i32 %2 = spv.SpecConstantOperation wraps "spv.IAdd"(%0, %1) : (i32, i32) -> i32
``` ```
}]; }];
let arguments = (ins); let arguments = (ins);
let results = (outs AnyType:$result); let results = (outs AnyType:$result);
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

Show First 20 Lines • Show All 350 Lines • ▼ Show 20 Lines matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
} else { } else {
rewriter.template replaceOpWithNewOp<SPIRVBitwiseOp>(operation, dstType, rewriter.template replaceOpWithNewOp<SPIRVBitwiseOp>(operation, dstType,
operands); operands);
} }
return success(); return success();
} }
}; };
/// Converts composite std.constant operation to spv.constant. /// Converts composite std.constant operation to spv.Constant.
class ConstantCompositeOpPattern final class ConstantCompositeOpPattern final
: public OpConversionPattern<ConstantOp> { : public OpConversionPattern<ConstantOp> {
public: public:
using OpConversionPattern<ConstantOp>::OpConversionPattern; using OpConversionPattern<ConstantOp>::OpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(ConstantOp constOp, ArrayRef<Value> operands, matchAndRewrite(ConstantOp constOp, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override; ConversionPatternRewriter &rewriter) const override;
}; };
/// Converts scalar std.constant operation to spv.constant. /// Converts scalar std.constant operation to spv.Constant.
class ConstantScalarOpPattern final : public OpConversionPattern<ConstantOp> { class ConstantScalarOpPattern final : public OpConversionPattern<ConstantOp> {
public: public:
using OpConversionPattern<ConstantOp>::OpConversionPattern; using OpConversionPattern<ConstantOp>::OpConversionPattern;
LogicalResult LogicalResult
matchAndRewrite(ConstantOp constOp, ArrayRef<Value> operands, matchAndRewrite(ConstantOp constOp, ArrayRef<Value> operands,
ConversionPatternRewriter &rewriter) const override; ConversionPatternRewriter &rewriter) const override;
}; };
▲ Show 20 Lines • Show All 849 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 LinesOpFoldResult spirv::CompositeExtractOp::fold(ArrayRef<Attribute> operands) {
auto indexVector = auto indexVector =
llvm::to_vector<8>(llvm::map_range(indices(), [](Attribute attr) { llvm::to_vector<8>(llvm::map_range(indices(), [](Attribute attr) {
return static_cast<unsigned>(attr.cast<IntegerAttr>().getInt()); return static_cast<unsigned>(attr.cast<IntegerAttr>().getInt());
})); }));
return extractCompositeElement(operands[0], indexVector); return extractCompositeElement(operands[0], indexVector);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.constant // spv.Constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
OpFoldResult spirv::ConstantOp::fold(ArrayRef<Attribute> operands) { OpFoldResult spirv::ConstantOp::fold(ArrayRef<Attribute> operands) {
assert(operands.empty() && "spv.constant has no operands"); assert(operands.empty() && "spv.Constant has no operands");
return value(); return value();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IAdd // spv.IAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
OpFoldResult spirv::IAddOp::fold(ArrayRef<Attribute> operands) { OpFoldResult spirv::IAddOp::fold(ArrayRef<Attribute> operands) {
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

Show First 20 Lines • Show All 935 Lines • ▼ Show 20 Lines if (!cType) {
<< resultType << " with index " << index; << resultType << " with index " << index;
return nullptr; return nullptr;
} }
index = 0; index = 0;
if (resultType.isa<spirv::StructType>()) { if (resultType.isa<spirv::StructType>()) {
Operation *op = indexSSA.getDefiningOp(); Operation *op = indexSSA.getDefiningOp();
if (!op) { if (!op) {
emitError(baseLoc, "'spv.AccessChain' op index must be an " emitError(baseLoc, "'spv.AccessChain' op index must be an "
"integer spv.constant to access " "integer spv.Constant to access "
"element of spv.struct"); "element of spv.struct");
return nullptr; return nullptr;
} }
// TODO: this should be relaxed to allow // TODO: this should be relaxed to allow
// integer literals of other bitwidths. // integer literals of other bitwidths.
if (failed(extractValueFromConstOp(op, index))) { if (failed(extractValueFromConstOp(op, index))) {
emitError(baseLoc, emitError(baseLoc,
"'spv.AccessChain' index must be an integer spv.constant to " "'spv.AccessChain' index must be an integer spv.Constant to "
"access element of spv.struct, but provided ") "access element of spv.struct, but provided ")
<< op->getName(); << op->getName();
return nullptr; return nullptr;
} }
if (index < 0 || static_cast<uint64_t>(index) >= cType.getNumElements()) { if (index < 0 || static_cast<uint64_t>(index) >= cType.getNumElements()) {
emitError(baseLoc, "'spv.AccessChain' op index ") emitError(baseLoc, "'spv.AccessChain' op index ")
<< index << " out of bounds for " << resultType; << index << " out of bounds for " << resultType;
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 516 Lines • ▼ Show 20 Linesstatic void print(spirv::CompositeInsertOp compositeInsertOp,
printer << spirv::CompositeInsertOp::getOperationName() << " " printer << spirv::CompositeInsertOp::getOperationName() << " "
<< compositeInsertOp.object() << ", " << compositeInsertOp.composite() << compositeInsertOp.object() << ", " << compositeInsertOp.composite()
<< compositeInsertOp.indices() << " : " << compositeInsertOp.indices() << " : "
<< compositeInsertOp.object().getType() << " into " << compositeInsertOp.object().getType() << " into "
<< compositeInsertOp.composite().getType(); << compositeInsertOp.composite().getType();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.constant // spv.Constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static ParseResult parseConstantOp(OpAsmParser &parser, OperationState &state) { static ParseResult parseConstantOp(OpAsmParser &parser, OperationState &state) {
Attribute value; Attribute value;
if (parser.parseAttribute(value, kValueAttrName, state.attributes)) if (parser.parseAttribute(value, kValueAttrName, state.attributes))
return failure(); return failure();
Type type = value.getType(); Type type = value.getType();
▲ Show 20 Lines • Show All 2,137 Lines • Show Last 20 Lines

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

Show All 32 Lines
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Instruction // Instruction
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Value spirv::Deserializer::getValue(uint32_t id) { Value spirv::Deserializer::getValue(uint32_t id) {
if (auto constInfo = getConstant(id)) { if (auto constInfo = getConstant(id)) {
// Materialize a `spv.constant` op at every use site. // Materialize a `spv.Constant` op at every use site.
return opBuilder.create<spirv::ConstantOp>(unknownLoc, constInfo->second, return opBuilder.create<spirv::ConstantOp>(unknownLoc, constInfo->second,
constInfo->first); constInfo->first);
} }
if (auto varOp = getGlobalVariable(id)) { if (auto varOp = getGlobalVariable(id)) {
auto addressOfOp = opBuilder.create<spirv::AddressOfOp>( auto addressOfOp = opBuilder.create<spirv::AddressOfOp>(
unknownLoc, varOp.type(), unknownLoc, varOp.type(),
opBuilder.getSymbolRefAttr(varOp.getOperation())); opBuilder.getSymbolRefAttr(varOp.getOperation()));
return addressOfOp.pointer(); return addressOfOp.pointer();
▲ Show 20 Lines • Show All 518 Lines • Show Last 20 Lines

mlir/test/Conversion/GPUToSPIRV/builtins.mlir

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Linesmodule attributes {gpu.container_module} {
// CHECK-LABEL: spv.module @{{.*}} Logical GLSL450 // CHECK-LABEL: spv.module @{{.*}} Logical GLSL450
gpu.module @kernels { gpu.module @kernels {
gpu.func @builtin_workgroup_size_x() kernel gpu.func @builtin_workgroup_size_x() kernel
attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]>: vector<3xi32>}} { attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]>: vector<3xi32>}} {
// The constant value is obtained from the spv.entry_point_abi. // The constant value is obtained from the spv.entry_point_abi.
// Note that this ignores the workgroup size specification in gpu.launch. // Note that this ignores the workgroup size specification in gpu.launch.
// We may want to define gpu.workgroup_size and convert it to the entry // We may want to define gpu.workgroup_size and convert it to the entry
// point ABI we want here. // point ABI we want here.
// CHECK: spv.constant 32 : i32 // CHECK: spv.Constant 32 : i32
%0 = "gpu.block_dim"() {dimension = "x"} : () -> index %0 = "gpu.block_dim"() {dimension = "x"} : () -> index
gpu.return gpu.return
} }
} }
} }
// ----- // -----
module attributes {gpu.container_module} { module attributes {gpu.container_module} {
func @builtin() { func @builtin() {
%c0 = constant 1 : index %c0 = constant 1 : index
gpu.launch_func @kernels::@builtin_workgroup_size_y gpu.launch_func @kernels::@builtin_workgroup_size_y
blocks in (%c0, %c0, %c0) threads in (%c0, %c0, %c0) blocks in (%c0, %c0, %c0) threads in (%c0, %c0, %c0)
return return
} }
// CHECK-LABEL: spv.module @{{.*}} Logical GLSL450 // CHECK-LABEL: spv.module @{{.*}} Logical GLSL450
gpu.module @kernels { gpu.module @kernels {
gpu.func @builtin_workgroup_size_y() kernel gpu.func @builtin_workgroup_size_y() kernel
attributes {spv.entry_point_abi = {local_size = dense<[32, 4, 1]>: vector<3xi32>}} { attributes {spv.entry_point_abi = {local_size = dense<[32, 4, 1]>: vector<3xi32>}} {
// The constant value is obtained from the spv.entry_point_abi. // The constant value is obtained from the spv.entry_point_abi.
// CHECK: spv.constant 4 : i32 // CHECK: spv.Constant 4 : i32
%0 = "gpu.block_dim"() {dimension = "y"} : () -> index %0 = "gpu.block_dim"() {dimension = "y"} : () -> index
gpu.return gpu.return
} }
} }
} }
// ----- // -----
module attributes {gpu.container_module} { module attributes {gpu.container_module} {
func @builtin() { func @builtin() {
%c0 = constant 1 : index %c0 = constant 1 : index
gpu.launch_func @kernels::@builtin_workgroup_size_z gpu.launch_func @kernels::@builtin_workgroup_size_z
blocks in (%c0, %c0, %c0) threads in (%c0, %c0, %c0) blocks in (%c0, %c0, %c0) threads in (%c0, %c0, %c0)
return return
} }
// CHECK-LABEL: spv.module @{{.*}} Logical GLSL450 // CHECK-LABEL: spv.module @{{.*}} Logical GLSL450
gpu.module @kernels { gpu.module @kernels {
gpu.func @builtin_workgroup_size_z() kernel gpu.func @builtin_workgroup_size_z() kernel
attributes {spv.entry_point_abi = {local_size = dense<[32, 4, 1]>: vector<3xi32>}} { attributes {spv.entry_point_abi = {local_size = dense<[32, 4, 1]>: vector<3xi32>}} {
// The constant value is obtained from the spv.entry_point_abi. // The constant value is obtained from the spv.entry_point_abi.
// CHECK: spv.constant 1 : i32 // CHECK: spv.Constant 1 : i32
%0 = "gpu.block_dim"() {dimension = "z"} : () -> index %0 = "gpu.block_dim"() {dimension = "z"} : () -> index
gpu.return gpu.return
} }
} }
} }
// ----- // -----
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

mlir/test/Conversion/GPUToSPIRV/load-store.mlir

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines gpu.func @load_store_kernel(%arg0: memref<12x4xf32>, %arg1: memref<12x4xf32>, %arg2: memref<12x4xf32>, %arg3: index, %arg4: index, %arg5: index, %arg6: index) kernel
%8 = "gpu.grid_dim"() {dimension = "z"} : () -> index %8 = "gpu.grid_dim"() {dimension = "z"} : () -> index
%9 = "gpu.block_dim"() {dimension = "x"} : () -> index %9 = "gpu.block_dim"() {dimension = "x"} : () -> index
%10 = "gpu.block_dim"() {dimension = "y"} : () -> index %10 = "gpu.block_dim"() {dimension = "y"} : () -> index
%11 = "gpu.block_dim"() {dimension = "z"} : () -> index %11 = "gpu.block_dim"() {dimension = "z"} : () -> index
// CHECK: %[[INDEX1:.*]] = spv.IAdd %[[ARG3]], %[[WORKGROUPIDX]] // CHECK: %[[INDEX1:.*]] = spv.IAdd %[[ARG3]], %[[WORKGROUPIDX]]
%12 = addi %arg3, %0 : index %12 = addi %arg3, %0 : index
// CHECK: %[[INDEX2:.*]] = spv.IAdd %[[ARG4]], %[[LOCALINVOCATIONIDX]] // CHECK: %[[INDEX2:.*]] = spv.IAdd %[[ARG4]], %[[LOCALINVOCATIONIDX]]
%13 = addi %arg4, %3 : index %13 = addi %arg4, %3 : index
// CHECK: %[[ZERO:.*]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.*]] = spv.Constant 0 : i32
// CHECK: %[[OFFSET1_0:.*]] = spv.constant 0 : i32 // CHECK: %[[OFFSET1_0:.*]] = spv.Constant 0 : i32
// CHECK: %[[STRIDE1_1:.*]] = spv.constant 4 : i32 // CHECK: %[[STRIDE1_1:.*]] = spv.Constant 4 : i32
// CHECK: %[[UPDATE1_1:.*]] = spv.IMul %[[STRIDE1_1]], %[[INDEX1]] : i32 // CHECK: %[[UPDATE1_1:.*]] = spv.IMul %[[STRIDE1_1]], %[[INDEX1]] : i32
// CHECK: %[[OFFSET1_1:.*]] = spv.IAdd %[[OFFSET1_0]], %[[UPDATE1_1]] : i32 // CHECK: %[[OFFSET1_1:.*]] = spv.IAdd %[[OFFSET1_0]], %[[UPDATE1_1]] : i32
// CHECK: %[[STRIDE1_2:.*]] = spv.constant 1 : i32 // CHECK: %[[STRIDE1_2:.*]] = spv.Constant 1 : i32
// CHECK: %[[UPDATE1_2:.*]] = spv.IMul %[[STRIDE1_2]], %[[INDEX2]] : i32 // CHECK: %[[UPDATE1_2:.*]] = spv.IMul %[[STRIDE1_2]], %[[INDEX2]] : i32
// CHECK: %[[OFFSET1_2:.*]] = spv.IAdd %[[OFFSET1_1]], %[[UPDATE1_2]] : i32 // CHECK: %[[OFFSET1_2:.*]] = spv.IAdd %[[OFFSET1_1]], %[[UPDATE1_2]] : i32
// CHECK: %[[PTR1:.*]] = spv.AccessChain %[[ARG0]]{{\[}}%[[ZERO]], %[[OFFSET1_2]]{{\]}} // CHECK: %[[PTR1:.*]] = spv.AccessChain %[[ARG0]]{{\[}}%[[ZERO]], %[[OFFSET1_2]]{{\]}}
// CHECK-NEXT: %[[VAL1:.*]] = spv.Load "StorageBuffer" %[[PTR1]] // CHECK-NEXT: %[[VAL1:.*]] = spv.Load "StorageBuffer" %[[PTR1]]
%14 = load %arg0[%12, %13] : memref<12x4xf32> %14 = load %arg0[%12, %13] : memref<12x4xf32>
// CHECK: %[[PTR2:.*]] = spv.AccessChain %[[ARG1]]{{\[}}{{%.*}}, {{%.*}}{{\]}} // CHECK: %[[PTR2:.*]] = spv.AccessChain %[[ARG1]]{{\[}}{{%.*}}, {{%.*}}{{\]}}
// CHECK-NEXT: %[[VAL2:.*]] = spv.Load "StorageBuffer" %[[PTR2]] // CHECK-NEXT: %[[VAL2:.*]] = spv.Load "StorageBuffer" %[[PTR2]]
%15 = load %arg1[%12, %13] : memref<12x4xf32> %15 = load %arg1[%12, %13] : memref<12x4xf32>
Show All 9 Lines

mlir/test/Conversion/GPUToVulkan/lower-gpu-launch-vulkan-launch.mlir

// RUN: mlir-opt %s -convert-gpu-launch-to-vulkan-launch | FileCheck %s // RUN: mlir-opt %s -convert-gpu-launch-to-vulkan-launch | FileCheck %s
// CHECK: %[[resource:.*]] = alloc() : memref<12xf32> // CHECK: %[[resource:.*]] = alloc() : memref<12xf32>
// CHECK: %[[index:.*]] = constant 1 : index // CHECK: %[[index:.*]] = constant 1 : index
// CHECK: call @vulkanLaunch(%[[index]], %[[index]], %[[index]], %[[resource]]) {spirv_blob = "{{.*}}", spirv_entry_point = "kernel"} // CHECK: call @vulkanLaunch(%[[index]], %[[index]], %[[index]], %[[resource]]) {spirv_blob = "{{.*}}", spirv_entry_point = "kernel"}
module attributes {gpu.container_module} { module attributes {gpu.container_module} {
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]> {
spv.globalVariable @kernel_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer> spv.globalVariable @kernel_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>
spv.func @kernel() "None" attributes {workgroup_attributions = 0 : i64} { spv.func @kernel() "None" attributes {workgroup_attributions = 0 : i64} {
%0 = spv.mlir.addressof @kernel_arg_0 : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer> %0 = spv.mlir.addressof @kernel_arg_0 : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>
%2 = spv.constant 0 : i32 %2 = spv.Constant 0 : i32
%3 = spv.mlir.addressof @kernel_arg_0 : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer> %3 = spv.mlir.addressof @kernel_arg_0 : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>
%4 = spv.AccessChain %0[%2, %2] : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>, i32, i32 %4 = spv.AccessChain %0[%2, %2] : !spv.ptr<!spv.struct<(!spv.array<12 x f32, stride=4> [0])>, StorageBuffer>, i32, i32
%5 = spv.Load "StorageBuffer" %4 : f32 %5 = spv.Load "StorageBuffer" %4 : f32
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @kernel spv.EntryPoint "GLCompute" @kernel
spv.ExecutionMode @kernel "LocalSize", 1, 1, 1 spv.ExecutionMode @kernel "LocalSize", 1, 1, 1
} }
Show All 15 Lines

mlir/test/Conversion/LinalgToSPIRV/linalg-to-spirv.mlir

Show All 17 Lines
} { } {
// CHECK: spv.globalVariable // CHECK: spv.globalVariable
// CHECK-SAME: built_in("LocalInvocationId") // CHECK-SAME: built_in("LocalInvocationId")
// CHECK: @single_workgroup_reduction // CHECK: @single_workgroup_reduction
// CHECK-SAME: (%[[INPUT:.+]]: !spv.ptr{{.+}}, %[[OUTPUT:.+]]: !spv.ptr{{.+}}) // CHECK-SAME: (%[[INPUT:.+]]: !spv.ptr{{.+}}, %[[OUTPUT:.+]]: !spv.ptr{{.+}})
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[ID:.+]] = spv.Load "Input" %{{.+}} : vector<3xi32> // CHECK: %[[ID:.+]] = spv.Load "Input" %{{.+}} : vector<3xi32>
// CHECK: %[[X:.+]] = spv.CompositeExtract %[[ID]][0 : i32] // CHECK: %[[X:.+]] = spv.CompositeExtract %[[ID]][0 : i32]
// CHECK: %[[INPTR:.+]] = spv.AccessChain %[[INPUT]][%[[ZERO]], %[[X]]] // CHECK: %[[INPTR:.+]] = spv.AccessChain %[[INPUT]][%[[ZERO]], %[[X]]]
// CHECK: %[[VAL:.+]] = spv.Load "StorageBuffer" %[[INPTR]] : i32 // CHECK: %[[VAL:.+]] = spv.Load "StorageBuffer" %[[INPTR]] : i32
// CHECK: %[[ADD:.+]] = spv.GroupNonUniformIAdd "Subgroup" "Reduce" %[[VAL]] : i32 // CHECK: %[[ADD:.+]] = spv.GroupNonUniformIAdd "Subgroup" "Reduce" %[[VAL]] : i32
// CHECK: %[[OUTPTR:.+]] = spv.AccessChain %[[OUTPUT]][%[[ZERO]], %[[ZERO]]] // CHECK: %[[OUTPTR:.+]] = spv.AccessChain %[[OUTPUT]][%[[ZERO]], %[[ZERO]]]
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

mlir/test/Conversion/SCFToSPIRV/for.mlir

// RUN: mlir-opt -convert-scf-to-spirv %s -o - | FileCheck %s // RUN: mlir-opt -convert-scf-to-spirv %s -o - | FileCheck %s
module attributes { module attributes {
spv.target_env = #spv.target_env< spv.target_env = #spv.target_env<
#spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}> #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
} { } {
func @loop_kernel(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) { func @loop_kernel(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
// CHECK: %[[LB:.*]] = spv.constant 4 : i32 // CHECK: %[[LB:.*]] = spv.Constant 4 : i32
%lb = constant 4 : index %lb = constant 4 : index
// CHECK: %[[UB:.*]] = spv.constant 42 : i32 // CHECK: %[[UB:.*]] = spv.Constant 42 : i32
%ub = constant 42 : index %ub = constant 42 : index
// CHECK: %[[STEP:.*]] = spv.constant 2 : i32 // CHECK: %[[STEP:.*]] = spv.Constant 2 : i32
%step = constant 2 : index %step = constant 2 : index
// CHECK: spv.loop { // CHECK: spv.loop {
// CHECK-NEXT: spv.Branch ^[[HEADER:.*]](%[[LB]] : i32) // CHECK-NEXT: spv.Branch ^[[HEADER:.*]](%[[LB]] : i32)
// CHECK: ^[[HEADER]](%[[INDVAR:.*]]: i32): // CHECK: ^[[HEADER]](%[[INDVAR:.*]]: i32):
// CHECK: %[[CMP:.*]] = spv.SLessThan %[[INDVAR]], %[[UB]] : i32 // CHECK: %[[CMP:.*]] = spv.SLessThan %[[INDVAR]], %[[UB]] : i32
// CHECK: spv.BranchConditional %[[CMP]], ^[[BODY:.*]], ^[[MERGE:.*]] // CHECK: spv.BranchConditional %[[CMP]], ^[[BODY:.*]], ^[[MERGE:.*]]
// CHECK: ^[[BODY]]: // CHECK: ^[[BODY]]:
// CHECK: %[[ZERO1:.*]] = spv.constant 0 : i32 // CHECK: %[[ZERO1:.*]] = spv.Constant 0 : i32
// CHECK: %[[OFFSET1:.*]] = spv.constant 0 : i32 // CHECK: %[[OFFSET1:.*]] = spv.Constant 0 : i32
// CHECK: %[[STRIDE1:.*]] = spv.constant 1 : i32 // CHECK: %[[STRIDE1:.*]] = spv.Constant 1 : i32
// CHECK: %[[UPDATE1:.*]] = spv.IMul %[[STRIDE1]], %[[INDVAR]] : i32 // CHECK: %[[UPDATE1:.*]] = spv.IMul %[[STRIDE1]], %[[INDVAR]] : i32
// CHECK: %[[INDEX1:.*]] = spv.IAdd %[[OFFSET1]], %[[UPDATE1]] : i32 // CHECK: %[[INDEX1:.*]] = spv.IAdd %[[OFFSET1]], %[[UPDATE1]] : i32
// CHECK: spv.AccessChain {{%.*}}{{\[}}%[[ZERO1]], %[[INDEX1]]{{\]}} // CHECK: spv.AccessChain {{%.*}}{{\[}}%[[ZERO1]], %[[INDEX1]]{{\]}}
// CHECK: %[[ZERO2:.*]] = spv.constant 0 : i32 // CHECK: %[[ZERO2:.*]] = spv.Constant 0 : i32
// CHECK: %[[OFFSET2:.*]] = spv.constant 0 : i32 // CHECK: %[[OFFSET2:.*]] = spv.Constant 0 : i32
// CHECK: %[[STRIDE2:.*]] = spv.constant 1 : i32 // CHECK: %[[STRIDE2:.*]] = spv.Constant 1 : i32
// CHECK: %[[UPDATE2:.*]] = spv.IMul %[[STRIDE2]], %[[INDVAR]] : i32 // CHECK: %[[UPDATE2:.*]] = spv.IMul %[[STRIDE2]], %[[INDVAR]] : i32
// CHECK: %[[INDEX2:.*]] = spv.IAdd %[[OFFSET2]], %[[UPDATE2]] : i32 // CHECK: %[[INDEX2:.*]] = spv.IAdd %[[OFFSET2]], %[[UPDATE2]] : i32
// CHECK: spv.AccessChain {{%.*}}[%[[ZERO2]], %[[INDEX2]]] // CHECK: spv.AccessChain {{%.*}}[%[[ZERO2]], %[[INDEX2]]]
// CHECK: %[[INCREMENT:.*]] = spv.IAdd %[[INDVAR]], %[[STEP]] : i32 // CHECK: %[[INCREMENT:.*]] = spv.IAdd %[[INDVAR]], %[[STEP]] : i32
// CHECK: spv.Branch ^[[HEADER]](%[[INCREMENT]] : i32) // CHECK: spv.Branch ^[[HEADER]](%[[INCREMENT]] : i32)
// CHECK: ^[[MERGE]] // CHECK: ^[[MERGE]]
// CHECK: spv.mlir.merge // CHECK: spv.mlir.merge
// CHECK: } // CHECK: }
scf.for %arg4 = %lb to %ub step %step { scf.for %arg4 = %lb to %ub step %step {
%1 = load %arg2[%arg4] : memref<10xf32> %1 = load %arg2[%arg4] : memref<10xf32>
store %1, %arg3[%arg4] : memref<10xf32> store %1, %arg3[%arg4] : memref<10xf32>
} }
return return
} }
// CHECK-LABEL: @loop_yield // CHECK-LABEL: @loop_yield
func @loop_yield(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) { func @loop_yield(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
// CHECK: %[[LB:.*]] = spv.constant 4 : i32 // CHECK: %[[LB:.*]] = spv.Constant 4 : i32
%lb = constant 4 : index %lb = constant 4 : index
// CHECK: %[[UB:.*]] = spv.constant 42 : i32 // CHECK: %[[UB:.*]] = spv.Constant 42 : i32
%ub = constant 42 : index %ub = constant 42 : index
// CHECK: %[[STEP:.*]] = spv.constant 2 : i32 // CHECK: %[[STEP:.*]] = spv.Constant 2 : i32
%step = constant 2 : index %step = constant 2 : index
// CHECK: %[[INITVAR1:.*]] = spv.constant 0.000000e+00 : f32 // CHECK: %[[INITVAR1:.*]] = spv.Constant 0.000000e+00 : f32
%s0 = constant 0.0 : f32 %s0 = constant 0.0 : f32
// CHECK: %[[INITVAR2:.*]] = spv.constant 1.000000e+00 : f32 // CHECK: %[[INITVAR2:.*]] = spv.Constant 1.000000e+00 : f32
%s1 = constant 1.0 : f32 %s1 = constant 1.0 : f32
// CHECK: %[[VAR1:.*]] = spv.Variable : !spv.ptr<f32, Function> // CHECK: %[[VAR1:.*]] = spv.Variable : !spv.ptr<f32, Function>
// CHECK: %[[VAR2:.*]] = spv.Variable : !spv.ptr<f32, Function> // CHECK: %[[VAR2:.*]] = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.loop { // CHECK: spv.loop {
// CHECK: spv.Branch ^[[HEADER:.*]](%[[LB]], %[[INITVAR1]], %[[INITVAR2]] : i32, f32, f32) // CHECK: spv.Branch ^[[HEADER:.*]](%[[LB]], %[[INITVAR1]], %[[INITVAR2]] : i32, f32, f32)
// CHECK: ^[[HEADER]](%[[INDVAR:.*]]: i32, %[[CARRIED1:.*]]: f32, %[[CARRIED2:.*]]: f32): // CHECK: ^[[HEADER]](%[[INDVAR:.*]]: i32, %[[CARRIED1:.*]]: f32, %[[CARRIED2:.*]]: f32):
// CHECK: %[[CMP:.*]] = spv.SLessThan %[[INDVAR]], %[[UB]] : i32 // CHECK: %[[CMP:.*]] = spv.SLessThan %[[INDVAR]], %[[UB]] : i32
// CHECK: spv.BranchConditional %[[CMP]], ^[[BODY:.*]], ^[[MERGE:.*]] // CHECK: spv.BranchConditional %[[CMP]], ^[[BODY:.*]], ^[[MERGE:.*]]
Show All 23 Lines

mlir/test/Conversion/SCFToSPIRV/if.mlir

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
// CHECK-LABEL: @simple_if_yield // CHECK-LABEL: @simple_if_yield
func @simple_if_yield(%arg2 : memref<10xf32>, %arg3 : i1) { func @simple_if_yield(%arg2 : memref<10xf32>, %arg3 : i1) {
// CHECK: %[[VAR1:.*]] = spv.Variable : !spv.ptr<f32, Function> // CHECK: %[[VAR1:.*]] = spv.Variable : !spv.ptr<f32, Function>
// CHECK: %[[VAR2:.*]] = spv.Variable : !spv.ptr<f32, Function> // CHECK: %[[VAR2:.*]] = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
// CHECK-NEXT: spv.BranchConditional {{%.*}}, [[TRUE:\^.*]], [[FALSE:\^.*]] // CHECK-NEXT: spv.BranchConditional {{%.*}}, [[TRUE:\^.*]], [[FALSE:\^.*]]
// CHECK-NEXT: [[TRUE]]: // CHECK-NEXT: [[TRUE]]:
// CHECK: %[[RET1TRUE:.*]] = spv.constant 0.000000e+00 : f32 // CHECK: %[[RET1TRUE:.*]] = spv.Constant 0.000000e+00 : f32
// CHECK: %[[RET2TRUE:.*]] = spv.constant 1.000000e+00 : f32 // CHECK: %[[RET2TRUE:.*]] = spv.Constant 1.000000e+00 : f32
// CHECK-DAG: spv.Store "Function" %[[VAR1]], %[[RET1TRUE]] : f32 // CHECK-DAG: spv.Store "Function" %[[VAR1]], %[[RET1TRUE]] : f32
// CHECK-DAG: spv.Store "Function" %[[VAR2]], %[[RET2TRUE]] : f32 // CHECK-DAG: spv.Store "Function" %[[VAR2]], %[[RET2TRUE]] : f32
// CHECK: spv.Branch ^[[MERGE:.*]] // CHECK: spv.Branch ^[[MERGE:.*]]
// CHECK-NEXT: [[FALSE]]: // CHECK-NEXT: [[FALSE]]:
// CHECK: %[[RET2FALSE:.*]] = spv.constant 2.000000e+00 : f32 // CHECK: %[[RET2FALSE:.*]] = spv.Constant 2.000000e+00 : f32
// CHECK: %[[RET1FALSE:.*]] = spv.constant 3.000000e+00 : f32 // CHECK: %[[RET1FALSE:.*]] = spv.Constant 3.000000e+00 : f32
// CHECK-DAG: spv.Store "Function" %[[VAR1]], %[[RET1FALSE]] : f32 // CHECK-DAG: spv.Store "Function" %[[VAR1]], %[[RET1FALSE]] : f32
// CHECK-DAG: spv.Store "Function" %[[VAR2]], %[[RET2FALSE]] : f32 // CHECK-DAG: spv.Store "Function" %[[VAR2]], %[[RET2FALSE]] : f32
// CHECK: spv.Branch ^[[MERGE]] // CHECK: spv.Branch ^[[MERGE]]
// CHECK-NEXT: ^[[MERGE]]: // CHECK-NEXT: ^[[MERGE]]:
// CHECK: spv.mlir.merge // CHECK: spv.mlir.merge
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-DAG: %[[OUT1:.*]] = spv.Load "Function" %[[VAR1]] : f32 // CHECK-DAG: %[[OUT1:.*]] = spv.Load "Function" %[[VAR1]] : f32
// CHECK-DAG: %[[OUT2:.*]] = spv.Load "Function" %[[VAR2]] : f32 // CHECK-DAG: %[[OUT2:.*]] = spv.Load "Function" %[[VAR2]] : f32
▲ Show 20 Lines • Show All 52 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) : i1 // CHECK: llvm.mlir.constant(true) : i1
%0 = spv.constant true %0 = spv.Constant true
// CHECK: llvm.mlir.constant(false) : 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>) : vector<2xi1> // CHECK: llvm.mlir.constant(dense<[true, false]> : vector<2xi1>) : vector<2xi1>
%0 = spv.constant dense<[true, false]> : vector<2xi1> %0 = spv.Constant dense<[true, false]> : vector<2xi1>
// CHECK: llvm.mlir.constant(dense<false> : vector<3xi1>) : vector<3xi1> // CHECK: llvm.mlir.constant(dense<false> : vector<3xi1>) : vector<3xi1>
%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) : i8 // CHECK: llvm.mlir.constant(0 : i8) : i8
%0 = spv.constant 0 : i8 %0 = spv.Constant 0 : i8
// CHECK: llvm.mlir.constant(-5 : i64) : i64 // CHECK: llvm.mlir.constant(-5 : i64) : i64
%1 = spv.constant -5 : si64 %1 = spv.Constant -5 : si64
// CHECK: llvm.mlir.constant(10 : i16) : 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>) : vector<2xi32> // CHECK: llvm.mlir.constant(dense<[2, 3]> : vector<2xi32>) : vector<2xi32>
%0 = spv.constant dense<[2, 3]> : vector<2xi32> %0 = spv.Constant dense<[2, 3]> : vector<2xi32>
// CHECK: llvm.mlir.constant(dense<-4> : vector<2xi32>) : vector<2xi32> // CHECK: llvm.mlir.constant(dense<-4> : vector<2xi32>) : vector<2xi32>
%1 = spv.constant dense<-4> : vector<2xsi32> %1 = spv.Constant dense<-4> : vector<2xsi32>
// CHECK: llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : vector<3xi32> // CHECK: llvm.mlir.constant(dense<[2, 3, 4]> : vector<3xi32>) : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xui32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xui32>
spv.Return spv.Return
} }
// CHECK-LABEL: @float_constant_scalar // CHECK-LABEL: @float_constant_scalar
spv.func @float_constant_scalar() "None" { spv.func @float_constant_scalar() "None" {
// CHECK: llvm.mlir.constant(5.000000e+00 : f16) : f16 // CHECK: llvm.mlir.constant(5.000000e+00 : f16) : f16
%0 = spv.constant 5.000000e+00 : f16 %0 = spv.Constant 5.000000e+00 : f16
// CHECK: llvm.mlir.constant(5.000000e+00 : f64) : f64 // CHECK: llvm.mlir.constant(5.000000e+00 : f64) : f64
%1 = spv.constant 5.000000e+00 : f64 %1 = spv.Constant 5.000000e+00 : f64
spv.Return spv.Return
} }
// CHECK-LABEL: @float_constant_vector // CHECK-LABEL: @float_constant_vector
spv.func @float_constant_vector() "None" { spv.func @float_constant_vector() "None" {
// CHECK: llvm.mlir.constant(dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32>) : vector<2xf32> // CHECK: llvm.mlir.constant(dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32>) : vector<2xf32>
%0 = spv.constant dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32> %0 = spv.Constant dense<[2.000000e+00, 3.000000e+00]> : vector<2xf32>
spv.Return spv.Return
} }

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

// RUN: mlir-opt -convert-spirv-to-llvm -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -convert-spirv-to-llvm -split-input-file -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Branch // spv.Branch
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @branch_without_arguments() -> () "None" { spv.func @branch_without_arguments() -> () "None" {
// CHECK: llvm.br ^bb1 // CHECK: llvm.br ^bb1
spv.Branch ^label spv.Branch ^label
// 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(%{{.*}}, %{{.*}} : i32, i1) // CHECK: llvm.br ^bb1(%{{.*}}, %{{.*}} : i32, i1)
spv.Branch ^label(%0, %1: i32, i1) spv.Branch ^label(%0, %1: i32, i1)
// CHECK: ^bb1(%{{.*}}: i32, %{{.*}}: 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) : 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) : 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) : i1 // CHECK: %[[COND2:.*]] = llvm.mlir.constant(false) : i1
%false = spv.constant false %false = spv.Constant false
// CHECK: llvm.cond_br %[[COND1]], ^bb1(%{{.*}}, %[[COND2]] : i32, 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(%{{.*}}: i32, %[[COND:.*]]: 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(%{{.*}}, %{{.*}} : i32, 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:
Show All 37 Lines spv.func @infinite_loop(%count : i32) -> () "None" {
// CHECK: llvm.br ^[[BB1:.*]] // CHECK: llvm.br ^[[BB1:.*]]
// CHECK: ^[[BB4]]: // CHECK: ^[[BB4]]:
// CHECK: llvm.br ^[[BB5:.*]] // CHECK: llvm.br ^[[BB5:.*]]
// CHECK: ^[[BB5]]: // CHECK: ^[[BB5]]:
// CHECK: llvm.return // CHECK: llvm.return
spv.loop { spv.loop {
spv.Branch ^header spv.Branch ^header
^header: ^header:
%cond = spv.constant true %cond = spv.Constant true
spv.BranchConditional %cond, ^body, ^merge spv.BranchConditional %cond, ^body, ^merge
^body: ^body:
// Do nothing // Do nothing
spv.Branch ^continue spv.Branch ^continue
^continue: ^continue:
// Do nothing // Do nothing
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
Show All 13 Linesspv.module Logical GLSL450 {
spv.func @selection_empty() -> () "None" { spv.func @selection_empty() -> () "None" {
// CHECK: llvm.return // CHECK: llvm.return
spv.selection { spv.selection {
} }
spv.Return spv.Return
} }
spv.func @selection_with_merge_block_only() -> () "None" { spv.func @selection_with_merge_block_only() -> () "None" {
%cond = spv.constant true %cond = spv.Constant true
// CHECK: llvm.return // CHECK: llvm.return
spv.selection { 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) : 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) : 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) : 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]] : 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:.*]]: i32): // CHECK: ^bb1(%[[ARG:.*]]: i32):
^true(%arg1: i32): ^true(%arg1: i32):
// CHECK: llvm.return %[[ARG]] : 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/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) : 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) : i32 // CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: llvm.getelementptr %{{.*}}[%[[ZERO]], %[[ONE]], %[[ONE]]] : (!llvm.ptr<struct<packed (f32, array<4 x f32>)>>, i32, i32, i32) -> !llvm.ptr<f32> // CHECK: llvm.getelementptr %{{.*}}[%[[ZERO]], %[[ONE]], %[[ONE]]] : (!llvm.ptr<struct<packed (f32, array<4 x f32>)>>, i32, i32, i32) -> !llvm.ptr<f32>
%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
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Lines
} }
// 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) : i64 // CHECK: %[[VALUE:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x i64 : (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) : i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca %[[SIZE]] x vector<3xf32> : (i32) -> !llvm.ptr<vector<3xf32>> // CHECK: llvm.alloca %[[SIZE]] x vector<3xf32> : (i32) -> !llvm.ptr<vector<3xf32>>
%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>) : vector<3xi1> // CHECK: %[[VALUE:.*]] = llvm.mlir.constant(dense<false> : vector<3xi1>) : vector<3xi1>
// CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x vector<3xi1> : (i32) -> !llvm.ptr<vector<3xi1>> // CHECK: %[[ALLOCATED:.*]] = llvm.alloca %[[SIZE]] x vector<3xi1> : (i32) -> !llvm.ptr<vector<3xi1>>
// CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<vector<3xi1>> // CHECK: llvm.store %[[VALUE]], %[[ALLOCATED]] : !llvm.ptr<vector<3xi1>>
%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) : i32 // CHECK: %[[SIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca %[[SIZE]] x !llvm.array<10 x i32> : (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/StandardToSPIRV/std-ops-to-spirv.mlir

Show First 20 Lines • Show All 404 Lines • ▼ Show 20 Lines
module attributes { module attributes {
spv.target_env = #spv.target_env< spv.target_env = #spv.target_env<
#spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, {}> #spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, {}>
} { } {
// CHECK-LABEL: @constant // CHECK-LABEL: @constant
func @constant() { func @constant() {
// CHECK: spv.constant true // CHECK: spv.Constant true
%0 = constant true %0 = constant true
// CHECK: spv.constant 42 : i32 // CHECK: spv.Constant 42 : i32
%1 = constant 42 : i32 %1 = constant 42 : i32
// CHECK: spv.constant 5.000000e-01 : f32 // CHECK: spv.Constant 5.000000e-01 : f32
%2 = constant 0.5 : f32 %2 = constant 0.5 : f32
// CHECK: spv.constant dense<[2, 3]> : vector<2xi32> // CHECK: spv.Constant dense<[2, 3]> : vector<2xi32>
%3 = constant dense<[2, 3]> : vector<2xi32> %3 = constant dense<[2, 3]> : vector<2xi32>
// CHECK: spv.constant 1 : i32 // CHECK: spv.Constant 1 : i32
%4 = constant 1 : index %4 = constant 1 : index
// CHECK: spv.constant dense<1> : tensor<6xi32> : !spv.array<6 x i32, stride=4> // CHECK: spv.Constant dense<1> : tensor<6xi32> : !spv.array<6 x i32, stride=4>
%5 = constant dense<1> : tensor<2x3xi32> %5 = constant dense<1> : tensor<2x3xi32>
// CHECK: spv.constant dense<1.000000e+00> : tensor<6xf32> : !spv.array<6 x f32, stride=4> // CHECK: spv.Constant dense<1.000000e+00> : tensor<6xf32> : !spv.array<6 x f32, stride=4>
%6 = constant dense<1.0> : tensor<2x3xf32> %6 = constant dense<1.0> : tensor<2x3xf32>
// CHECK: spv.constant dense<{{\[}}1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf32> : !spv.array<6 x f32, stride=4> // CHECK: spv.Constant dense<{{\[}}1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf32> : !spv.array<6 x f32, stride=4>
%7 = constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> %7 = constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32>
// CHECK: spv.constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spv.array<6 x i32, stride=4> // CHECK: spv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spv.array<6 x i32, stride=4>
%8 = constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> %8 = constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>
// CHECK: spv.constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spv.array<6 x i32, stride=4> // CHECK: spv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spv.array<6 x i32, stride=4>
%9 = constant dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32> %9 = constant dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32>
// CHECK: spv.constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spv.array<6 x i32, stride=4> // CHECK: spv.Constant dense<{{\[}}1, 2, 3, 4, 5, 6]> : tensor<6xi32> : !spv.array<6 x i32, stride=4>
%10 = constant dense<[1, 2, 3, 4, 5, 6]> : tensor<6xi32> %10 = constant dense<[1, 2, 3, 4, 5, 6]> : tensor<6xi32>
return return
} }
// CHECK-LABEL: @constant_16bit // CHECK-LABEL: @constant_16bit
func @constant_16bit() { func @constant_16bit() {
// CHECK: spv.constant 4 : i16 // CHECK: spv.Constant 4 : i16
%0 = constant 4 : i16 %0 = constant 4 : i16
// CHECK: spv.constant 5.000000e+00 : f16 // CHECK: spv.Constant 5.000000e+00 : f16
%1 = constant 5.0 : f16 %1 = constant 5.0 : f16
// CHECK: spv.constant dense<[2, 3]> : vector<2xi16> // CHECK: spv.Constant dense<[2, 3]> : vector<2xi16>
%2 = constant dense<[2, 3]> : vector<2xi16> %2 = constant dense<[2, 3]> : vector<2xi16>
// CHECK: spv.constant dense<4.000000e+00> : tensor<5xf16> : !spv.array<5 x f16, stride=2> // CHECK: spv.Constant dense<4.000000e+00> : tensor<5xf16> : !spv.array<5 x f16, stride=2>
%3 = constant dense<4.0> : tensor<5xf16> %3 = constant dense<4.0> : tensor<5xf16>
return return
} }
// CHECK-LABEL: @constant_64bit // CHECK-LABEL: @constant_64bit
func @constant_64bit() { func @constant_64bit() {
// CHECK: spv.constant 4 : i64 // CHECK: spv.Constant 4 : i64
%0 = constant 4 : i64 %0 = constant 4 : i64
// CHECK: spv.constant 5.000000e+00 : f64 // CHECK: spv.Constant 5.000000e+00 : f64
%1 = constant 5.0 : f64 %1 = constant 5.0 : f64
// CHECK: spv.constant dense<[2, 3]> : vector<2xi64> // CHECK: spv.Constant dense<[2, 3]> : vector<2xi64>
%2 = constant dense<[2, 3]> : vector<2xi64> %2 = constant dense<[2, 3]> : vector<2xi64>
// CHECK: spv.constant dense<4.000000e+00> : tensor<5xf64> : !spv.array<5 x f64, stride=8> // CHECK: spv.Constant dense<4.000000e+00> : tensor<5xf64> : !spv.array<5 x f64, stride=8>
%3 = constant dense<4.0> : tensor<5xf64> %3 = constant dense<4.0> : tensor<5xf64>
return return
} }
} // end module } // end module
// ----- // -----
// Check that constants are converted to 32-bit when no special capability. // Check that constants are converted to 32-bit when no special capability.
module attributes { module attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, {}>
} { } {
// CHECK-LABEL: @constant_16bit // CHECK-LABEL: @constant_16bit
func @constant_16bit() { func @constant_16bit() {
// CHECK: spv.constant 4 : i32 // CHECK: spv.Constant 4 : i32
%0 = constant 4 : i16 %0 = constant 4 : i16
// CHECK: spv.constant 5.000000e+00 : f32 // CHECK: spv.Constant 5.000000e+00 : f32
%1 = constant 5.0 : f16 %1 = constant 5.0 : f16
// CHECK: spv.constant dense<[2, 3]> : vector<2xi32> // CHECK: spv.Constant dense<[2, 3]> : vector<2xi32>
%2 = constant dense<[2, 3]> : vector<2xi16> %2 = constant dense<[2, 3]> : vector<2xi16>
// CHECK: spv.constant dense<4.000000e+00> : tensor<5xf32> : !spv.array<5 x f32, stride=4> // CHECK: spv.Constant dense<4.000000e+00> : tensor<5xf32> : !spv.array<5 x f32, stride=4>
%3 = constant dense<4.0> : tensor<5xf16> %3 = constant dense<4.0> : tensor<5xf16>
// CHECK: spv.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spv.array<4 x f32, stride=4> // CHECK: spv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spv.array<4 x f32, stride=4>
%4 = constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16> %4 = constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16>
return return
} }
// CHECK-LABEL: @constant_64bit // CHECK-LABEL: @constant_64bit
func @constant_64bit() { func @constant_64bit() {
// CHECK: spv.constant 4 : i32 // CHECK: spv.Constant 4 : i32
%0 = constant 4 : i64 %0 = constant 4 : i64
// CHECK: spv.constant 5.000000e+00 : f32 // CHECK: spv.Constant 5.000000e+00 : f32
%1 = constant 5.0 : f64 %1 = constant 5.0 : f64
// CHECK: spv.constant dense<[2, 3]> : vector<2xi32> // CHECK: spv.Constant dense<[2, 3]> : vector<2xi32>
%2 = constant dense<[2, 3]> : vector<2xi64> %2 = constant dense<[2, 3]> : vector<2xi64>
// CHECK: spv.constant dense<4.000000e+00> : tensor<5xf32> : !spv.array<5 x f32, stride=4> // CHECK: spv.Constant dense<4.000000e+00> : tensor<5xf32> : !spv.array<5 x f32, stride=4>
%3 = constant dense<4.0> : tensor<5xf64> %3 = constant dense<4.0> : tensor<5xf64>
// CHECK: spv.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spv.array<4 x f32, stride=4> // CHECK: spv.Constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00]> : tensor<4xf32> : !spv.array<4 x f32, stride=4>
%4 = constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16> %4 = constant dense<[[1.0, 2.0], [3.0, 4.0]]> : tensor<2x2xf16>
return return
} }
// CHECK-LABEL: @corner_cases // CHECK-LABEL: @corner_cases
func @corner_cases() { func @corner_cases() {
// CHECK: %{{.*}} = spv.constant -1 : i32 // CHECK: %{{.*}} = spv.Constant -1 : i32
%0 = constant 4294967295 : i64 // 2^32 - 1 %0 = constant 4294967295 : i64 // 2^32 - 1
// CHECK: %{{.*}} = spv.constant 2147483647 : i32 // CHECK: %{{.*}} = spv.Constant 2147483647 : i32
%1 = constant 2147483647 : i64 // 2^31 - 1 %1 = constant 2147483647 : i64 // 2^31 - 1
// CHECK: %{{.*}} = spv.constant -2147483648 : i32 // CHECK: %{{.*}} = spv.Constant -2147483648 : i32
%2 = constant 2147483648 : i64 // 2^31 %2 = constant 2147483648 : i64 // 2^31
// CHECK: %{{.*}} = spv.constant -2147483648 : i32 // CHECK: %{{.*}} = spv.Constant -2147483648 : i32
%3 = constant -2147483648 : i64 // -2^31 %3 = constant -2147483648 : i64 // -2^31
// CHECK: %{{.*}} = spv.constant -1 : i32 // CHECK: %{{.*}} = spv.Constant -1 : i32
%5 = constant -1 : i64 %5 = constant -1 : i64
// CHECK: %{{.*}} = spv.constant -2 : i32 // CHECK: %{{.*}} = spv.Constant -2 : i32
%6 = constant -2 : i64 %6 = constant -2 : i64
// CHECK: %{{.*}} = spv.constant -1 : i32 // CHECK: %{{.*}} = spv.Constant -1 : i32
%7 = constant -1 : index %7 = constant -1 : index
// CHECK: %{{.*}} = spv.constant -2 : i32 // CHECK: %{{.*}} = spv.Constant -2 : i32
%8 = constant -2 : index %8 = constant -2 : index
// CHECK: spv.constant false // CHECK: spv.Constant false
%9 = constant false %9 = constant false
// CHECK: spv.constant true // CHECK: spv.Constant true
%10 = constant true %10 = constant true
return return
} }
// CHECK-LABEL: @unsupported_cases // CHECK-LABEL: @unsupported_cases
func @unsupported_cases() { func @unsupported_cases() {
// CHECK: %{{.*}} = constant 4294967296 : i64 // CHECK: %{{.*}} = constant 4294967296 : i64
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines
func @uitofp_i32_f32(%arg0 : i32) -> f32 { func @uitofp_i32_f32(%arg0 : i32) -> f32 {
// CHECK: spv.ConvertUToF %{{.*}} : i32 to f32 // CHECK: spv.ConvertUToF %{{.*}} : i32 to f32
%0 = std.uitofp %arg0 : i32 to f32 %0 = std.uitofp %arg0 : i32 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i1_f32 // CHECK-LABEL: @uitofp_i1_f32
func @uitofp_i1_f32(%arg0 : i1) -> f32 { func @uitofp_i1_f32(%arg0 : i1) -> f32 {
// CHECK: %[[ZERO:.+]] = spv.constant 0.000000e+00 : f32 // CHECK: %[[ZERO:.+]] = spv.Constant 0.000000e+00 : f32
// CHECK: %[[ONE:.+]] = spv.constant 1.000000e+00 : f32 // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f32 // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f32
%0 = std.uitofp %arg0 : i1 to f32 %0 = std.uitofp %arg0 : i1 to f32
return %0 : f32 return %0 : f32
} }
// CHECK-LABEL: @uitofp_i1_f64 // CHECK-LABEL: @uitofp_i1_f64
func @uitofp_i1_f64(%arg0 : i1) -> f64 { func @uitofp_i1_f64(%arg0 : i1) -> f64 {
// CHECK: %[[ZERO:.+]] = spv.constant 0.000000e+00 : f64 // CHECK: %[[ZERO:.+]] = spv.Constant 0.000000e+00 : f64
// CHECK: %[[ONE:.+]] = spv.constant 1.000000e+00 : f64 // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f64
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f64 // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, f64
%0 = std.uitofp %arg0 : i1 to f64 %0 = std.uitofp %arg0 : i1 to f64
return %0 : f64 return %0 : f64
} }
// CHECK-LABEL: @uitofp_vec_i1_f32 // CHECK-LABEL: @uitofp_vec_i1_f32
func @uitofp_vec_i1_f32(%arg0 : vector<4xi1>) -> vector<4xf32> { func @uitofp_vec_i1_f32(%arg0 : vector<4xi1>) -> vector<4xf32> {
// CHECK: %[[ZERO:.+]] = spv.constant dense<0.000000e+00> : vector<4xf32> // CHECK: %[[ZERO:.+]] = spv.Constant dense<0.000000e+00> : vector<4xf32>
// CHECK: %[[ONE:.+]] = spv.constant dense<1.000000e+00> : vector<4xf32> // CHECK: %[[ONE:.+]] = spv.Constant dense<1.000000e+00> : vector<4xf32>
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf32> // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf32>
%0 = std.uitofp %arg0 : vector<4xi1> to vector<4xf32> %0 = std.uitofp %arg0 : vector<4xi1> to vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// CHECK-LABEL: @uitofp_vec_i1_f64 // CHECK-LABEL: @uitofp_vec_i1_f64
spv.func @uitofp_vec_i1_f64(%arg0: vector<4xi1>) -> vector<4xf64> "None" { spv.func @uitofp_vec_i1_f64(%arg0: vector<4xi1>) -> vector<4xf64> "None" {
// CHECK: %[[ZERO:.+]] = spv.constant dense<0.000000e+00> : vector<4xf64> // CHECK: %[[ZERO:.+]] = spv.Constant dense<0.000000e+00> : vector<4xf64>
// CHECK: %[[ONE:.+]] = spv.constant dense<1.000000e+00> : vector<4xf64> // CHECK: %[[ONE:.+]] = spv.Constant dense<1.000000e+00> : vector<4xf64>
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf64> // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xf64>
%0 = spv.constant dense<0.000000e+00> : vector<4xf64> %0 = spv.Constant dense<0.000000e+00> : vector<4xf64>
%1 = spv.constant dense<1.000000e+00> : vector<4xf64> %1 = spv.Constant dense<1.000000e+00> : vector<4xf64>
%2 = spv.Select %arg0, %1, %0 : vector<4xi1>, vector<4xf64> %2 = spv.Select %arg0, %1, %0 : vector<4xi1>, vector<4xf64>
spv.ReturnValue %2 : vector<4xf64> spv.ReturnValue %2 : vector<4xf64>
} }
// CHECK-LABEL: @sexti1 // CHECK-LABEL: @sexti1
func @sexti1(%arg0: i16) -> i64 { func @sexti1(%arg0: i16) -> i64 {
// CHECK: spv.SConvert %{{.*}} : i16 to i64 // CHECK: spv.SConvert %{{.*}} : i16 to i64
%0 = std.sexti %arg0 : i16 to i64 %0 = std.sexti %arg0 : i16 to i64
Show All 18 Lines
func @zexti2(%arg0 : i32) -> i64 { func @zexti2(%arg0 : i32) -> i64 {
// CHECK: spv.UConvert %{{.*}} : i32 to i64 // CHECK: spv.UConvert %{{.*}} : i32 to i64
%0 = std.zexti %arg0 : i32 to i64 %0 = std.zexti %arg0 : i32 to i64
return %0 : i64 return %0 : i64
} }
// CHECK-LABEL: @zexti3 // CHECK-LABEL: @zexti3
func @zexti3(%arg0 : i1) -> i32 { func @zexti3(%arg0 : i1) -> i32 {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[ONE:.+]] = spv.constant 1 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, i32 // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : i1, i32
%0 = std.zexti %arg0 : i1 to i32 %0 = std.zexti %arg0 : i1 to i32
return %0 : i32 return %0 : i32
} }
// CHECK-LABEL: @zexti4 // CHECK-LABEL: @zexti4
func @zexti4(%arg0 : vector<4xi1>) -> vector<4xi32> { func @zexti4(%arg0 : vector<4xi1>) -> vector<4xi32> {
// CHECK: %[[ZERO:.+]] = spv.constant dense<0> : vector<4xi32> // CHECK: %[[ZERO:.+]] = spv.Constant dense<0> : vector<4xi32>
// CHECK: %[[ONE:.+]] = spv.constant dense<1> : vector<4xi32> // CHECK: %[[ONE:.+]] = spv.Constant dense<1> : vector<4xi32>
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi32> // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi32>
%0 = std.zexti %arg0 : vector<4xi1> to vector<4xi32> %0 = std.zexti %arg0 : vector<4xi1> to vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// CHECK-LABEL: @zexti5 // CHECK-LABEL: @zexti5
func @zexti5(%arg0 : vector<4xi1>) -> vector<4xi64> { func @zexti5(%arg0 : vector<4xi1>) -> vector<4xi64> {
// CHECK: %[[ZERO:.+]] = spv.constant dense<0> : vector<4xi64> // CHECK: %[[ZERO:.+]] = spv.Constant dense<0> : vector<4xi64>
// CHECK: %[[ONE:.+]] = spv.constant dense<1> : vector<4xi64> // CHECK: %[[ONE:.+]] = spv.Constant dense<1> : vector<4xi64>
// CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi64> // CHECK: spv.Select %{{.*}}, %[[ONE]], %[[ZERO]] : vector<4xi1>, vector<4xi64>
%0 = std.zexti %arg0 : vector<4xi1> to vector<4xi64> %0 = std.zexti %arg0 : vector<4xi1> to vector<4xi64>
return %0 : vector<4xi64> return %0 : vector<4xi64>
} }
// CHECK-LABEL: @trunci1 // CHECK-LABEL: @trunci1
func @trunci1(%arg0 : i64) -> i16 { func @trunci1(%arg0 : i64) -> i16 {
// CHECK: spv.SConvert %{{.*}} : i64 to i16 // CHECK: spv.SConvert %{{.*}} : i64 to i16
%0 = std.trunci %arg0 : i64 to i16 %0 = std.trunci %arg0 : i64 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: @trunci2 // CHECK-LABEL: @trunci2
func @trunci2(%arg0: i32) -> i16 { func @trunci2(%arg0: i32) -> i16 {
// CHECK: spv.SConvert %{{.*}} : i32 to i16 // CHECK: spv.SConvert %{{.*}} : i32 to i16
%0 = std.trunci %arg0 : i32 to i16 %0 = std.trunci %arg0 : i32 to i16
return %0 : i16 return %0 : i16
} }
// CHECK-LABEL: @trunc_to_i1 // CHECK-LABEL: @trunc_to_i1
func @trunc_to_i1(%arg0: i32) -> i1 { func @trunc_to_i1(%arg0: i32) -> i1 {
// CHECK: %[[MASK:.*]] = spv.constant 1 : i32 // CHECK: %[[MASK:.*]] = spv.Constant 1 : i32
// CHECK: %[[MASKED_SRC:.*]] = spv.BitwiseAnd %{{.*}}, %[[MASK]] : i32 // CHECK: %[[MASKED_SRC:.*]] = spv.BitwiseAnd %{{.*}}, %[[MASK]] : i32
// CHECK: %[[IS_ONE:.*]] = spv.IEqual %[[MASKED_SRC]], %[[MASK]] : i32 // CHECK: %[[IS_ONE:.*]] = spv.IEqual %[[MASKED_SRC]], %[[MASK]] : i32
// CHECK-DAG: %[[TRUE:.*]] = spv.constant true // CHECK-DAG: %[[TRUE:.*]] = spv.Constant true
// CHECK-DAG: %[[FALSE:.*]] = spv.constant false // CHECK-DAG: %[[FALSE:.*]] = spv.Constant false
// CHECK: spv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : i1, i1 // CHECK: spv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : i1, i1
%0 = std.trunci %arg0 : i32 to i1 %0 = std.trunci %arg0 : i32 to i1
return %0 : i1 return %0 : i1
} }
// CHECK-LABEL: @trunc_to_veci1 // CHECK-LABEL: @trunc_to_veci1
func @trunc_to_veci1(%arg0: vector<4xi32>) -> vector<4xi1> { func @trunc_to_veci1(%arg0: vector<4xi32>) -> vector<4xi1> {
// CHECK: %[[MASK:.*]] = spv.constant dense<1> : vector<4xi32> // CHECK: %[[MASK:.*]] = spv.Constant dense<1> : vector<4xi32>
// CHECK: %[[MASKED_SRC:.*]] = spv.BitwiseAnd %{{.*}}, %[[MASK]] : vector<4xi32> // CHECK: %[[MASKED_SRC:.*]] = spv.BitwiseAnd %{{.*}}, %[[MASK]] : vector<4xi32>
// CHECK: %[[IS_ONE:.*]] = spv.IEqual %[[MASKED_SRC]], %[[MASK]] : vector<4xi32> // CHECK: %[[IS_ONE:.*]] = spv.IEqual %[[MASKED_SRC]], %[[MASK]] : vector<4xi32>
// CHECK-DAG: %[[TRUE:.*]] = spv.constant dense<true> : vector<4xi1> // CHECK-DAG: %[[TRUE:.*]] = spv.Constant dense<true> : vector<4xi1>
// CHECK-DAG: %[[FALSE:.*]] = spv.constant dense<false> : vector<4xi1> // CHECK-DAG: %[[FALSE:.*]] = spv.Constant dense<false> : vector<4xi1>
// CHECK: spv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : vector<4xi1>, vector<4xi1> // CHECK: spv.Select %[[IS_ONE]], %[[TRUE]], %[[FALSE]] : vector<4xi1>, vector<4xi1>
%0 = std.trunci %arg0 : vector<4xi32> to vector<4xi1> %0 = std.trunci %arg0 : vector<4xi32> to vector<4xi1>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// CHECK-LABEL: @fptosi1 // CHECK-LABEL: @fptosi1
func @fptosi1(%arg0 : f32) -> i32 { func @fptosi1(%arg0 : f32) -> i32 {
// CHECK: spv.ConvertFToS %{{.*}} : f32 to i32 // CHECK: spv.ConvertFToS %{{.*}} : f32 to i32
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// std load/store ops // std load/store ops
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @load_store_zero_rank_float // CHECK-LABEL: @load_store_zero_rank_float
// CHECK: [[ARG0:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, // CHECK: [[ARG0:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>,
// CHECK: [[ARG1:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>) // CHECK: [[ARG1:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>)
func @load_store_zero_rank_float(%arg0: memref<f32>, %arg1: memref<f32>) { func @load_store_zero_rank_float(%arg0: memref<f32>, %arg1: memref<f32>) {
// CHECK: [[ZERO1:%.*]] = spv.constant 0 : i32 // CHECK: [[ZERO1:%.*]] = spv.Constant 0 : i32
// CHECK: spv.AccessChain [[ARG0]][ // CHECK: spv.AccessChain [[ARG0]][
// CHECK-SAME: [[ZERO1]], [[ZERO1]] // CHECK-SAME: [[ZERO1]], [[ZERO1]]
// CHECK-SAME: ] : // CHECK-SAME: ] :
// CHECK: spv.Load "StorageBuffer" %{{.*}} : f32 // CHECK: spv.Load "StorageBuffer" %{{.*}} : f32
%0 = load %arg0[] : memref<f32> %0 = load %arg0[] : memref<f32>
// CHECK: [[ZERO2:%.*]] = spv.constant 0 : i32 // CHECK: [[ZERO2:%.*]] = spv.Constant 0 : i32
// CHECK: spv.AccessChain [[ARG1]][ // CHECK: spv.AccessChain [[ARG1]][
// CHECK-SAME: [[ZERO2]], [[ZERO2]] // CHECK-SAME: [[ZERO2]], [[ZERO2]]
// CHECK-SAME: ] : // CHECK-SAME: ] :
// CHECK: spv.Store "StorageBuffer" %{{.*}} : f32 // CHECK: spv.Store "StorageBuffer" %{{.*}} : f32
store %0, %arg1[] : memref<f32> store %0, %arg1[] : memref<f32>
return return
} }
// CHECK-LABEL: @load_store_zero_rank_int // CHECK-LABEL: @load_store_zero_rank_int
// CHECK: [[ARG0:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, // CHECK: [[ARG0:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>,
// CHECK: [[ARG1:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>) // CHECK: [[ARG1:%.*]]: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>)
func @load_store_zero_rank_int(%arg0: memref<i32>, %arg1: memref<i32>) { func @load_store_zero_rank_int(%arg0: memref<i32>, %arg1: memref<i32>) {
// CHECK: [[ZERO1:%.*]] = spv.constant 0 : i32 // CHECK: [[ZERO1:%.*]] = spv.Constant 0 : i32
// CHECK: spv.AccessChain [[ARG0]][ // CHECK: spv.AccessChain [[ARG0]][
// CHECK-SAME: [[ZERO1]], [[ZERO1]] // CHECK-SAME: [[ZERO1]], [[ZERO1]]
// CHECK-SAME: ] : // CHECK-SAME: ] :
// CHECK: spv.Load "StorageBuffer" %{{.*}} : i32 // CHECK: spv.Load "StorageBuffer" %{{.*}} : i32
%0 = load %arg0[] : memref<i32> %0 = load %arg0[] : memref<i32>
// CHECK: [[ZERO2:%.*]] = spv.constant 0 : i32 // CHECK: [[ZERO2:%.*]] = spv.Constant 0 : i32
// CHECK: spv.AccessChain [[ARG1]][ // CHECK: spv.AccessChain [[ARG1]][
// CHECK-SAME: [[ZERO2]], [[ZERO2]] // CHECK-SAME: [[ZERO2]], [[ZERO2]]
// CHECK-SAME: ] : // CHECK-SAME: ] :
// CHECK: spv.Store "StorageBuffer" %{{.*}} : i32 // CHECK: spv.Store "StorageBuffer" %{{.*}} : i32
store %0, %arg1[] : memref<i32> store %0, %arg1[] : memref<i32>
return return
} }
} // end module } // end module
// ----- // -----
// Check that access chain indices are properly adjusted if non-32-bit types are // Check that access chain indices are properly adjusted if non-32-bit types are
// emulated via 32-bit types. // emulated via 32-bit types.
// TODO: Test i1 and i64 types. // TODO: Test i1 and i64 types.
module attributes { module attributes {
spv.target_env = #spv.target_env< spv.target_env = #spv.target_env<
#spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}> #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, {}>
} { } {
// CHECK-LABEL: @load_i8 // CHECK-LABEL: @load_i8
func @load_i8(%arg0: memref<i8>) { func @load_i8(%arg0: memref<i8>) {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[FOUR1:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR1:.+]] = spv.Constant 4 : i32
// CHECK: %[[QUOTIENT:.+]] = spv.SDiv %[[ZERO]], %[[FOUR1]] : i32 // CHECK: %[[QUOTIENT:.+]] = spv.SDiv %[[ZERO]], %[[FOUR1]] : i32
// CHECK: %[[PTR:.+]] = spv.AccessChain %{{.+}}[%[[ZERO]], %[[QUOTIENT]]] // CHECK: %[[PTR:.+]] = spv.AccessChain %{{.+}}[%[[ZERO]], %[[QUOTIENT]]]
// CHECK: %[[LOAD:.+]] = spv.Load "StorageBuffer" %[[PTR]] // CHECK: %[[LOAD:.+]] = spv.Load "StorageBuffer" %[[PTR]]
// CHECK: %[[FOUR2:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR2:.+]] = spv.Constant 4 : i32
// CHECK: %[[EIGHT:.+]] = spv.constant 8 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32
// CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR2]] : i32 // CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR2]] : i32
// CHECK: %[[BITS:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32 // CHECK: %[[BITS:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32
// CHECK: %[[VALUE:.+]] = spv.ShiftRightArithmetic %[[LOAD]], %[[BITS]] : i32, i32 // CHECK: %[[VALUE:.+]] = spv.ShiftRightArithmetic %[[LOAD]], %[[BITS]] : i32, i32
// CHECK: %[[MASK:.+]] = spv.constant 255 : i32 // CHECK: %[[MASK:.+]] = spv.Constant 255 : i32
// CHECK: %[[T1:.+]] = spv.BitwiseAnd %[[VALUE]], %[[MASK]] : i32 // CHECK: %[[T1:.+]] = spv.BitwiseAnd %[[VALUE]], %[[MASK]] : i32
// CHECK: %[[T2:.+]] = spv.constant 24 : i32 // CHECK: %[[T2:.+]] = spv.Constant 24 : i32
// CHECK: %[[T3:.+]] = spv.ShiftLeftLogical %[[T1]], %[[T2]] : i32, i32 // CHECK: %[[T3:.+]] = spv.ShiftLeftLogical %[[T1]], %[[T2]] : i32, i32
// CHECK: spv.ShiftRightArithmetic %[[T3]], %[[T2]] : i32, i32 // CHECK: spv.ShiftRightArithmetic %[[T3]], %[[T2]] : i32, i32
%0 = load %arg0[] : memref<i8> %0 = load %arg0[] : memref<i8>
return return
} }
// CHECK-LABEL: @load_i16 // CHECK-LABEL: @load_i16
// CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32) // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32)
func @load_i16(%arg0: memref<10xi16>, %index : index) { func @load_i16(%arg0: memref<10xi16>, %index : index) {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[OFFSET:.+]] = spv.constant 0 : i32 // CHECK: %[[OFFSET:.+]] = spv.Constant 0 : i32
// CHECK: %[[ONE:.+]] = spv.constant 1 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32
// CHECK: %[[UPDATE:.+]] = spv.IMul %[[ONE]], %[[ARG1]] : i32 // CHECK: %[[UPDATE:.+]] = spv.IMul %[[ONE]], %[[ARG1]] : i32
// CHECK: %[[FLAT_IDX:.+]] = spv.IAdd %[[OFFSET]], %[[UPDATE]] : i32 // CHECK: %[[FLAT_IDX:.+]] = spv.IAdd %[[OFFSET]], %[[UPDATE]] : i32
// CHECK: %[[TWO1:.+]] = spv.constant 2 : i32 // CHECK: %[[TWO1:.+]] = spv.Constant 2 : i32
// CHECK: %[[QUOTIENT:.+]] = spv.SDiv %[[FLAT_IDX]], %[[TWO1]] : i32 // CHECK: %[[QUOTIENT:.+]] = spv.SDiv %[[FLAT_IDX]], %[[TWO1]] : i32
// CHECK: %[[PTR:.+]] = spv.AccessChain %{{.+}}[%[[ZERO]], %[[QUOTIENT]]] // CHECK: %[[PTR:.+]] = spv.AccessChain %{{.+}}[%[[ZERO]], %[[QUOTIENT]]]
// CHECK: %[[LOAD:.+]] = spv.Load "StorageBuffer" %[[PTR]] // CHECK: %[[LOAD:.+]] = spv.Load "StorageBuffer" %[[PTR]]
// CHECK: %[[TWO2:.+]] = spv.constant 2 : i32 // CHECK: %[[TWO2:.+]] = spv.Constant 2 : i32
// CHECK: %[[SIXTEEN:.+]] = spv.constant 16 : i32 // CHECK: %[[SIXTEEN:.+]] = spv.Constant 16 : i32
// CHECK: %[[IDX:.+]] = spv.UMod %[[FLAT_IDX]], %[[TWO2]] : i32 // CHECK: %[[IDX:.+]] = spv.UMod %[[FLAT_IDX]], %[[TWO2]] : i32
// CHECK: %[[BITS:.+]] = spv.IMul %[[IDX]], %[[SIXTEEN]] : i32 // CHECK: %[[BITS:.+]] = spv.IMul %[[IDX]], %[[SIXTEEN]] : i32
// CHECK: %[[VALUE:.+]] = spv.ShiftRightArithmetic %[[LOAD]], %[[BITS]] : i32, i32 // CHECK: %[[VALUE:.+]] = spv.ShiftRightArithmetic %[[LOAD]], %[[BITS]] : i32, i32
// CHECK: %[[MASK:.+]] = spv.constant 65535 : i32 // CHECK: %[[MASK:.+]] = spv.Constant 65535 : i32
// CHECK: %[[T1:.+]] = spv.BitwiseAnd %[[VALUE]], %[[MASK]] : i32 // CHECK: %[[T1:.+]] = spv.BitwiseAnd %[[VALUE]], %[[MASK]] : i32
// CHECK: %[[T2:.+]] = spv.constant 16 : i32 // CHECK: %[[T2:.+]] = spv.Constant 16 : i32
// CHECK: %[[T3:.+]] = spv.ShiftLeftLogical %[[T1]], %[[T2]] : i32, i32 // CHECK: %[[T3:.+]] = spv.ShiftLeftLogical %[[T1]], %[[T2]] : i32, i32
// CHECK: spv.ShiftRightArithmetic %[[T3]], %[[T2]] : i32, i32 // CHECK: spv.ShiftRightArithmetic %[[T3]], %[[T2]] : i32, i32
%0 = load %arg0[%index] : memref<10xi16> %0 = load %arg0[%index] : memref<10xi16>
return return
} }
// CHECK-LABEL: @load_i32 // CHECK-LABEL: @load_i32
func @load_i32(%arg0: memref<i32>) { func @load_i32(%arg0: memref<i32>) {
Show All 11 Linesfunc @load_f32(%arg0: memref<f32>) {
// CHECK-NOT: spv.ShiftRightArithmetic // CHECK-NOT: spv.ShiftRightArithmetic
%0 = load %arg0[] : memref<f32> %0 = load %arg0[] : memref<f32>
return return
} }
// CHECK-LABEL: @store_i8 // CHECK-LABEL: @store_i8
// CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32) // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32)
func @store_i8(%arg0: memref<i8>, %value: i8) { func @store_i8(%arg0: memref<i8>, %value: i8) {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[FOUR:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR:.+]] = spv.Constant 4 : i32
// CHECK: %[[EIGHT:.+]] = spv.constant 8 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32
// CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR]] : i32 // CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR]] : i32
// CHECK: %[[OFFSET:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32 // CHECK: %[[OFFSET:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32
// CHECK: %[[MASK1:.+]] = spv.constant 255 : i32 // CHECK: %[[MASK1:.+]] = spv.Constant 255 : i32
// CHECK: %[[TMP1:.+]] = spv.ShiftLeftLogical %[[MASK1]], %[[OFFSET]] : i32, i32 // CHECK: %[[TMP1:.+]] = spv.ShiftLeftLogical %[[MASK1]], %[[OFFSET]] : i32, i32
// CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32 // CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32
// CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG1]], %[[MASK1]] : i32 // CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG1]], %[[MASK1]] : i32
// CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32 // CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32
// CHECK: %[[FOUR2:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR2:.+]] = spv.Constant 4 : i32
// CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[ZERO]], %[[FOUR2]] : i32 // CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[ZERO]], %[[FOUR2]] : i32
// CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]] // CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
// CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]] // CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
// CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]] // CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
store %value, %arg0[] : memref<i8> store %value, %arg0[] : memref<i8>
return return
} }
// CHECK-LABEL: @store_i16 // CHECK-LABEL: @store_i16
// CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32, %[[ARG2:.+]]: i32) // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32, %[[ARG2:.+]]: i32)
func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) { func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[OFFSET:.+]] = spv.constant 0 : i32 // CHECK: %[[OFFSET:.+]] = spv.Constant 0 : i32
// CHECK: %[[ONE:.+]] = spv.constant 1 : i32 // CHECK: %[[ONE:.+]] = spv.Constant 1 : i32
// CHECK: %[[UPDATE:.+]] = spv.IMul %[[ONE]], %[[ARG1]] : i32 // CHECK: %[[UPDATE:.+]] = spv.IMul %[[ONE]], %[[ARG1]] : i32
// CHECK: %[[FLAT_IDX:.+]] = spv.IAdd %[[OFFSET]], %[[UPDATE]] : i32 // CHECK: %[[FLAT_IDX:.+]] = spv.IAdd %[[OFFSET]], %[[UPDATE]] : i32
// CHECK: %[[TWO:.+]] = spv.constant 2 : i32 // CHECK: %[[TWO:.+]] = spv.Constant 2 : i32
// CHECK: %[[SIXTEEN:.+]] = spv.constant 16 : i32 // CHECK: %[[SIXTEEN:.+]] = spv.Constant 16 : i32
// CHECK: %[[IDX:.+]] = spv.UMod %[[FLAT_IDX]], %[[TWO]] : i32 // CHECK: %[[IDX:.+]] = spv.UMod %[[FLAT_IDX]], %[[TWO]] : i32
// CHECK: %[[OFFSET:.+]] = spv.IMul %[[IDX]], %[[SIXTEEN]] : i32 // CHECK: %[[OFFSET:.+]] = spv.IMul %[[IDX]], %[[SIXTEEN]] : i32
// CHECK: %[[MASK1:.+]] = spv.constant 65535 : i32 // CHECK: %[[MASK1:.+]] = spv.Constant 65535 : i32
// CHECK: %[[TMP1:.+]] = spv.ShiftLeftLogical %[[MASK1]], %[[OFFSET]] : i32, i32 // CHECK: %[[TMP1:.+]] = spv.ShiftLeftLogical %[[MASK1]], %[[OFFSET]] : i32, i32
// CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32 // CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32
// CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG2]], %[[MASK1]] : i32 // CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG2]], %[[MASK1]] : i32
// CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32 // CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32
// CHECK: %[[TWO2:.+]] = spv.constant 2 : i32 // CHECK: %[[TWO2:.+]] = spv.Constant 2 : i32
// CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[FLAT_IDX]], %[[TWO2]] : i32 // CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[FLAT_IDX]], %[[TWO2]] : i32
// CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]] // CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
// CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]] // CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
// CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]] // CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
store %value, %arg0[%index] : memref<10xi16> store %value, %arg0[%index] : memref<10xi16>
return return
} }
Show All 24 Lines
module attributes { module attributes {
spv.target_env = #spv.target_env< spv.target_env = #spv.target_env<
#spv.vce<v1.0, [Int16, StorageBuffer16BitAccess, Shader], #spv.vce<v1.0, [Int16, StorageBuffer16BitAccess, Shader],
[SPV_KHR_storage_buffer_storage_class, SPV_KHR_16bit_storage]>, {}> [SPV_KHR_storage_buffer_storage_class, SPV_KHR_16bit_storage]>, {}>
} { } {
// CHECK-LABEL: @load_i8 // CHECK-LABEL: @load_i8
func @load_i8(%arg0: memref<i8>) { func @load_i8(%arg0: memref<i8>) {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[FOUR1:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR1:.+]] = spv.Constant 4 : i32
// CHECK: %[[QUOTIENT:.+]] = spv.SDiv %[[ZERO]], %[[FOUR1]] : i32 // CHECK: %[[QUOTIENT:.+]] = spv.SDiv %[[ZERO]], %[[FOUR1]] : i32
// CHECK: %[[PTR:.+]] = spv.AccessChain %{{.+}}[%[[ZERO]], %[[QUOTIENT]]] // CHECK: %[[PTR:.+]] = spv.AccessChain %{{.+}}[%[[ZERO]], %[[QUOTIENT]]]
// CHECK: %[[LOAD:.+]] = spv.Load "StorageBuffer" %[[PTR]] // CHECK: %[[LOAD:.+]] = spv.Load "StorageBuffer" %[[PTR]]
// CHECK: %[[FOUR2:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR2:.+]] = spv.Constant 4 : i32
// CHECK: %[[EIGHT:.+]] = spv.constant 8 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32
// CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR2]] : i32 // CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR2]] : i32
// CHECK: %[[BITS:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32 // CHECK: %[[BITS:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32
// CHECK: %[[VALUE:.+]] = spv.ShiftRightArithmetic %[[LOAD]], %[[BITS]] : i32, i32 // CHECK: %[[VALUE:.+]] = spv.ShiftRightArithmetic %[[LOAD]], %[[BITS]] : i32, i32
// CHECK: %[[MASK:.+]] = spv.constant 255 : i32 // CHECK: %[[MASK:.+]] = spv.Constant 255 : i32
// CHECK: %[[T1:.+]] = spv.BitwiseAnd %[[VALUE]], %[[MASK]] : i32 // CHECK: %[[T1:.+]] = spv.BitwiseAnd %[[VALUE]], %[[MASK]] : i32
// CHECK: %[[T2:.+]] = spv.constant 24 : i32 // CHECK: %[[T2:.+]] = spv.Constant 24 : i32
// CHECK: %[[T3:.+]] = spv.ShiftLeftLogical %[[T1]], %[[T2]] : i32, i32 // CHECK: %[[T3:.+]] = spv.ShiftLeftLogical %[[T1]], %[[T2]] : i32, i32
// CHECK: spv.ShiftRightArithmetic %[[T3]], %[[T2]] : i32, i32 // CHECK: spv.ShiftRightArithmetic %[[T3]], %[[T2]] : i32, i32
%0 = load %arg0[] : memref<i8> %0 = load %arg0[] : memref<i8>
return return
} }
// CHECK-LABEL: @load_i16 // CHECK-LABEL: @load_i16
func @load_i16(%arg0: memref<i16>) { func @load_i16(%arg0: memref<i16>) {
// CHECK-NOT: spv.SDiv // CHECK-NOT: spv.SDiv
// CHECK: spv.Load // CHECK: spv.Load
// CHECK-NOT: spv.ShiftRightArithmetic // CHECK-NOT: spv.ShiftRightArithmetic
%0 = load %arg0[] : memref<i16> %0 = load %arg0[] : memref<i16>
return return
} }
// CHECK-LABEL: @store_i8 // CHECK-LABEL: @store_i8
// CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32) // CHECK: (%[[ARG0:.+]]: {{.*}}, %[[ARG1:.+]]: i32)
func @store_i8(%arg0: memref<i8>, %value: i8) { func @store_i8(%arg0: memref<i8>, %value: i8) {
// CHECK: %[[ZERO:.+]] = spv.constant 0 : i32 // CHECK: %[[ZERO:.+]] = spv.Constant 0 : i32
// CHECK: %[[FOUR:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR:.+]] = spv.Constant 4 : i32
// CHECK: %[[EIGHT:.+]] = spv.constant 8 : i32 // CHECK: %[[EIGHT:.+]] = spv.Constant 8 : i32
// CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR]] : i32 // CHECK: %[[IDX:.+]] = spv.UMod %[[ZERO]], %[[FOUR]] : i32
// CHECK: %[[OFFSET:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32 // CHECK: %[[OFFSET:.+]] = spv.IMul %[[IDX]], %[[EIGHT]] : i32
// CHECK: %[[MASK1:.+]] = spv.constant 255 : i32 // CHECK: %[[MASK1:.+]] = spv.Constant 255 : i32
// CHECK: %[[TMP1:.+]] = spv.ShiftLeftLogical %[[MASK1]], %[[OFFSET]] : i32, i32 // CHECK: %[[TMP1:.+]] = spv.ShiftLeftLogical %[[MASK1]], %[[OFFSET]] : i32, i32
// CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32 // CHECK: %[[MASK:.+]] = spv.Not %[[TMP1]] : i32
// CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG1]], %[[MASK1]] : i32 // CHECK: %[[CLAMPED_VAL:.+]] = spv.BitwiseAnd %[[ARG1]], %[[MASK1]] : i32
// CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32 // CHECK: %[[STORE_VAL:.+]] = spv.ShiftLeftLogical %[[CLAMPED_VAL]], %[[OFFSET]] : i32, i32
// CHECK: %[[FOUR2:.+]] = spv.constant 4 : i32 // CHECK: %[[FOUR2:.+]] = spv.Constant 4 : i32
// CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[ZERO]], %[[FOUR2]] : i32 // CHECK: %[[ACCESS_IDX:.+]] = spv.SDiv %[[ZERO]], %[[FOUR2]] : i32
// CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]] // CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
// CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]] // CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
// CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]] // CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
store %value, %arg0[] : memref<i8> store %value, %arg0[] : memref<i8>
return return
} }
Show All 36 Lines

mlir/test/Dialect/SPIRV/IR/composite-ops.mlir

Show First 20 Lines • Show All 107 Lines • ▼ Show 20 Linesfunc @composite_extract_no_ssa_operand() -> () {
// expected-error @+1 {{expected SSA operand}} // expected-error @+1 {{expected SSA operand}}
%0 = spv.CompositeExtract [4 : i32, 1 : i32] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract [4 : i32, 1 : i32] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_invalid_index_type_1() -> () { func @composite_extract_invalid_index_type_1() -> () {
%0 = spv.constant 10 : i32 %0 = spv.Constant 10 : i32
%1 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %1 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
%2 = spv.Load "Function" %1 ["Volatile"] : !spv.array<4x!spv.array<4xf32>> %2 = spv.Load "Function" %1 ["Volatile"] : !spv.array<4x!spv.array<4xf32>>
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
%3 = spv.CompositeExtract %2[%0] : !spv.array<4x!spv.array<4xf32>> %3 = spv.CompositeExtract %2[%0] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/control-flow-ops.mlir

// RUN: mlir-opt -allow-unregistered-dialect -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect -split-input-file -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Branch // spv.Branch
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @branch() -> () { func @branch() -> () {
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
spv.Branch ^next spv.Branch ^next
^next: ^next:
spv.Return spv.Return
} }
// ----- // -----
func @branch_argument() -> () { func @branch_argument() -> () {
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK: spv.Branch ^bb1(%{{.*}}, %{{.*}} : i32, i32) // CHECK: spv.Branch ^bb1(%{{.*}}, %{{.*}} : i32, i32)
spv.Branch ^next(%zero, %zero: i32, i32) spv.Branch ^next(%zero, %zero: i32, i32)
^next(%arg0: i32, %arg1: i32): ^next(%arg0: i32, %arg1: i32):
spv.Return spv.Return
} }
// ----- // -----
func @missing_accessor() -> () { func @missing_accessor() -> () {
// expected-error @+2 {{expected block name}} // expected-error @+2 {{expected block name}}
spv.Branch spv.Branch
} }
// ----- // -----
func @wrong_accessor_count() -> () { func @wrong_accessor_count() -> () {
%true = spv.constant true %true = spv.Constant true
// expected-error @+1 {{requires 1 successor but found 2}} // expected-error @+1 {{requires 1 successor but found 2}}
"spv.Branch"()[^one, ^two] : () -> () "spv.Branch"()[^one, ^two] : () -> ()
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BranchConditional // spv.BranchConditional
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @cond_branch() -> () { func @cond_branch() -> () {
%true = spv.constant true %true = spv.Constant true
// CHECK: spv.BranchConditional %{{.*}}, ^bb1, ^bb2 // CHECK: spv.BranchConditional %{{.*}}, ^bb1, ^bb2
spv.BranchConditional %true, ^one, ^two spv.BranchConditional %true, ^one, ^two
// CHECK: ^bb1 // CHECK: ^bb1
^one: ^one:
spv.Return spv.Return
// CHECK: ^bb2 // CHECK: ^bb2
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
func @cond_branch_argument() -> () { func @cond_branch_argument() -> () {
%true = spv.constant true %true = spv.Constant true
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK: spv.BranchConditional %{{.*}}, ^bb1(%{{.*}}, %{{.*}} : i32, i32), ^bb2 // CHECK: spv.BranchConditional %{{.*}}, ^bb1(%{{.*}}, %{{.*}} : i32, i32), ^bb2
spv.BranchConditional %true, ^true1(%zero, %zero: i32, i32), ^false1 spv.BranchConditional %true, ^true1(%zero, %zero: i32, i32), ^false1
^true1(%arg0: i32, %arg1: i32): ^true1(%arg0: i32, %arg1: i32):
// CHECK: spv.BranchConditional %{{.*}}, ^bb3, ^bb4(%{{.*}}, %{{.*}} : i32, i32) // CHECK: spv.BranchConditional %{{.*}}, ^bb3, ^bb4(%{{.*}}, %{{.*}} : i32, i32)
spv.BranchConditional %true, ^true2, ^false2(%zero, %zero: i32, i32) spv.BranchConditional %true, ^true2, ^false2(%zero, %zero: i32, i32)
^false1: ^false1:
spv.Return spv.Return
^true2: ^true2:
spv.Return spv.Return
^false2(%arg3: i32, %arg4: i32): ^false2(%arg3: i32, %arg4: i32):
spv.Return spv.Return
} }
// ----- // -----
func @cond_branch_with_weights() -> () { func @cond_branch_with_weights() -> () {
%true = spv.constant true %true = spv.Constant true
// CHECK: spv.BranchConditional %{{.*}} [5, 10] // CHECK: spv.BranchConditional %{{.*}} [5, 10]
spv.BranchConditional %true [5, 10], ^one, ^two spv.BranchConditional %true [5, 10], ^one, ^two
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
func @missing_condition() -> () { func @missing_condition() -> () {
// expected-error @+1 {{expected SSA operand}} // expected-error @+1 {{expected SSA operand}}
spv.BranchConditional ^one, ^two spv.BranchConditional ^one, ^two
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
func @wrong_condition_type() -> () { func @wrong_condition_type() -> () {
// expected-note @+1 {{prior use here}} // expected-note @+1 {{prior use here}}
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// expected-error @+1 {{use of value '%zero' expects different type than prior uses: 'i1' vs 'i32'}} // expected-error @+1 {{use of value '%zero' expects different type than prior uses: 'i1' vs 'i32'}}
spv.BranchConditional %zero, ^one, ^two spv.BranchConditional %zero, ^one, ^two
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
func @wrong_accessor_count() -> () { func @wrong_accessor_count() -> () {
%true = spv.constant true %true = spv.Constant true
// expected-error @+1 {{requires 2 successors but found 1}} // expected-error @+1 {{requires 2 successors but found 1}}
"spv.BranchConditional"(%true)[^one] {operand_segment_sizes = dense<[1, 0, 0]>: vector<3xi32>} : (i1) -> () "spv.BranchConditional"(%true)[^one] {operand_segment_sizes = dense<[1, 0, 0]>: vector<3xi32>} : (i1) -> ()
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
func @wrong_number_of_weights() -> () { func @wrong_number_of_weights() -> () {
%true = spv.constant true %true = spv.Constant true
// expected-error @+1 {{must have exactly two branch weights}} // expected-error @+1 {{must have exactly two branch weights}}
"spv.BranchConditional"(%true)[^one, ^two] {branch_weights = [1 : i32, 2 : i32, 3 : i32], "spv.BranchConditional"(%true)[^one, ^two] {branch_weights = [1 : i32, 2 : i32, 3 : i32],
operand_segment_sizes = dense<[1, 0, 0]>: vector<3xi32>} : (i1) -> () operand_segment_sizes = dense<[1, 0, 0]>: vector<3xi32>} : (i1) -> ()
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
// ----- // -----
func @weights_cannot_both_be_zero() -> () { func @weights_cannot_both_be_zero() -> () {
%true = spv.constant true %true = spv.Constant true
// expected-error @+1 {{branch weights cannot both be zero}} // expected-error @+1 {{branch weights cannot both be zero}}
spv.BranchConditional %true [0, 0], ^one, ^two spv.BranchConditional %true [0, 0], ^one, ^two
^one: ^one:
spv.Return spv.Return
^two: ^two:
spv.Return spv.Return
} }
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines spv.func @f_type_mismatch(%arg0 : i32, %arg1 : i32) -> () "None" {
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @f_type_mismatch(%arg0 : i32, %arg1 : i32) -> () "None" { spv.func @f_type_mismatch(%arg0 : i32, %arg1 : i32) -> () "None" {
%0 = spv.constant 2.0 : f32 %0 = spv.Constant 2.0 : f32
// expected-error @+1 {{operand type mismatch: expected operand type 'i32', but provided 'f32' for operand number 1}} // expected-error @+1 {{operand type mismatch: expected operand type 'i32', but provided 'f32' for operand number 1}}
spv.FunctionCall @f_type_mismatch(%arg0, %0) : (i32, f32) -> () spv.FunctionCall @f_type_mismatch(%arg0, %0) : (i32, f32) -> ()
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @f_type_mismatch(%arg0 : i32, %arg1 : i32) -> i32 "None" { spv.func @f_type_mismatch(%arg0 : i32, %arg1 : i32) -> i32 "None" {
%cst = spv.constant 0: i32 %cst = spv.Constant 0: i32
// expected-error @+1 {{result type mismatch: expected 'i32', but provided 'f32'}} // expected-error @+1 {{result type mismatch: expected 'i32', but provided 'f32'}}
%0 = spv.FunctionCall @f_type_mismatch(%arg0, %arg0) : (i32, i32) -> f32 %0 = spv.FunctionCall @f_type_mismatch(%arg0, %arg0) : (i32, i32) -> f32
spv.ReturnValue %cst: i32 spv.ReturnValue %cst: i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @f_foo(%arg0 : i32, %arg1 : i32) -> i32 "None" { spv.func @f_foo(%arg0 : i32, %arg1 : i32) -> i32 "None" {
// expected-error @+1 {{op callee function 'f_undefined' not found in nearest symbol table}} // expected-error @+1 {{op callee function 'f_undefined' not found in nearest symbol table}}
%0 = spv.FunctionCall @f_undefined(%arg0, %arg0) : (i32, i32) -> i32 %0 = spv.FunctionCall @f_undefined(%arg0, %arg0) : (i32, i32) -> i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.loop // spv.loop
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// for (int i = 0; i < count; ++i) {} // for (int i = 0; i < count; ++i) {}
func @loop(%count : i32) -> () { func @loop(%count : i32) -> () {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
// CHECK: spv.loop { // CHECK: spv.loop {
spv.loop { spv.loop {
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Lines
func @merge() -> () { func @merge() -> () {
// expected-error @+1 {{expected parent op to be 'spv.selection' or 'spv.loop'}} // expected-error @+1 {{expected parent op to be 'spv.selection' or 'spv.loop'}}
spv.mlir.merge spv.mlir.merge
} }
// ----- // -----
func @only_allowed_in_last_block(%cond : i1) -> () { func @only_allowed_in_last_block(%cond : i1) -> () {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
^then: ^then:
spv.Store "Function" %var, %one : i32 spv.Store "Function" %var, %one : i32
// expected-error @+1 {{can only be used in the last block of 'spv.selection' or 'spv.loop'}} // expected-error @+1 {{can only be used in the last block of 'spv.selection' or 'spv.loop'}}
spv.mlir.merge spv.mlir.merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
func @only_allowed_in_last_block() -> () { func @only_allowed_in_last_block() -> () {
%true = spv.constant true %true = spv.Constant true
spv.loop { spv.loop {
spv.Branch ^header spv.Branch ^header
^header: ^header:
spv.BranchConditional %true, ^body, ^merge spv.BranchConditional %true, ^body, ^merge
^body: ^body:
// expected-error @+1 {{can only be used in the last block of 'spv.selection' or 'spv.loop'}} // expected-error @+1 {{can only be used in the last block of 'spv.selection' or 'spv.loop'}}
spv.mlir.merge spv.mlir.merge
^continue: ^continue:
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines spv.selection {
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
^then: ^then:
// expected-error @+1 {{cannot be used in functions returning value}} // expected-error @+1 {{cannot be used in functions returning value}}
spv.Return spv.Return
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
spv.ReturnValue %zero: i32 spv.ReturnValue %zero: i32
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ReturnValue // spv.ReturnValue
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @ret_val() -> (i32) { func @ret_val() -> (i32) {
%0 = spv.constant 42 : i32 %0 = spv.Constant 42 : i32
// CHECK: spv.ReturnValue %{{.*}} : i32 // CHECK: spv.ReturnValue %{{.*}} : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// CHECK-LABEL: func @in_selection // CHECK-LABEL: func @in_selection
func @in_selection(%cond : i1) -> (i32) { func @in_selection(%cond : i1) -> (i32) {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
^then: ^then:
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK: spv.ReturnValue // CHECK: spv.ReturnValue
spv.ReturnValue %zero : i32 spv.ReturnValue %zero : i32
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
spv.ReturnValue %one : i32 spv.ReturnValue %one : i32
} }
// CHECK-LABEL: func @in_loop // CHECK-LABEL: func @in_loop
func @in_loop(%cond : i1) -> (i32) { func @in_loop(%cond : i1) -> (i32) {
spv.loop { spv.loop {
spv.Branch ^header spv.Branch ^header
^header: ^header:
spv.BranchConditional %cond, ^body, ^merge spv.BranchConditional %cond, ^body, ^merge
^body: ^body:
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK: spv.ReturnValue // CHECK: spv.ReturnValue
spv.ReturnValue %zero : i32 spv.ReturnValue %zero : i32
^continue: ^continue:
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
spv.ReturnValue %one : i32 spv.ReturnValue %one : i32
} }
// CHECK-LABEL: in_other_func_like_op // CHECK-LABEL: in_other_func_like_op
func @in_other_func_like_op(%arg: i32) -> i32 { func @in_other_func_like_op(%arg: i32) -> i32 {
// CHECK: spv.ReturnValue // CHECK: spv.ReturnValue
spv.ReturnValue %arg: i32 spv.ReturnValue %arg: i32
} }
// ----- // -----
"foo.function"() ({ "foo.function"() ({
%0 = spv.constant true %0 = spv.Constant true
// expected-error @+1 {{op must appear in a function-like op's block}} // expected-error @+1 {{op must appear in a function-like op's block}}
spv.ReturnValue %0 : i1 spv.ReturnValue %0 : i1
}) : () -> () }) : () -> ()
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @value_count_mismatch() -> () "None" { spv.func @value_count_mismatch() -> () "None" {
%0 = spv.constant 42 : i32 %0 = spv.Constant 42 : i32
// expected-error @+1 {{op returns 1 value but enclosing function requires 0 results}} // expected-error @+1 {{op returns 1 value but enclosing function requires 0 results}}
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @value_type_mismatch() -> (f32) "None" { spv.func @value_type_mismatch() -> (f32) "None" {
%0 = spv.constant 42 : i32 %0 = spv.Constant 42 : i32
// expected-error @+1 {{return value's type ('i32') mismatch with function's result type ('f32')}} // expected-error @+1 {{return value's type ('i32') mismatch with function's result type ('f32')}}
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @in_nested_region(%cond: i1) -> () "None" { spv.func @in_nested_region(%cond: i1) -> () "None" {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
^then: ^then:
%cst = spv.constant 0: i32 %cst = spv.Constant 0: i32
// expected-error @+1 {{op returns 1 value but enclosing function requires 0 results}} // expected-error @+1 {{op returns 1 value but enclosing function requires 0 results}}
spv.ReturnValue %cst: i32 spv.ReturnValue %cst: i32
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.selection // spv.selection
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @selection(%cond: i1) -> () { func @selection(%cond: i1) -> () {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
// CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb1, ^bb2 // CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb1, ^bb2
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
// CHECK: ^bb1 // CHECK: ^bb1
Show All 9 Linesfunc @selection(%cond: i1) -> () {
} }
spv.Return spv.Return
} }
// ----- // -----
func @selection(%cond: i1) -> () { func @selection(%cond: i1) -> () {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%two = spv.constant 2: i32 %two = spv.Constant 2: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
// CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb1, ^bb2 // CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb1, ^bb2
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
// CHECK: ^bb1 // CHECK: ^bb1
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/cooperative-matrix-ops.mlir

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Linesspv.func @cooperative_matrix_fdiv(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" {
%r = spv.FDiv %a, %b : !spv.coopmatrix<8x16xf32, Subgroup> %r = spv.FDiv %a, %b : !spv.coopmatrix<8x16xf32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: @cooperative_matrix_access_chain // CHECK-LABEL: @cooperative_matrix_access_chain
spv.func @cooperative_matrix_access_chain(%a : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>) -> !spv.ptr<f32, Function> "None" { spv.func @cooperative_matrix_access_chain(%a : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>) -> !spv.ptr<f32, Function> "None" {
%0 = spv.constant 0: i32 %0 = spv.Constant 0: i32
// CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32 // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32
%1 = spv.AccessChain %a[%0] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32 %1 = spv.AccessChain %a[%0] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32
spv.ReturnValue %1 : !spv.ptr<f32, Function> spv.ReturnValue %1 : !spv.ptr<f32, Function>
} }
// ----- // -----
spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<16x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" { spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<16x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/logical-ops.mlir

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Lines
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SelectOp // spv.SelectOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @select_op_bool(%arg0: i1) -> () { func @select_op_bool(%arg0: i1) -> () {
%0 = spv.constant true %0 = spv.Constant true
%1 = spv.constant false %1 = spv.Constant false
// CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i1 // CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i1
%2 = spv.Select %arg0, %0, %1 : i1, i1 %2 = spv.Select %arg0, %0, %1 : i1, i1
return return
} }
func @select_op_int(%arg0: i1) -> () { func @select_op_int(%arg0: i1) -> () {
%0 = spv.constant 2 : i32 %0 = spv.Constant 2 : i32
%1 = spv.constant 3 : i32 %1 = spv.Constant 3 : i32
// CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i32 // CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, i32
%2 = spv.Select %arg0, %0, %1 : i1, i32 %2 = spv.Select %arg0, %0, %1 : i1, i32
return return
} }
func @select_op_float(%arg0: i1) -> () { func @select_op_float(%arg0: i1) -> () {
%0 = spv.constant 2.0 : f32 %0 = spv.Constant 2.0 : f32
%1 = spv.constant 3.0 : f32 %1 = spv.Constant 3.0 : f32
// CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, f32 // CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, f32
%2 = spv.Select %arg0, %0, %1 : i1, f32 %2 = spv.Select %arg0, %0, %1 : i1, f32
return return
} }
func @select_op_ptr(%arg0: i1) -> () { func @select_op_ptr(%arg0: i1) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
%1 = spv.Variable : !spv.ptr<f32, Function> %1 = spv.Variable : !spv.ptr<f32, Function>
// CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, !spv.ptr<f32, Function> // CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, !spv.ptr<f32, Function>
%2 = spv.Select %arg0, %0, %1 : i1, !spv.ptr<f32, Function> %2 = spv.Select %arg0, %0, %1 : i1, !spv.ptr<f32, Function>
return return
} }
func @select_op_vec(%arg0: i1) -> () { func @select_op_vec(%arg0: i1) -> () {
%0 = spv.constant dense<[2.0, 3.0, 4.0]> : vector<3xf32> %0 = spv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
%1 = spv.constant dense<[5.0, 6.0, 7.0]> : vector<3xf32> %1 = spv.Constant dense<[5.0, 6.0, 7.0]> : vector<3xf32>
// CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, vector<3xf32> // CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : i1, vector<3xf32>
%2 = spv.Select %arg0, %0, %1 : i1, vector<3xf32> %2 = spv.Select %arg0, %0, %1 : i1, vector<3xf32>
return return
} }
func @select_op_vec_condn_vec(%arg0: vector<3xi1>) -> () { func @select_op_vec_condn_vec(%arg0: vector<3xi1>) -> () {
%0 = spv.constant dense<[2.0, 3.0, 4.0]> : vector<3xf32> %0 = spv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
%1 = spv.constant dense<[5.0, 6.0, 7.0]> : vector<3xf32> %1 = spv.Constant dense<[5.0, 6.0, 7.0]> : vector<3xf32>
// CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi1>, vector<3xf32> // CHECK : spv.Select {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi1>, vector<3xf32>
%2 = spv.Select %arg0, %0, %1 : vector<3xi1>, vector<3xf32> %2 = spv.Select %arg0, %0, %1 : vector<3xi1>, vector<3xf32>
return return
} }
// ----- // -----
func @select_op(%arg0: i1) -> () { func @select_op(%arg0: i1) -> () {
%0 = spv.constant 2 : i32 %0 = spv.Constant 2 : i32
%1 = spv.constant 3 : i32 %1 = spv.Constant 3 : i32
// expected-error @+2 {{expected ','}} // expected-error @+2 {{expected ','}}
%2 = spv.Select %arg0, %0, %1 : i1 %2 = spv.Select %arg0, %0, %1 : i1
return return
} }
// ----- // -----
func @select_op(%arg1: vector<3xi1>) -> () { func @select_op(%arg1: vector<3xi1>) -> () {
%0 = spv.constant 2 : i32 %0 = spv.Constant 2 : i32
%1 = spv.constant 3 : i32 %1 = spv.Constant 3 : i32
// expected-error @+1 {{result expected to be of vector type when condition is of vector type}} // expected-error @+1 {{result expected to be of vector type when condition is of vector type}}
%2 = spv.Select %arg1, %0, %1 : vector<3xi1>, i32 %2 = spv.Select %arg1, %0, %1 : vector<3xi1>, i32
return return
} }
// ----- // -----
func @select_op(%arg1: vector<4xi1>) -> () { func @select_op(%arg1: vector<4xi1>) -> () {
%0 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %0 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%1 = spv.constant dense<[5, 6, 7]> : vector<3xi32> %1 = spv.Constant dense<[5, 6, 7]> : vector<3xi32>
// expected-error @+1 {{result should have the same number of elements as the condition when condition is of vector type}} // expected-error @+1 {{result should have the same number of elements as the condition when condition is of vector type}}
%2 = spv.Select %arg1, %0, %1 : vector<4xi1>, vector<3xi32> %2 = spv.Select %arg1, %0, %1 : vector<4xi1>, vector<3xi32>
return return
} }
// ----- // -----
func @select_op(%arg1: vector<4xi1>) -> () { func @select_op(%arg1: vector<4xi1>) -> () {
%0 = spv.constant dense<[2.0, 3.0, 4.0]> : vector<3xf32> %0 = spv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
%1 = spv.constant dense<[5, 6, 7]> : vector<3xi32> %1 = spv.Constant dense<[5, 6, 7]> : vector<3xi32>
// expected-error @+1 {{all of {true_value, false_value, result} have same type}} // expected-error @+1 {{all of {true_value, false_value, result} have same type}}
%2 = "spv.Select"(%arg1, %0, %1) : (vector<4xi1>, vector<3xf32>, vector<3xi32>) -> vector<3xi32> %2 = "spv.Select"(%arg1, %0, %1) : (vector<4xi1>, vector<3xf32>, vector<3xi32>) -> vector<3xi32>
return return
} }
// ----- // -----
func @select_op(%arg1: vector<4xi1>) -> () { func @select_op(%arg1: vector<4xi1>) -> () {
%0 = spv.constant dense<[2.0, 3.0, 4.0]> : vector<3xf32> %0 = spv.Constant dense<[2.0, 3.0, 4.0]> : vector<3xf32>
%1 = spv.constant dense<[5, 6, 7]> : vector<3xi32> %1 = spv.Constant dense<[5, 6, 7]> : vector<3xi32>
// expected-error @+1 {{all of {true_value, false_value, result} have same type}} // expected-error @+1 {{all of {true_value, false_value, result} have same type}}
%2 = "spv.Select"(%arg1, %1, %0) : (vector<4xi1>, vector<3xi32>, vector<3xf32>) -> vector<3xi32> %2 = "spv.Select"(%arg1, %1, %0) : (vector<4xi1>, vector<3xi32>, vector<3xf32>) -> vector<3xi32>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/memory-ops.mlir

// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AccessChain // spv.AccessChain
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @access_chain_struct() -> () { func @access_chain_struct() -> () {
%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: spv.AccessChain {{.*}}[{{.*}}, {{.*}}] : !spv.ptr<!spv.struct<(f32, !spv.array<4 x f32>)>, Function> // CHECK: spv.AccessChain {{.*}}[{{.*}}, {{.*}}] : !spv.ptr<!spv.struct<(f32, !spv.array<4 x f32>)>, Function>
%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
return return
} }
func @access_chain_1D_array(%arg0 : i32) -> () { func @access_chain_1D_array(%arg0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4xf32>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4xf32>, Function>
Show All 24 Linesfunc @access_chain_rtarray(%arg0 : i32) -> () {
%1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.rtarray<f32>, Function>, i32 %1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.rtarray<f32>, Function>, i32
%2 = spv.Load "Function" %1 ["Volatile"] : f32 %2 = spv.Load "Function" %1 ["Volatile"] : f32
return return
} }
// ----- // -----
func @access_chain_non_composite() -> () { func @access_chain_non_composite() -> () {
%0 = spv.constant 1: i32 %0 = spv.Constant 1: i32
%1 = spv.Variable : !spv.ptr<f32, Function> %1 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{cannot extract from non-composite type 'f32' with index 0}} // expected-error @+1 {{cannot extract from non-composite type 'f32' with index 0}}
%2 = spv.AccessChain %1[%0] : !spv.ptr<f32, Function>, i32 %2 = spv.AccessChain %1[%0] : !spv.ptr<f32, Function>, i32
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesfunc @access_chain_invalid_index_1(%index0 : i32) -> () {
%1 = spv.AccessChain %0[%index, 4] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32 %1 = spv.AccessChain %0[%index, 4] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32
return return
} }
// ----- // -----
func @access_chain_invalid_index_2(%index0 : i32) -> () { func @access_chain_invalid_index_2(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function> %0 = spv.Variable : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>
// expected-error @+1 {{index must be an integer spv.constant to access element of spv.struct}} // expected-error @+1 {{index must be an integer spv.Constant to access element of spv.struct}}
%1 = spv.AccessChain %0[%index0, %index0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>, i32, i32 %1 = spv.AccessChain %0[%index0, %index0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>, i32, i32
return return
} }
// ----- // -----
func @access_chain_invalid_constant_type_1() -> () { func @access_chain_invalid_constant_type_1() -> () {
%0 = std.constant 1: i32 %0 = std.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>
// expected-error @+1 {{index must be an integer spv.constant to access element of spv.struct, but provided std.constant}} // expected-error @+1 {{index must be an integer spv.Constant to access element of spv.struct, but provided std.constant}}
%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
return return
} }
// ----- // -----
func @access_chain_out_of_bounds() -> () { func @access_chain_out_of_bounds() -> () {
%index0 = "spv.constant"() { value = 12: i32} : () -> i32 %index0 = "spv.Constant"() { value = 12: i32} : () -> i32
%0 = spv.Variable : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function> %0 = spv.Variable : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>
// expected-error @+1 {{'spv.AccessChain' op index 12 out of bounds for '!spv.struct<(f32, !spv.array<4 x f32>)>'}} // expected-error @+1 {{'spv.AccessChain' op index 12 out of bounds for '!spv.struct<(f32, !spv.array<4 x f32>)>'}}
%1 = spv.AccessChain %0[%index0, %index0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>, i32, i32 %1 = spv.AccessChain %0[%index0, %index0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Function>, i32, i32
return return
} }
// ----- // -----
▲ Show 20 Lines • Show All 340 Lines • ▼ Show 20 Linesfunc @variable(%arg0: f32) -> () {
// CHECK: spv.Variable : !spv.ptr<f32, Function> // CHECK: spv.Variable : !spv.ptr<f32, Function>
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
return return
} }
// ----- // -----
func @variable_init_normal_constant() -> () { func @variable_init_normal_constant() -> () {
%0 = spv.constant 4.0 : f32 %0 = spv.Constant 4.0 : f32
// CHECK: spv.Variable init(%0) : !spv.ptr<f32, Function> // CHECK: spv.Variable init(%0) : !spv.ptr<f32, Function>
%1 = spv.Variable init(%0) : !spv.ptr<f32, Function> %1 = spv.Variable init(%0) : !spv.ptr<f32, Function>
return return
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
Show All 25 Linesfunc @variable_bind() -> () {
// expected-error @+1 {{cannot have 'descriptor_set' attribute (only allowed in spv.globalVariable)}} // expected-error @+1 {{cannot have 'descriptor_set' attribute (only allowed in spv.globalVariable)}}
%0 = spv.Variable bind(1, 2) : !spv.ptr<f32, Function> %0 = spv.Variable bind(1, 2) : !spv.ptr<f32, Function>
return return
} }
// ----- // -----
func @variable_init_bind() -> () { func @variable_init_bind() -> () {
%0 = spv.constant 4.0 : f32 %0 = spv.Constant 4.0 : f32
// expected-error @+1 {{cannot have 'binding' attribute (only allowed in spv.globalVariable)}} // expected-error @+1 {{cannot have 'binding' attribute (only allowed in spv.globalVariable)}}
%1 = spv.Variable init(%0) {binding = 5 : i32} : !spv.ptr<f32, Function> %1 = spv.Variable init(%0) {binding = 5 : i32} : !spv.ptr<f32, Function>
return return
} }
// ----- // -----
func @variable_builtin() -> () { func @variable_builtin() -> () {
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/non-uniform-ops.mlir

Show All 27 Lines
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.NonUniformGroupBroadcast // spv.NonUniformGroupBroadcast
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @group_non_uniform_broadcast_scalar(%value: f32) -> f32 { func @group_non_uniform_broadcast_scalar(%value: f32) -> f32 {
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
// CHECK: spv.GroupNonUniformBroadcast Workgroup %{{.*}}, %{{.*}} : f32, i32 // CHECK: spv.GroupNonUniformBroadcast Workgroup %{{.*}}, %{{.*}} : f32, i32
%0 = spv.GroupNonUniformBroadcast Workgroup %value, %one : f32, i32 %0 = spv.GroupNonUniformBroadcast Workgroup %value, %one : f32, i32
return %0: f32 return %0: f32
} }
// ----- // -----
func @group_non_uniform_broadcast_vector(%value: vector<4xf32>) -> vector<4xf32> { func @group_non_uniform_broadcast_vector(%value: vector<4xf32>) -> vector<4xf32> {
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
// CHECK: spv.GroupNonUniformBroadcast Subgroup %{{.*}}, %{{.*}} : vector<4xf32>, i32 // CHECK: spv.GroupNonUniformBroadcast Subgroup %{{.*}}, %{{.*}} : vector<4xf32>, i32
%0 = spv.GroupNonUniformBroadcast Subgroup %value, %one : vector<4xf32>, i32 %0 = spv.GroupNonUniformBroadcast Subgroup %value, %one : vector<4xf32>, i32
return %0: vector<4xf32> return %0: vector<4xf32>
} }
// ----- // -----
func @group_non_uniform_broadcast_negative_scope(%value: f32, %localid: i32 ) -> f32 { func @group_non_uniform_broadcast_negative_scope(%value: f32, %localid: i32 ) -> f32 {
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
// expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}} // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
%0 = spv.GroupNonUniformBroadcast Device %value, %one : f32, i32 %0 = spv.GroupNonUniformBroadcast Device %value, %one : f32, i32
return %0: f32 return %0: f32
} }
// ----- // -----
func @group_non_uniform_broadcast_negative_non_const(%value: f32, %localid: i32) -> f32 { func @group_non_uniform_broadcast_negative_non_const(%value: f32, %localid: i32) -> f32 {
Show All 33 Lines
func @group_non_uniform_fadd_reduce(%val: f32) -> f32 { func @group_non_uniform_fadd_reduce(%val: f32) -> f32 {
// CHECK: %{{.+}} = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %{{.+}} : f32 // CHECK: %{{.+}} = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %{{.+}} : f32
%0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %val : f32
return %0: f32 return %0: f32
} }
// CHECK-LABEL: @group_non_uniform_fadd_clustered_reduce // CHECK-LABEL: @group_non_uniform_fadd_clustered_reduce
func @group_non_uniform_fadd_clustered_reduce(%val: vector<2xf32>) -> vector<2xf32> { func @group_non_uniform_fadd_clustered_reduce(%val: vector<2xf32>) -> vector<2xf32> {
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
// CHECK: %{{.+}} = spv.GroupNonUniformFAdd "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xf32> // CHECK: %{{.+}} = spv.GroupNonUniformFAdd "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xf32>
%0 = spv.GroupNonUniformFAdd "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xf32> %0 = spv.GroupNonUniformFAdd "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xf32>
return %0: vector<2xf32> return %0: vector<2xf32>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformFMul // spv.GroupNonUniformFMul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_fmul_reduce // CHECK-LABEL: @group_non_uniform_fmul_reduce
func @group_non_uniform_fmul_reduce(%val: f32) -> f32 { func @group_non_uniform_fmul_reduce(%val: f32) -> f32 {
// CHECK: %{{.+}} = spv.GroupNonUniformFMul "Workgroup" "Reduce" %{{.+}} : f32 // CHECK: %{{.+}} = spv.GroupNonUniformFMul "Workgroup" "Reduce" %{{.+}} : f32
%0 = spv.GroupNonUniformFMul "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFMul "Workgroup" "Reduce" %val : f32
return %0: f32 return %0: f32
} }
// CHECK-LABEL: @group_non_uniform_fmul_clustered_reduce // CHECK-LABEL: @group_non_uniform_fmul_clustered_reduce
func @group_non_uniform_fmul_clustered_reduce(%val: vector<2xf32>) -> vector<2xf32> { func @group_non_uniform_fmul_clustered_reduce(%val: vector<2xf32>) -> vector<2xf32> {
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
// CHECK: %{{.+}} = spv.GroupNonUniformFMul "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xf32> // CHECK: %{{.+}} = spv.GroupNonUniformFMul "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xf32>
%0 = spv.GroupNonUniformFMul "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xf32> %0 = spv.GroupNonUniformFMul "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xf32>
return %0: vector<2xf32> return %0: vector<2xf32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 30 Lines
func @group_non_uniform_iadd_reduce(%val: i32) -> i32 { func @group_non_uniform_iadd_reduce(%val: i32) -> i32 {
// CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %val : i32
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @group_non_uniform_iadd_clustered_reduce // CHECK-LABEL: @group_non_uniform_iadd_clustered_reduce
func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> { func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
// CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xi32> // CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xi32>
%0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xi32> %0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xi32>
return %0: vector<2xi32> return %0: vector<2xi32>
} }
// ----- // -----
func @group_non_uniform_iadd_reduce(%val: i32) -> i32 { func @group_non_uniform_iadd_reduce(%val: i32) -> i32 {
Show All 16 Linesfunc @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>, %size: i32) -> vector<2xi32> {
// expected-error @+1 {{cluster size operand must come from a constant op}} // expected-error @+1 {{cluster size operand must come from a constant op}}
%0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%size) : vector<2xi32> %0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%size) : vector<2xi32>
return %0: vector<2xi32> return %0: vector<2xi32>
} }
// ----- // -----
func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> { func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
%five = spv.constant 5 : i32 %five = spv.Constant 5 : i32
// expected-error @+1 {{cluster size operand must be a power of two}} // expected-error @+1 {{cluster size operand must be a power of two}}
%0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%five) : vector<2xi32> %0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%five) : vector<2xi32>
return %0: vector<2xi32> return %0: vector<2xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformIMul // spv.GroupNonUniformIMul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_imul_reduce // CHECK-LABEL: @group_non_uniform_imul_reduce
func @group_non_uniform_imul_reduce(%val: i32) -> i32 { func @group_non_uniform_imul_reduce(%val: i32) -> i32 {
// CHECK: %{{.+}} = spv.GroupNonUniformIMul "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformIMul "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %val : i32
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @group_non_uniform_imul_clustered_reduce // CHECK-LABEL: @group_non_uniform_imul_clustered_reduce
func @group_non_uniform_imul_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> { func @group_non_uniform_imul_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
// CHECK: %{{.+}} = spv.GroupNonUniformIMul "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xi32> // CHECK: %{{.+}} = spv.GroupNonUniformIMul "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xi32>
%0 = spv.GroupNonUniformIMul "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xi32> %0 = spv.GroupNonUniformIMul "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xi32>
return %0: vector<2xi32> return %0: vector<2xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

mlir/test/Dialect/SPIRV/IR/structure-ops.mlir

// RUN: mlir-opt -allow-unregistered-dialect -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -allow-unregistered-dialect -split-input-file -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.mlir.addressof // spv.mlir.addressof
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @var1 : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input> spv.globalVariable @var1 : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>
spv.func @access_chain() -> () "None" { spv.func @access_chain() -> () "None" {
%0 = spv.constant 1: i32 %0 = spv.Constant 1: i32
// CHECK: [[VAR1:%.*]] = spv.mlir.addressof @var1 : !spv.ptr<!spv.struct<(f32, !spv.array<4 x f32>)>, Input> // CHECK: [[VAR1:%.*]] = spv.mlir.addressof @var1 : !spv.ptr<!spv.struct<(f32, !spv.array<4 x f32>)>, Input>
// CHECK-NEXT: spv.AccessChain [[VAR1]][{{.*}}, {{.*}}] : !spv.ptr<!spv.struct<(f32, !spv.array<4 x f32>)>, Input> // CHECK-NEXT: spv.AccessChain [[VAR1]][{{.*}}, {{.*}}] : !spv.ptr<!spv.struct<(f32, !spv.array<4 x f32>)>, Input>
%1 = spv.mlir.addressof @var1 : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input> %1 = spv.mlir.addressof @var1 : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>
%2 = spv.AccessChain %1[%0, %0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>, i32, i32 %2 = spv.AccessChain %1[%0, %0] : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>, i32, i32
spv.Return spv.Return
} }
} }
Show All 25 Lines spv.func @foo() -> () "None" {
// expected-error @+1 {{result type mismatch with the referenced global variable's type}} // expected-error @+1 {{result type mismatch with the referenced global variable's type}}
%0 = spv.mlir.addressof @var1 : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @var1 : !spv.ptr<f32, Input>
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.constant // spv.Constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @const() -> () { func @const() -> () {
// CHECK: spv.constant true // CHECK: spv.Constant true
// CHECK: spv.constant 42 : i32 // CHECK: spv.Constant 42 : i32
// CHECK: spv.constant 5.000000e-01 : f32 // CHECK: spv.Constant 5.000000e-01 : f32
// CHECK: spv.constant dense<[2, 3]> : vector<2xi32> // CHECK: spv.Constant dense<[2, 3]> : vector<2xi32>
// CHECK: spv.constant [dense<3.000000e+00> : vector<2xf32>] : !spv.array<1 x vector<2xf32>> // CHECK: spv.Constant [dense<3.000000e+00> : vector<2xf32>] : !spv.array<1 x vector<2xf32>>
// CHECK: spv.constant dense<1> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>> // CHECK: spv.Constant dense<1> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>>
// CHECK: spv.constant dense<1.000000e+00> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>> // CHECK: spv.Constant dense<1.000000e+00> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>>
// CHECK: spv.constant dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>> // CHECK: spv.Constant dense<{{\[}}[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>>
// CHECK: spv.constant dense<{{\[}}[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>> // CHECK: spv.Constant dense<{{\[}}[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>>
%0 = spv.constant true %0 = spv.Constant true
%1 = spv.constant 42 : i32 %1 = spv.Constant 42 : i32
%2 = spv.constant 0.5 : f32 %2 = spv.Constant 0.5 : f32
%3 = spv.constant dense<[2, 3]> : vector<2xi32> %3 = spv.Constant dense<[2, 3]> : vector<2xi32>
%4 = spv.constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>> %4 = spv.Constant [dense<3.0> : vector<2xf32>] : !spv.array<1xvector<2xf32>>
%5 = spv.constant dense<1> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>> %5 = spv.Constant dense<1> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>>
%6 = spv.constant dense<1.0> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>> %6 = spv.Constant dense<1.0> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>>
%7 = spv.constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>> %7 = spv.Constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> : !spv.array<2 x !spv.array<3 x i32>>
%8 = spv.constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>> %8 = spv.Constant dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x f32>>
return return
} }
// ----- // -----
func @unaccepted_std_attr() -> () { func @unaccepted_std_attr() -> () {
// expected-error @+1 {{cannot have value of type 'none'}} // expected-error @+1 {{cannot have value of type 'none'}}
%0 = spv.constant unit : none %0 = spv.Constant unit : none
return return
} }
// ----- // -----
func @array_constant() -> () { func @array_constant() -> () {
// expected-error @+1 {{has array element whose type ('vector<2xi32>') does not match the result element type ('vector<2xf32>')}} // expected-error @+1 {{has array element whose type ('vector<2xi32>') does not match the result element type ('vector<2xf32>')}}
%0 = spv.constant [dense<3.0> : vector<2xf32>, dense<4> : vector<2xi32>] : !spv.array<2xvector<2xf32>> %0 = spv.Constant [dense<3.0> : vector<2xf32>, dense<4> : vector<2xi32>] : !spv.array<2xvector<2xf32>>
return return
} }
// ----- // -----
func @array_constant() -> () { func @array_constant() -> () {
// expected-error @+1 {{must have spv.array result type for array value}} // expected-error @+1 {{must have spv.array result type for array value}}
%0 = spv.constant [dense<3.0> : vector<2xf32>] : !spv.rtarray<vector<2xf32>> %0 = spv.Constant [dense<3.0> : vector<2xf32>] : !spv.rtarray<vector<2xf32>>
return return
} }
// ----- // -----
func @non_nested_array_constant() -> () { func @non_nested_array_constant() -> () {
// expected-error @+1 {{only support nested array result type}} // expected-error @+1 {{only support nested array result type}}
%0 = spv.constant dense<3.0> : tensor<2x2xf32> : !spv.array<2xvector<2xf32>> %0 = spv.Constant dense<3.0> : tensor<2x2xf32> : !spv.array<2xvector<2xf32>>
return return
} }
// ----- // -----
func @value_result_type_mismatch() -> () { func @value_result_type_mismatch() -> () {
// expected-error @+1 {{must have spv.array result type for array value}} // expected-error @+1 {{must have spv.array result type for array value}}
%0 = "spv.constant"() {value = dense<0> : tensor<4xi32>} : () -> (vector<4xi32>) %0 = "spv.Constant"() {value = dense<0> : tensor<4xi32>} : () -> (vector<4xi32>)
} }
// ----- // -----
func @value_result_type_mismatch() -> () { func @value_result_type_mismatch() -> () {
// expected-error @+1 {{result element type ('i32') does not match value element type ('f32')}} // expected-error @+1 {{result element type ('i32') does not match value element type ('f32')}}
%0 = spv.constant dense<1.0> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x i32>> %0 = spv.Constant dense<1.0> : tensor<2x3xf32> : !spv.array<2 x !spv.array<3 x i32>>
} }
// ----- // -----
func @value_result_num_elements_mismatch() -> () { func @value_result_num_elements_mismatch() -> () {
// expected-error @+1 {{result number of elements (6) does not match value number of elements (4)}} // expected-error @+1 {{result number of elements (6) does not match value number of elements (4)}}
%0 = spv.constant dense<1.0> : tensor<2x2xf32> : !spv.array<2 x !spv.array<3 x f32>> %0 = spv.Constant dense<1.0> : tensor<2x2xf32> : !spv.array<2 x !spv.array<3 x f32>>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.EntryPoint // spv.EntryPoint
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// CHECK: spv.globalVariable @var0 : !spv.ptr<f32, Input> // CHECK: spv.globalVariable @var0 : !spv.ptr<f32, Input>
spv.globalVariable @var0 : !spv.ptr<f32, Input> spv.globalVariable @var0 : !spv.ptr<f32, Input>
} }
// TODO: Fix test case after initialization with normal constant is addressed // TODO: Fix test case after initialization with normal constant is addressed
// spv.module Logical GLSL450 { // spv.module Logical GLSL450 {
// %0 = spv.constant 4.0 : f32 // %0 = spv.Constant 4.0 : f32
// // CHECK1: spv.Variable init(%0) : !spv.ptr<f32, Private> // // CHECK1: spv.Variable init(%0) : !spv.ptr<f32, Private>
// spv.globalVariable @var1 init(%0) : !spv.ptr<f32, Private> // spv.globalVariable @var1 init(%0) : !spv.ptr<f32, Private>
// } // }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc = 4.0 : f32 spv.specConstant @sc = 4.0 : f32
Show All 12 Lines
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// CHECK: spv.globalVariable @var0 bind(1, 2) : !spv.ptr<f32, Uniform> // CHECK: spv.globalVariable @var0 bind(1, 2) : !spv.ptr<f32, Uniform>
spv.globalVariable @var0 bind(1, 2) : !spv.ptr<f32, Uniform> spv.globalVariable @var0 bind(1, 2) : !spv.ptr<f32, Uniform>
} }
// TODO: Fix test case after initialization with constant is addressed // TODO: Fix test case after initialization with constant is addressed
// spv.module Logical GLSL450 { // spv.module Logical GLSL450 {
// %0 = spv.constant 4.0 : f32 // %0 = spv.Constant 4.0 : f32
// // CHECK1: spv.globalVariable @var1 initializer(%0) {binding = 5 : i32} : !spv.ptr<f32, Private> // // CHECK1: spv.globalVariable @var1 initializer(%0) {binding = 5 : i32} : !spv.ptr<f32, Private>
// spv.globalVariable @var1 initializer(%0) {binding = 5 : i32} : !spv.ptr<f32, Private> // spv.globalVariable @var1 initializer(%0) {binding = 5 : i32} : !spv.ptr<f32, Private>
// } // }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// CHECK: spv.globalVariable @var1 built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Input> // CHECK: spv.globalVariable @var1 built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Input>
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
} }
// ----- // -----
// Module with wrong terminator // Module with wrong terminator
// expected-error@+2 {{expects regions to end with 'spv.mlir.endmodule'}} // expected-error@+2 {{expects regions to end with 'spv.mlir.endmodule'}}
// expected-note@+1 {{in custom textual format, the absence of terminator implies 'spv.mlir.endmodule'}} // expected-note@+1 {{in custom textual format, the absence of terminator implies 'spv.mlir.endmodule'}}
"spv.module"() ({ "spv.module"() ({
%0 = spv.constant true %0 = spv.Constant true
}) {addressing_model = 0 : i32, memory_model = 1 : i32} : () -> () }) {addressing_model = 0 : i32, memory_model = 1 : i32} : () -> ()
// ----- // -----
// Use non SPIR-V op inside module // Use non SPIR-V op inside module
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{'spv.module' can only contain spv.* ops}} // expected-error @+1 {{'spv.module' can only contain spv.* ops}}
"dialect.op"() : () -> () "dialect.op"() : () -> ()
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines spv.func @initialize() -> i64 "None" {
%2 = spv.Load "Function" %1 : i64 %2 = spv.Load "Function" %1 : i64
spv.ReturnValue %2 : i64 spv.ReturnValue %2 : i64
} }
// CHECK-LABEL: @compute // CHECK-LABEL: @compute
spv.func @compute() -> f32 "None" { spv.func @compute() -> f32 "None" {
// CHECK: spv.mlir.referenceof @sc3 : f32 // CHECK: spv.mlir.referenceof @sc3 : f32
%0 = spv.mlir.referenceof @sc3 : f32 %0 = spv.mlir.referenceof @sc3 : f32
%1 = spv.constant 6.0 : f32 %1 = spv.Constant 6.0 : f32
%2 = spv.FAdd %0, %1 : f32 %2 = spv.FAdd %0, %1 : f32
spv.ReturnValue %2 : f32 spv.ReturnValue %2 : f32
} }
} }
// ----- // -----
// Allow taking reference of spec constant in other module-like ops // Allow taking reference of spec constant in other module-like ops
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SpecConstantOperation // spv.SpecConstantOperation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo() -> i32 "None" { spv.func @foo() -> i32 "None" {
// CHECK: [[LHS:%.*]] = spv.constant // CHECK: [[LHS:%.*]] = spv.Constant
%0 = spv.constant 1: i32 %0 = spv.Constant 1: i32
// CHECK: [[RHS:%.*]] = spv.constant // CHECK: [[RHS:%.*]] = spv.Constant
%1 = spv.constant 1: i32 %1 = spv.Constant 1: i32
// CHECK: spv.SpecConstantOperation wraps "spv.IAdd"([[LHS]], [[RHS]]) : (i32, i32) -> i32 // CHECK: spv.SpecConstantOperation wraps "spv.IAdd"([[LHS]], [[RHS]]) : (i32, i32) -> i32
%2 = spv.SpecConstantOperation wraps "spv.IAdd"(%0, %1) : (i32, i32) -> i32 %2 = spv.SpecConstantOperation wraps "spv.IAdd"(%0, %1) : (i32, i32) -> i32
spv.ReturnValue %2 : i32 spv.ReturnValue %2 : i32
} }
} }
Show All 10 Lines spv.func @foo() -> i32 "None" {
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo() -> i32 "None" { spv.func @foo() -> i32 "None" {
%0 = spv.constant 1: i32 %0 = spv.Constant 1: i32
// expected-error @+1 {{op expects parent op 'spv.SpecConstantOperation'}} // expected-error @+1 {{op expects parent op 'spv.SpecConstantOperation'}}
spv.mlir.yield %0 : i32 spv.mlir.yield %0 : i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
Show All 22 Lines

mlir/test/Dialect/SPIRV/Transforms/abi-interface.mlir

Show All 12 Linesspv.module Logical GLSL450 {
spv.func @kernel( spv.func @kernel(
%arg0: f32 %arg0: f32
{spv.interface_var_abi = #spv.interface_var_abi<(0, 0), StorageBuffer>}, {spv.interface_var_abi = #spv.interface_var_abi<(0, 0), StorageBuffer>},
%arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, StorageBuffer> %arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, StorageBuffer>
{spv.interface_var_abi = #spv.interface_var_abi<(0, 1)>}) "None" {spv.interface_var_abi = #spv.interface_var_abi<(0, 1)>}) "None"
attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]> : vector<3xi32>}} { attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]> : vector<3xi32>}} {
// CHECK: [[ARG1:%.*]] = spv.mlir.addressof [[VAR1]] // CHECK: [[ARG1:%.*]] = spv.mlir.addressof [[VAR1]]
// CHECK: [[ADDRESSARG0:%.*]] = spv.mlir.addressof [[VAR0]] // CHECK: [[ADDRESSARG0:%.*]] = spv.mlir.addressof [[VAR0]]
// CHECK: [[CONST0:%.*]] = spv.constant 0 : i32 // CHECK: [[CONST0:%.*]] = spv.Constant 0 : i32
// CHECK: [[ARG0PTR:%.*]] = spv.AccessChain [[ADDRESSARG0]]{{\[}}[[CONST0]] // CHECK: [[ARG0PTR:%.*]] = spv.AccessChain [[ADDRESSARG0]]{{\[}}[[CONST0]]
// CHECK: [[ARG0:%.*]] = spv.Load "StorageBuffer" [[ARG0PTR]] // CHECK: [[ARG0:%.*]] = spv.Load "StorageBuffer" [[ARG0PTR]]
// CHECK: spv.Return // CHECK: spv.Return
spv.Return spv.Return
} }
// CHECK: spv.EntryPoint "GLCompute" [[FN]] // CHECK: spv.EntryPoint "GLCompute" [[FN]]
// CHECK: spv.ExecutionMode [[FN]] "LocalSize", 32, 1, 1 // CHECK: spv.ExecutionMode [[FN]] "LocalSize", 32, 1, 1
} // end spv.module } // end spv.module
} // end module } // end module

mlir/test/Dialect/SPIRV/Transforms/abi-load-store.mlir

Show All 34 Lines spv.func @load_store_kernel(
%arg4: i32 %arg4: i32
{spv.interface_var_abi = #spv.interface_var_abi<(0, 4), StorageBuffer>}, {spv.interface_var_abi = #spv.interface_var_abi<(0, 4), StorageBuffer>},
%arg5: i32 %arg5: i32
{spv.interface_var_abi = #spv.interface_var_abi<(0, 5), StorageBuffer>}, {spv.interface_var_abi = #spv.interface_var_abi<(0, 5), StorageBuffer>},
%arg6: i32 %arg6: i32
{spv.interface_var_abi = #spv.interface_var_abi<(0, 6), StorageBuffer>}) "None" {spv.interface_var_abi = #spv.interface_var_abi<(0, 6), StorageBuffer>}) "None"
attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]> : vector<3xi32>}} { attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]> : vector<3xi32>}} {
// CHECK: [[ADDRESSARG6:%.*]] = spv.mlir.addressof [[VAR6]] // CHECK: [[ADDRESSARG6:%.*]] = spv.mlir.addressof [[VAR6]]
// CHECK: [[CONST6:%.*]] = spv.constant 0 : i32 // CHECK: [[CONST6:%.*]] = spv.Constant 0 : i32
// CHECK: [[ARG6PTR:%.*]] = spv.AccessChain [[ADDRESSARG6]]{{\[}}[[CONST6]] // CHECK: [[ARG6PTR:%.*]] = spv.AccessChain [[ADDRESSARG6]]{{\[}}[[CONST6]]
// CHECK: {{%.*}} = spv.Load "StorageBuffer" [[ARG6PTR]] // CHECK: {{%.*}} = spv.Load "StorageBuffer" [[ARG6PTR]]
// CHECK: [[ADDRESSARG5:%.*]] = spv.mlir.addressof [[VAR5]] // CHECK: [[ADDRESSARG5:%.*]] = spv.mlir.addressof [[VAR5]]
// CHECK: [[CONST5:%.*]] = spv.constant 0 : i32 // CHECK: [[CONST5:%.*]] = spv.Constant 0 : i32
// CHECK: [[ARG5PTR:%.*]] = spv.AccessChain [[ADDRESSARG5]]{{\[}}[[CONST5]] // CHECK: [[ARG5PTR:%.*]] = spv.AccessChain [[ADDRESSARG5]]{{\[}}[[CONST5]]
// CHECK: {{%.*}} = spv.Load "StorageBuffer" [[ARG5PTR]] // CHECK: {{%.*}} = spv.Load "StorageBuffer" [[ARG5PTR]]
// CHECK: [[ADDRESSARG4:%.*]] = spv.mlir.addressof [[VAR4]] // CHECK: [[ADDRESSARG4:%.*]] = spv.mlir.addressof [[VAR4]]
// CHECK: [[CONST4:%.*]] = spv.constant 0 : i32 // CHECK: [[CONST4:%.*]] = spv.Constant 0 : i32
// CHECK: [[ARG4PTR:%.*]] = spv.AccessChain [[ADDRESSARG4]]{{\[}}[[CONST4]] // CHECK: [[ARG4PTR:%.*]] = spv.AccessChain [[ADDRESSARG4]]{{\[}}[[CONST4]]
// CHECK: [[ARG4:%.*]] = spv.Load "StorageBuffer" [[ARG4PTR]] // CHECK: [[ARG4:%.*]] = spv.Load "StorageBuffer" [[ARG4PTR]]
// CHECK: [[ADDRESSARG3:%.*]] = spv.mlir.addressof [[VAR3]] // CHECK: [[ADDRESSARG3:%.*]] = spv.mlir.addressof [[VAR3]]
// CHECK: [[CONST3:%.*]] = spv.constant 0 : i32 // CHECK: [[CONST3:%.*]] = spv.Constant 0 : i32
// CHECK: [[ARG3PTR:%.*]] = spv.AccessChain [[ADDRESSARG3]]{{\[}}[[CONST3]] // CHECK: [[ARG3PTR:%.*]] = spv.AccessChain [[ADDRESSARG3]]{{\[}}[[CONST3]]
// CHECK: [[ARG3:%.*]] = spv.Load "StorageBuffer" [[ARG3PTR]] // CHECK: [[ARG3:%.*]] = spv.Load "StorageBuffer" [[ARG3PTR]]
// CHECK: [[ADDRESSARG2:%.*]] = spv.mlir.addressof [[VAR2]] // CHECK: [[ADDRESSARG2:%.*]] = spv.mlir.addressof [[VAR2]]
// CHECK: [[ARG2:%.*]] = spv.Bitcast [[ADDRESSARG2]] // CHECK: [[ARG2:%.*]] = spv.Bitcast [[ADDRESSARG2]]
// CHECK: [[ADDRESSARG1:%.*]] = spv.mlir.addressof [[VAR1]] // CHECK: [[ADDRESSARG1:%.*]] = spv.mlir.addressof [[VAR1]]
// CHECK: [[ARG1:%.*]] = spv.Bitcast [[ADDRESSARG1]] // CHECK: [[ARG1:%.*]] = spv.Bitcast [[ADDRESSARG1]]
// CHECK: [[ADDRESSARG0:%.*]] = spv.mlir.addressof [[VAR0]] // CHECK: [[ADDRESSARG0:%.*]] = spv.mlir.addressof [[VAR0]]
// CHECK: [[ARG0:%.*]] = spv.Bitcast [[ADDRESSARG0]] // CHECK: [[ARG0:%.*]] = spv.Bitcast [[ADDRESSARG0]]
Show All 33 Lines attributes {spv.entry_point_abi = {local_size = dense<[32, 1, 1]> : vector<3xi32>}} {
%33 = spv.mlir.addressof @__builtin_var_WorkgroupSize__ : !spv.ptr<vector<3xi32>, Input> %33 = spv.mlir.addressof @__builtin_var_WorkgroupSize__ : !spv.ptr<vector<3xi32>, Input>
%34 = spv.Load "Input" %33 : vector<3xi32> %34 = spv.Load "Input" %33 : vector<3xi32>
%35 = spv.CompositeExtract %34[2 : i32] : vector<3xi32> %35 = spv.CompositeExtract %34[2 : i32] : vector<3xi32>
// CHECK: spv.IAdd [[ARG3]] // CHECK: spv.IAdd [[ARG3]]
%36 = spv.IAdd %arg3, %2 : i32 %36 = spv.IAdd %arg3, %2 : i32
// CHECK: spv.IAdd [[ARG4]] // CHECK: spv.IAdd [[ARG4]]
%37 = spv.IAdd %arg4, %11 : i32 %37 = spv.IAdd %arg4, %11 : i32
// CHECK: spv.AccessChain [[ARG0]] // CHECK: spv.AccessChain [[ARG0]]
%c0 = spv.constant 0 : i32 %c0 = spv.Constant 0 : i32
%38 = spv.AccessChain %arg0[%c0, %36, %37] : !spv.ptr<!spv.struct<(!spv.array<12 x !spv.array<4 x f32>>)>, StorageBuffer>, i32, i32, i32 %38 = spv.AccessChain %arg0[%c0, %36, %37] : !spv.ptr<!spv.struct<(!spv.array<12 x !spv.array<4 x f32>>)>, StorageBuffer>, i32, i32, i32
%39 = spv.Load "StorageBuffer" %38 : f32 %39 = spv.Load "StorageBuffer" %38 : f32
// CHECK: spv.AccessChain [[ARG1]] // CHECK: spv.AccessChain [[ARG1]]
%40 = spv.AccessChain %arg1[%c0, %36, %37] : !spv.ptr<!spv.struct<(!spv.array<12 x !spv.array<4 x f32>>)>, StorageBuffer>, i32, i32, i32 %40 = spv.AccessChain %arg1[%c0, %36, %37] : !spv.ptr<!spv.struct<(!spv.array<12 x !spv.array<4 x f32>>)>, StorageBuffer>, i32, i32, i32
%41 = spv.Load "StorageBuffer" %40 : f32 %41 = spv.Load "StorageBuffer" %40 : f32
%42 = spv.FAdd %39, %41 : f32 %42 = spv.FAdd %39, %41 : f32
// CHECK: spv.AccessChain [[ARG2]] // CHECK: spv.AccessChain [[ARG2]]
%43 = spv.AccessChain %arg2[%c0, %36, %37] : !spv.ptr<!spv.struct<(!spv.array<12 x !spv.array<4 x f32>>)>, StorageBuffer>, i32, i32, i32 %43 = spv.AccessChain %arg2[%c0, %36, %37] : !spv.ptr<!spv.struct<(!spv.array<12 x !spv.array<4 x f32>>)>, StorageBuffer>, i32, i32, i32
spv.Store "StorageBuffer" %43, %42 : f32 spv.Store "StorageBuffer" %43, %42 : f32
spv.Return spv.Return
} }
// CHECK: spv.EntryPoint "GLCompute" [[FN]], [[WORKGROUPID]], [[LOCALINVOCATIONID]], [[NUMWORKGROUPS]], [[WORKGROUPSIZE]] // CHECK: spv.EntryPoint "GLCompute" [[FN]], [[WORKGROUPID]], [[LOCALINVOCATIONID]], [[NUMWORKGROUPS]], [[WORKGROUPSIZE]]
// CHECK-NEXT: spv.ExecutionMode [[FN]] "LocalSize", 32, 1, 1 // CHECK-NEXT: spv.ExecutionMode [[FN]] "LocalSize", 32, 1, 1
} // end spv.module } // end spv.module
} // end module } // end module

mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir

// RUN: mlir-opt %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s // RUN: mlir-opt %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AccessChain // spv.AccessChain
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @combine_full_access_chain() -> f32 { func @combine_full_access_chain() -> f32 {
// CHECK: %[[INDEX:.*]] = spv.constant 0 // CHECK: %[[INDEX:.*]] = spv.Constant 0
// CHECK-NEXT: %[[VAR:.*]] = spv.Variable // CHECK-NEXT: %[[VAR:.*]] = spv.Variable
// CHECK-NEXT: %[[PTR:.*]] = spv.AccessChain %[[VAR]][%[[INDEX]], %[[INDEX]], %[[INDEX]]] // CHECK-NEXT: %[[PTR:.*]] = spv.AccessChain %[[VAR]][%[[INDEX]], %[[INDEX]], %[[INDEX]]]
// CHECK-NEXT: spv.Load "Function" %[[PTR]] // CHECK-NEXT: spv.Load "Function" %[[PTR]]
%c0 = spv.constant 0: i32 %c0 = spv.Constant 0: i32
%0 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function> %0 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>
%1 = spv.AccessChain %0[%c0] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32 %1 = spv.AccessChain %0[%c0] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32
%2 = spv.AccessChain %1[%c0, %c0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32 %2 = spv.AccessChain %1[%c0, %c0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32
%3 = spv.Load "Function" %2 : f32 %3 = spv.Load "Function" %2 : f32
spv.ReturnValue %3 : f32 spv.ReturnValue %3 : f32
} }
// ----- // -----
func @combine_access_chain_multi_use() -> !spv.array<4xf32> { func @combine_access_chain_multi_use() -> !spv.array<4xf32> {
// CHECK: %[[INDEX:.*]] = spv.constant 0 // CHECK: %[[INDEX:.*]] = spv.Constant 0
// CHECK-NEXT: %[[VAR:.*]] = spv.Variable // CHECK-NEXT: %[[VAR:.*]] = spv.Variable
// CHECK-NEXT: %[[PTR_0:.*]] = spv.AccessChain %[[VAR]][%[[INDEX]], %[[INDEX]]] // CHECK-NEXT: %[[PTR_0:.*]] = spv.AccessChain %[[VAR]][%[[INDEX]], %[[INDEX]]]
// CHECK-NEXT: %[[PTR_1:.*]] = spv.AccessChain %[[VAR]][%[[INDEX]], %[[INDEX]], %[[INDEX]]] // CHECK-NEXT: %[[PTR_1:.*]] = spv.AccessChain %[[VAR]][%[[INDEX]], %[[INDEX]], %[[INDEX]]]
// CHECK-NEXT: spv.Load "Function" %[[PTR_0]] // CHECK-NEXT: spv.Load "Function" %[[PTR_0]]
// CHECK-NEXT: spv.Load "Function" %[[PTR_1]] // CHECK-NEXT: spv.Load "Function" %[[PTR_1]]
%c0 = spv.constant 0: i32 %c0 = spv.Constant 0: i32
%0 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function> %0 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>
%1 = spv.AccessChain %0[%c0] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32 %1 = spv.AccessChain %0[%c0] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32
%2 = spv.AccessChain %1[%c0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32 %2 = spv.AccessChain %1[%c0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32
%3 = spv.AccessChain %2[%c0] : !spv.ptr<!spv.array<4xf32>, Function>, i32 %3 = spv.AccessChain %2[%c0] : !spv.ptr<!spv.array<4xf32>, Function>, i32
%4 = spv.Load "Function" %2 : !spv.array<4xf32> %4 = spv.Load "Function" %2 : !spv.array<4xf32>
%5 = spv.Load "Function" %3 : f32 %5 = spv.Load "Function" %3 : f32
spv.ReturnValue %4: !spv.array<4xf32> spv.ReturnValue %4: !spv.array<4xf32>
} }
// ----- // -----
func @dont_combine_access_chain_without_common_base() -> !spv.array<4xi32> { func @dont_combine_access_chain_without_common_base() -> !spv.array<4xi32> {
// CHECK: %[[INDEX:.*]] = spv.constant 1 // CHECK: %[[INDEX:.*]] = spv.Constant 1
// CHECK-NEXT: %[[VAR_0:.*]] = spv.Variable // CHECK-NEXT: %[[VAR_0:.*]] = spv.Variable
// CHECK-NEXT: %[[VAR_1:.*]] = spv.Variable // CHECK-NEXT: %[[VAR_1:.*]] = spv.Variable
// CHECK-NEXT: %[[VAR_0_PTR:.*]] = spv.AccessChain %[[VAR_0]][%[[INDEX]]] // CHECK-NEXT: %[[VAR_0_PTR:.*]] = spv.AccessChain %[[VAR_0]][%[[INDEX]]]
// CHECK-NEXT: %[[VAR_1_PTR:.*]] = spv.AccessChain %[[VAR_1]][%[[INDEX]]] // CHECK-NEXT: %[[VAR_1_PTR:.*]] = spv.AccessChain %[[VAR_1]][%[[INDEX]]]
// CHECK-NEXT: spv.Load "Function" %[[VAR_0_PTR]] // CHECK-NEXT: spv.Load "Function" %[[VAR_0_PTR]]
// CHECK-NEXT: spv.Load "Function" %[[VAR_1_PTR]] // CHECK-NEXT: spv.Load "Function" %[[VAR_1_PTR]]
%c1 = spv.constant 1: i32 %c1 = spv.Constant 1: i32
%0 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function> %0 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>
%1 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function> %1 = spv.Variable : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>
%2 = spv.AccessChain %0[%c1] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32 %2 = spv.AccessChain %0[%c1] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32
%3 = spv.AccessChain %1[%c1] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32 %3 = spv.AccessChain %1[%c1] : !spv.ptr<!spv.struct<(!spv.array<4x!spv.array<4xf32>>, !spv.array<4xi32>)>, Function>, i32
%4 = spv.Load "Function" %2 : !spv.array<4xi32> %4 = spv.Load "Function" %2 : !spv.array<4xi32>
%5 = spv.Load "Function" %3 : !spv.array<4xi32> %5 = spv.Load "Function" %3 : !spv.array<4xi32>
spv.ReturnValue %4 : !spv.array<4xi32> spv.ReturnValue %4 : !spv.array<4xi32>
} }
Show All 29 Lines
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeExtract // spv.CompositeExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: extract_vector // CHECK-LABEL: extract_vector
func @extract_vector() -> (i32, i32, i32) { func @extract_vector() -> (i32, i32, i32) {
// CHECK: spv.constant 42 : i32 // CHECK: spv.Constant 42 : i32
// CHECK: spv.constant -33 : i32 // CHECK: spv.Constant -33 : i32
// CHECK: spv.constant 6 : i32 // CHECK: spv.Constant 6 : i32
%0 = spv.constant dense<[42, -33, 6]> : vector<3xi32> %0 = spv.Constant dense<[42, -33, 6]> : vector<3xi32>
%1 = spv.CompositeExtract %0[0 : i32] : vector<3xi32> %1 = spv.CompositeExtract %0[0 : i32] : vector<3xi32>
%2 = spv.CompositeExtract %0[1 : i32] : vector<3xi32> %2 = spv.CompositeExtract %0[1 : i32] : vector<3xi32>
%3 = spv.CompositeExtract %0[2 : i32] : vector<3xi32> %3 = spv.CompositeExtract %0[2 : i32] : vector<3xi32>
return %1, %2, %3 : i32, i32, i32 return %1, %2, %3 : i32, i32, i32
} }
// ----- // -----
// CHECK-LABEL: extract_array_final // CHECK-LABEL: extract_array_final
func @extract_array_final() -> (i32, i32) { func @extract_array_final() -> (i32, i32) {
// CHECK: spv.constant 4 : i32 // CHECK: spv.Constant 4 : i32
// CHECK: spv.constant -5 : i32 // CHECK: spv.Constant -5 : i32
%0 = spv.constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>> %0 = spv.Constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
%1 = spv.CompositeExtract %0[0 : i32, 0 : i32] : !spv.array<1 x vector<2 x i32>> %1 = spv.CompositeExtract %0[0 : i32, 0 : i32] : !spv.array<1 x vector<2 x i32>>
%2 = spv.CompositeExtract %0[0 : i32, 1 : i32] : !spv.array<1 x vector<2 x i32>> %2 = spv.CompositeExtract %0[0 : i32, 1 : i32] : !spv.array<1 x vector<2 x i32>>
return %1, %2 : i32, i32 return %1, %2 : i32, i32
} }
// ----- // -----
// CHECK-LABEL: extract_array_interm // CHECK-LABEL: extract_array_interm
func @extract_array_interm() -> (vector<2xi32>) { func @extract_array_interm() -> (vector<2xi32>) {
// CHECK: spv.constant dense<[4, -5]> : vector<2xi32> // CHECK: spv.Constant dense<[4, -5]> : vector<2xi32>
%0 = spv.constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>> %0 = spv.Constant [dense<[4, -5]> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.array<1 x vector<2 x i32>> %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<1 x vector<2 x i32>>
return %1 : vector<2xi32> return %1 : vector<2xi32>
} }
// ----- // -----
// CHECK-LABEL: extract_from_not_constant // CHECK-LABEL: extract_from_not_constant
func @extract_from_not_constant() -> i32 { func @extract_from_not_constant() -> i32 {
%0 = spv.Variable : !spv.ptr<vector<3xi32>, Function> %0 = spv.Variable : !spv.ptr<vector<3xi32>, Function>
%1 = spv.Load "Function" %0 : vector<3xi32> %1 = spv.Load "Function" %0 : vector<3xi32>
// CHECK: spv.CompositeExtract // CHECK: spv.CompositeExtract
%2 = spv.CompositeExtract %1[0 : i32] : vector<3xi32> %2 = spv.CompositeExtract %1[0 : i32] : vector<3xi32>
spv.ReturnValue %2 : i32 spv.ReturnValue %2 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.constant // spv.Constant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TODO: test constants in different blocks // TODO: test constants in different blocks
func @deduplicate_scalar_constant() -> (i32, i32) { func @deduplicate_scalar_constant() -> (i32, i32) {
// CHECK: %[[CST:.*]] = spv.constant 42 : i32 // CHECK: %[[CST:.*]] = spv.Constant 42 : i32
%0 = spv.constant 42 : i32 %0 = spv.Constant 42 : i32
%1 = spv.constant 42 : i32 %1 = spv.Constant 42 : i32
// CHECK-NEXT: return %[[CST]], %[[CST]] // CHECK-NEXT: return %[[CST]], %[[CST]]
return %0, %1 : i32, i32 return %0, %1 : i32, i32
} }
// ----- // -----
func @deduplicate_vector_constant() -> (vector<3xi32>, vector<3xi32>) { func @deduplicate_vector_constant() -> (vector<3xi32>, vector<3xi32>) {
// CHECK: %[[CST:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[CST:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%0 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %0 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK-NEXT: return %[[CST]], %[[CST]] // CHECK-NEXT: return %[[CST]], %[[CST]]
return %0, %1 : vector<3xi32>, vector<3xi32> return %0, %1 : vector<3xi32>, vector<3xi32>
} }
// ----- // -----
func @deduplicate_composite_constant() -> (!spv.array<1 x vector<2xi32>>, !spv.array<1 x vector<2xi32>>) { func @deduplicate_composite_constant() -> (!spv.array<1 x vector<2xi32>>, !spv.array<1 x vector<2xi32>>) {
// CHECK: %[[CST:.*]] = spv.constant [dense<5> : vector<2xi32>] : !spv.array<1 x vector<2xi32>> // CHECK: %[[CST:.*]] = spv.Constant [dense<5> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
%0 = spv.constant [dense<5> : vector<2xi32>] : !spv.array<1 x vector<2xi32>> %0 = spv.Constant [dense<5> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
%1 = spv.constant [dense<5> : vector<2xi32>] : !spv.array<1 x vector<2xi32>> %1 = spv.Constant [dense<5> : vector<2xi32>] : !spv.array<1 x vector<2xi32>>
// CHECK-NEXT: return %[[CST]], %[[CST]] // CHECK-NEXT: return %[[CST]], %[[CST]]
return %0, %1 : !spv.array<1 x vector<2xi32>>, !spv.array<1 x vector<2xi32>> return %0, %1 : !spv.array<1 x vector<2xi32>>, !spv.array<1 x vector<2xi32>>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IAdd // spv.IAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @iadd_zero // CHECK-LABEL: @iadd_zero
// CHECK-SAME: (%[[ARG:.*]]: i32) // CHECK-SAME: (%[[ARG:.*]]: i32)
func @iadd_zero(%arg0: i32) -> (i32, i32) { func @iadd_zero(%arg0: i32) -> (i32, i32) {
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
%0 = spv.IAdd %arg0, %zero : i32 %0 = spv.IAdd %arg0, %zero : i32
%1 = spv.IAdd %zero, %arg0 : i32 %1 = spv.IAdd %zero, %arg0 : i32
// CHECK: return %[[ARG]], %[[ARG]] // CHECK: return %[[ARG]], %[[ARG]]
return %0, %1: i32, i32 return %0, %1: i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_iadd_normal // CHECK-LABEL: @const_fold_scalar_iadd_normal
func @const_fold_scalar_iadd_normal() -> (i32, i32, i32) { func @const_fold_scalar_iadd_normal() -> (i32, i32, i32) {
%c5 = spv.constant 5 : i32 %c5 = spv.Constant 5 : i32
%cn8 = spv.constant -8 : i32 %cn8 = spv.Constant -8 : i32
// CHECK: spv.constant 10 // CHECK: spv.Constant 10
// CHECK: spv.constant -16 // CHECK: spv.Constant -16
// CHECK: spv.constant -3 // CHECK: spv.Constant -3
%0 = spv.IAdd %c5, %c5 : i32 %0 = spv.IAdd %c5, %c5 : i32
%1 = spv.IAdd %cn8, %cn8 : i32 %1 = spv.IAdd %cn8, %cn8 : i32
%2 = spv.IAdd %c5, %cn8 : i32 %2 = spv.IAdd %c5, %cn8 : i32
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_iadd_flow // CHECK-LABEL: @const_fold_scalar_iadd_flow
func @const_fold_scalar_iadd_flow() -> (i32, i32, i32, i32) { func @const_fold_scalar_iadd_flow() -> (i32, i32, i32, i32) {
%c1 = spv.constant 1 : i32 %c1 = spv.Constant 1 : i32
%c2 = spv.constant 2 : i32 %c2 = spv.Constant 2 : i32
%c3 = spv.constant 4294967295 : i32 // 2^32 - 1: 0xffff ffff %c3 = spv.Constant 4294967295 : i32 // 2^32 - 1: 0xffff ffff
%c4 = spv.constant -2147483648 : i32 // -2^31 : 0x8000 0000 %c4 = spv.Constant -2147483648 : i32 // -2^31 : 0x8000 0000
%c5 = spv.constant -1 : i32 // : 0xffff ffff %c5 = spv.Constant -1 : i32 // : 0xffff ffff
%c6 = spv.constant -2 : i32 // : 0xffff fffe %c6 = spv.Constant -2 : i32 // : 0xffff fffe
// 0x0000 0001 + 0xffff ffff = 0x1 0000 0000 -> 0x0000 0000 // 0x0000 0001 + 0xffff ffff = 0x1 0000 0000 -> 0x0000 0000
// CHECK: spv.constant 0 // CHECK: spv.Constant 0
%0 = spv.IAdd %c1, %c3 : i32 %0 = spv.IAdd %c1, %c3 : i32
// 0x0000 0002 + 0xffff ffff = 0x1 0000 0001 -> 0x0000 0001 // 0x0000 0002 + 0xffff ffff = 0x1 0000 0001 -> 0x0000 0001
// CHECK: spv.constant 1 // CHECK: spv.Constant 1
%1 = spv.IAdd %c2, %c3 : i32 %1 = spv.IAdd %c2, %c3 : i32
// 0x8000 0000 + 0xffff ffff = 0x1 7fff ffff -> 0x7fff ffff // 0x8000 0000 + 0xffff ffff = 0x1 7fff ffff -> 0x7fff ffff
// CHECK: spv.constant 2147483647 // CHECK: spv.Constant 2147483647
%2 = spv.IAdd %c4, %c5 : i32 %2 = spv.IAdd %c4, %c5 : i32
// 0x8000 0000 + 0xffff fffe = 0x1 7fff fffe -> 0x7fff fffe // 0x8000 0000 + 0xffff fffe = 0x1 7fff fffe -> 0x7fff fffe
// CHECK: spv.constant 2147483646 // CHECK: spv.Constant 2147483646
%3 = spv.IAdd %c4, %c6 : i32 %3 = spv.IAdd %c4, %c6 : i32
return %0, %1, %2, %3: i32, i32, i32, i32 return %0, %1, %2, %3: i32, i32, i32, i32
} }
// CHECK-LABEL: @const_fold_vector_iadd // CHECK-LABEL: @const_fold_vector_iadd
func @const_fold_vector_iadd() -> vector<3xi32> { func @const_fold_vector_iadd() -> vector<3xi32> {
%vc1 = spv.constant dense<[42, -55, 127]> : vector<3xi32> %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
%vc2 = spv.constant dense<[-3, -15, 28]> : vector<3xi32> %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>
// CHECK: spv.constant dense<[39, -70, 155]> // CHECK: spv.Constant dense<[39, -70, 155]>
%0 = spv.IAdd %vc1, %vc2 : vector<3xi32> %0 = spv.IAdd %vc1, %vc2 : vector<3xi32>
return %0: vector<3xi32> return %0: vector<3xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IMul // spv.IMul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @imul_zero_one // CHECK-LABEL: @imul_zero_one
// CHECK-SAME: (%[[ARG:.*]]: i32) // CHECK-SAME: (%[[ARG:.*]]: i32)
func @imul_zero_one(%arg0: i32) -> (i32, i32) { func @imul_zero_one(%arg0: i32) -> (i32, i32) {
// CHECK: %[[ZERO:.*]] = spv.constant 0 // CHECK: %[[ZERO:.*]] = spv.Constant 0
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%0 = spv.IMul %arg0, %zero : i32 %0 = spv.IMul %arg0, %zero : i32
%1 = spv.IMul %one, %arg0 : i32 %1 = spv.IMul %one, %arg0 : i32
// CHECK: return %[[ZERO]], %[[ARG]] // CHECK: return %[[ZERO]], %[[ARG]]
return %0, %1: i32, i32 return %0, %1: i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_imul_normal // CHECK-LABEL: @const_fold_scalar_imul_normal
func @const_fold_scalar_imul_normal() -> (i32, i32, i32) { func @const_fold_scalar_imul_normal() -> (i32, i32, i32) {
%c5 = spv.constant 5 : i32 %c5 = spv.Constant 5 : i32
%cn8 = spv.constant -8 : i32 %cn8 = spv.Constant -8 : i32
%c7 = spv.constant 7 : i32 %c7 = spv.Constant 7 : i32
// CHECK: spv.constant 35 // CHECK: spv.Constant 35
// CHECK: spv.constant -40 // CHECK: spv.Constant -40
// CHECK: spv.constant -56 // CHECK: spv.Constant -56
%0 = spv.IMul %c7, %c5 : i32 %0 = spv.IMul %c7, %c5 : i32
%1 = spv.IMul %c5, %cn8 : i32 %1 = spv.IMul %c5, %cn8 : i32
%2 = spv.IMul %cn8, %c7 : i32 %2 = spv.IMul %cn8, %c7 : i32
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_imul_flow // CHECK-LABEL: @const_fold_scalar_imul_flow
func @const_fold_scalar_imul_flow() -> (i32, i32, i32) { func @const_fold_scalar_imul_flow() -> (i32, i32, i32) {
%c1 = spv.constant 2 : i32 %c1 = spv.Constant 2 : i32
%c2 = spv.constant 4 : i32 %c2 = spv.Constant 4 : i32
%c3 = spv.constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff %c3 = spv.Constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff
%c4 = spv.constant 2147483647 : i32 // 2^31 - 1 : 0x7fff ffff %c4 = spv.Constant 2147483647 : i32 // 2^31 - 1 : 0x7fff ffff
// (0xffff ffff << 1) = 0x1 ffff fffe -> 0xffff fffe // (0xffff ffff << 1) = 0x1 ffff fffe -> 0xffff fffe
// CHECK: %[[CST2:.*]] = spv.constant -2 // CHECK: %[[CST2:.*]] = spv.Constant -2
%0 = spv.IMul %c1, %c3 : i32 %0 = spv.IMul %c1, %c3 : i32
// (0x7fff ffff << 1) = 0x0 ffff fffe -> 0xffff fffe // (0x7fff ffff << 1) = 0x0 ffff fffe -> 0xffff fffe
%1 = spv.IMul %c1, %c4 : i32 %1 = spv.IMul %c1, %c4 : i32
// (0x7fff ffff << 2) = 0x1 ffff fffc -> 0xffff fffc // (0x7fff ffff << 2) = 0x1 ffff fffc -> 0xffff fffc
// CHECK: %[[CST4:.*]] = spv.constant -4 // CHECK: %[[CST4:.*]] = spv.Constant -4
%2 = spv.IMul %c4, %c2 : i32 %2 = spv.IMul %c4, %c2 : i32
// CHECK: return %[[CST2]], %[[CST2]], %[[CST4]] // CHECK: return %[[CST2]], %[[CST2]], %[[CST4]]
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_vector_imul // CHECK-LABEL: @const_fold_vector_imul
func @const_fold_vector_imul() -> vector<3xi32> { func @const_fold_vector_imul() -> vector<3xi32> {
%vc1 = spv.constant dense<[42, -55, 127]> : vector<3xi32> %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
%vc2 = spv.constant dense<[-3, -15, 28]> : vector<3xi32> %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>
// CHECK: spv.constant dense<[-126, 825, 3556]> // CHECK: spv.Constant dense<[-126, 825, 3556]>
%0 = spv.IMul %vc1, %vc2 : vector<3xi32> %0 = spv.IMul %vc1, %vc2 : vector<3xi32>
return %0: vector<3xi32> return %0: vector<3xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ISub // spv.ISub
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @isub_x_x // CHECK-LABEL: @isub_x_x
func @isub_x_x(%arg0: i32) -> i32 { func @isub_x_x(%arg0: i32) -> i32 {
// CHECK: spv.constant 0 // CHECK: spv.Constant 0
%0 = spv.ISub %arg0, %arg0: i32 %0 = spv.ISub %arg0, %arg0: i32
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @const_fold_scalar_isub_normal // CHECK-LABEL: @const_fold_scalar_isub_normal
func @const_fold_scalar_isub_normal() -> (i32, i32, i32) { func @const_fold_scalar_isub_normal() -> (i32, i32, i32) {
%c5 = spv.constant 5 : i32 %c5 = spv.Constant 5 : i32
%cn8 = spv.constant -8 : i32 %cn8 = spv.Constant -8 : i32
%c7 = spv.constant 7 : i32 %c7 = spv.Constant 7 : i32
// CHECK: spv.constant 2 // CHECK: spv.Constant 2
// CHECK: spv.constant 13 // CHECK: spv.Constant 13
// CHECK: spv.constant -15 // CHECK: spv.Constant -15
%0 = spv.ISub %c7, %c5 : i32 %0 = spv.ISub %c7, %c5 : i32
%1 = spv.ISub %c5, %cn8 : i32 %1 = spv.ISub %c5, %cn8 : i32
%2 = spv.ISub %cn8, %c7 : i32 %2 = spv.ISub %cn8, %c7 : i32
return %0, %1, %2: i32, i32, i32 return %0, %1, %2: i32, i32, i32
} }
// CHECK-LABEL: @const_fold_scalar_isub_flow // CHECK-LABEL: @const_fold_scalar_isub_flow
func @const_fold_scalar_isub_flow() -> (i32, i32, i32, i32) { func @const_fold_scalar_isub_flow() -> (i32, i32, i32, i32) {
%c1 = spv.constant 0 : i32 %c1 = spv.Constant 0 : i32
%c2 = spv.constant 1 : i32 %c2 = spv.Constant 1 : i32
%c3 = spv.constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff %c3 = spv.Constant 4294967295 : i32 // 2^32 - 1 : 0xffff ffff
%c4 = spv.constant 2147483647 : i32 // 2^31 : 0x7fff ffff %c4 = spv.Constant 2147483647 : i32 // 2^31 : 0x7fff ffff
%c5 = spv.constant -1 : i32 // : 0xffff ffff %c5 = spv.Constant -1 : i32 // : 0xffff ffff
%c6 = spv.constant -2 : i32 // : 0xffff fffe %c6 = spv.Constant -2 : i32 // : 0xffff fffe
// 0x0000 0000 - 0xffff ffff -> 0x0000 0000 + 0x0000 0001 = 0x0000 0001 // 0x0000 0000 - 0xffff ffff -> 0x0000 0000 + 0x0000 0001 = 0x0000 0001
// CHECK: spv.constant 1 // CHECK: spv.Constant 1
%0 = spv.ISub %c1, %c3 : i32 %0 = spv.ISub %c1, %c3 : i32
// 0x0000 0001 - 0xffff ffff -> 0x0000 0001 + 0x0000 0001 = 0x0000 0002 // 0x0000 0001 - 0xffff ffff -> 0x0000 0001 + 0x0000 0001 = 0x0000 0002
// CHECK: spv.constant 2 // CHECK: spv.Constant 2
%1 = spv.ISub %c2, %c3 : i32 %1 = spv.ISub %c2, %c3 : i32
// 0xffff ffff - 0x7fff ffff -> 0xffff ffff + 0x8000 0001 = 0x1 8000 0000 // 0xffff ffff - 0x7fff ffff -> 0xffff ffff + 0x8000 0001 = 0x1 8000 0000
// CHECK: spv.constant -2147483648 // CHECK: spv.Constant -2147483648
%2 = spv.ISub %c5, %c4 : i32 %2 = spv.ISub %c5, %c4 : i32
// 0xffff fffe - 0x7fff ffff -> 0xffff fffe + 0x8000 0001 = 0x1 7fff ffff // 0xffff fffe - 0x7fff ffff -> 0xffff fffe + 0x8000 0001 = 0x1 7fff ffff
// CHECK: spv.constant 2147483647 // CHECK: spv.Constant 2147483647
%3 = spv.ISub %c6, %c4 : i32 %3 = spv.ISub %c6, %c4 : i32
return %0, %1, %2, %3: i32, i32, i32, i32 return %0, %1, %2, %3: i32, i32, i32, i32
} }
// CHECK-LABEL: @const_fold_vector_isub // CHECK-LABEL: @const_fold_vector_isub
func @const_fold_vector_isub() -> vector<3xi32> { func @const_fold_vector_isub() -> vector<3xi32> {
%vc1 = spv.constant dense<[42, -55, 127]> : vector<3xi32> %vc1 = spv.Constant dense<[42, -55, 127]> : vector<3xi32>
%vc2 = spv.constant dense<[-3, -15, 28]> : vector<3xi32> %vc2 = spv.Constant dense<[-3, -15, 28]> : vector<3xi32>
// CHECK: spv.constant dense<[45, -40, 99]> // CHECK: spv.Constant dense<[45, -40, 99]>
%0 = spv.ISub %vc1, %vc2 : vector<3xi32> %0 = spv.ISub %vc1, %vc2 : vector<3xi32>
return %0: vector<3xi32> return %0: vector<3xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalAnd // spv.LogicalAnd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @convert_logical_and_true_false_scalar // CHECK-LABEL: @convert_logical_and_true_false_scalar
// CHECK-SAME: %[[ARG:.+]]: i1 // CHECK-SAME: %[[ARG:.+]]: i1
func @convert_logical_and_true_false_scalar(%arg: i1) -> (i1, i1) { func @convert_logical_and_true_false_scalar(%arg: i1) -> (i1, i1) {
%true = spv.constant true %true = spv.Constant true
// CHECK: %[[FALSE:.+]] = spv.constant false // CHECK: %[[FALSE:.+]] = spv.Constant false
%false = spv.constant false %false = spv.Constant false
%0 = spv.LogicalAnd %true, %arg: i1 %0 = spv.LogicalAnd %true, %arg: i1
%1 = spv.LogicalAnd %arg, %false: i1 %1 = spv.LogicalAnd %arg, %false: i1
// CHECK: return %[[ARG]], %[[FALSE]] // CHECK: return %[[ARG]], %[[FALSE]]
return %0, %1: i1, i1 return %0, %1: i1, i1
} }
// CHECK-LABEL: @convert_logical_and_true_false_vector // CHECK-LABEL: @convert_logical_and_true_false_vector
// CHECK-SAME: %[[ARG:.+]]: vector<3xi1> // CHECK-SAME: %[[ARG:.+]]: vector<3xi1>
func @convert_logical_and_true_false_vector(%arg: vector<3xi1>) -> (vector<3xi1>, vector<3xi1>) { func @convert_logical_and_true_false_vector(%arg: vector<3xi1>) -> (vector<3xi1>, vector<3xi1>) {
%true = spv.constant dense<true> : vector<3xi1> %true = spv.Constant dense<true> : vector<3xi1>
// CHECK: %[[FALSE:.+]] = spv.constant dense<false> // CHECK: %[[FALSE:.+]] = spv.Constant dense<false>
%false = spv.constant dense<false> : vector<3xi1> %false = spv.Constant dense<false> : vector<3xi1>
%0 = spv.LogicalAnd %true, %arg: vector<3xi1> %0 = spv.LogicalAnd %true, %arg: vector<3xi1>
%1 = spv.LogicalAnd %arg, %false: vector<3xi1> %1 = spv.LogicalAnd %arg, %false: vector<3xi1>
// CHECK: return %[[ARG]], %[[FALSE]] // CHECK: return %[[ARG]], %[[FALSE]]
return %0, %1: vector<3xi1>, vector<3xi1> return %0, %1: vector<3xi1>, vector<3xi1>
} }
// ----- // -----
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalOr // spv.LogicalOr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @convert_logical_or_true_false_scalar // CHECK-LABEL: @convert_logical_or_true_false_scalar
// CHECK-SAME: %[[ARG:.+]]: i1 // CHECK-SAME: %[[ARG:.+]]: i1
func @convert_logical_or_true_false_scalar(%arg: i1) -> (i1, i1) { func @convert_logical_or_true_false_scalar(%arg: i1) -> (i1, i1) {
// CHECK: %[[TRUE:.+]] = spv.constant true // CHECK: %[[TRUE:.+]] = spv.Constant true
%true = spv.constant true %true = spv.Constant true
%false = spv.constant false %false = spv.Constant false
%0 = spv.LogicalOr %true, %arg: i1 %0 = spv.LogicalOr %true, %arg: i1
%1 = spv.LogicalOr %arg, %false: i1 %1 = spv.LogicalOr %arg, %false: i1
// CHECK: return %[[TRUE]], %[[ARG]] // CHECK: return %[[TRUE]], %[[ARG]]
return %0, %1: i1, i1 return %0, %1: i1, i1
} }
// CHECK-LABEL: @convert_logical_or_true_false_vector // CHECK-LABEL: @convert_logical_or_true_false_vector
// CHECK-SAME: %[[ARG:.+]]: vector<3xi1> // CHECK-SAME: %[[ARG:.+]]: vector<3xi1>
func @convert_logical_or_true_false_vector(%arg: vector<3xi1>) -> (vector<3xi1>, vector<3xi1>) { func @convert_logical_or_true_false_vector(%arg: vector<3xi1>) -> (vector<3xi1>, vector<3xi1>) {
// CHECK: %[[TRUE:.+]] = spv.constant dense<true> // CHECK: %[[TRUE:.+]] = spv.Constant dense<true>
%true = spv.constant dense<true> : vector<3xi1> %true = spv.Constant dense<true> : vector<3xi1>
%false = spv.constant dense<false> : vector<3xi1> %false = spv.Constant dense<false> : vector<3xi1>
%0 = spv.LogicalOr %true, %arg: vector<3xi1> %0 = spv.LogicalOr %true, %arg: vector<3xi1>
%1 = spv.LogicalOr %arg, %false: vector<3xi1> %1 = spv.LogicalOr %arg, %false: vector<3xi1>
// CHECK: return %[[TRUE]], %[[ARG]] // CHECK: return %[[TRUE]], %[[ARG]]
return %0, %1: vector<3xi1>, vector<3xi1> return %0, %1: vector<3xi1>, vector<3xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.selection // spv.selection
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @canonicalize_selection_op_scalar_type(%cond: i1) -> () { func @canonicalize_selection_op_scalar_type(%cond: i1) -> () {
%0 = spv.constant 0: i32 %0 = spv.Constant 0: i32
// CHECK: %[[TRUE_VALUE:.*]] = spv.constant 1 : i32 // CHECK: %[[TRUE_VALUE:.*]] = spv.Constant 1 : i32
%1 = spv.constant 1: i32 %1 = spv.Constant 1: i32
// CHECK: %[[FALSE_VALUE:.*]] = spv.constant 2 : i32 // CHECK: %[[FALSE_VALUE:.*]] = spv.Constant 2 : i32
%2 = spv.constant 2: i32 %2 = spv.Constant 2: i32
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<i32, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<i32, Function>
%3 = spv.Variable init(%0) : !spv.ptr<i32, Function> %3 = spv.Variable init(%0) : !spv.ptr<i32, Function>
// CHECK: %[[SRC_VALUE:.*]] = spv.Select {{%.*}}, %[[TRUE_VALUE]], %[[FALSE_VALUE]] : i1, i32 // CHECK: %[[SRC_VALUE:.*]] = spv.Select {{%.*}}, %[[TRUE_VALUE]], %[[FALSE_VALUE]] : i1, i32
// CHECK-NEXT: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE]] ["Aligned", 4] : i32 // CHECK-NEXT: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE]] ["Aligned", 4] : i32
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
Show All 10 Lines ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
func @canonicalize_selection_op_vector_type(%cond: i1) -> () { func @canonicalize_selection_op_vector_type(%cond: i1) -> () {
%0 = spv.constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[TRUE_VALUE:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[TRUE_VALUE:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[FALSE_VALUE:.*]] = spv.constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[FALSE_VALUE:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: %[[SRC_VALUE:.*]] = spv.Select {{%.*}}, %[[TRUE_VALUE]], %[[FALSE_VALUE]] : i1, vector<3xi32> // CHECK: %[[SRC_VALUE:.*]] = spv.Select {{%.*}}, %[[TRUE_VALUE]], %[[FALSE_VALUE]] : i1, vector<3xi32>
// CHECK-NEXT: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE]] ["Aligned", 8] : vector<3xi32> // CHECK-NEXT: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE]] ["Aligned", 8] : vector<3xi32>
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
Show All 11 Linesfunc @canonicalize_selection_op_vector_type(%cond: i1) -> () {
} }
spv.Return spv.Return
} }
// ----- // -----
// Store to a different variables. // Store to a different variables.
func @cannot_canonicalize_selection_op_0(%cond: i1) -> () { func @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
%0 = spv.constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
// CHECK: spv.BranchConditional // CHECK: spv.BranchConditional
Show All 16 Linesfunc @cannot_canonicalize_selection_op_0(%cond: i1) -> () {
} }
spv.Return spv.Return
} }
// ----- // -----
// A conditional block consists of more than 2 operations. // A conditional block consists of more than 2 operations.
func @cannot_canonicalize_selection_op_1(%cond: i1) -> () { func @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
%0 = spv.constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_0:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR_1:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %4 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
Show All 15 Linesfunc @cannot_canonicalize_selection_op_1(%cond: i1) -> () {
} }
spv.Return spv.Return
} }
// ----- // -----
// A control-flow goes into `^then` block from `^else` block. // A control-flow goes into `^then` block from `^else` block.
func @cannot_canonicalize_selection_op_2(%cond: i1) -> () { func @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
%0 = spv.constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
^then: ^then:
Show All 11 Linesfunc @cannot_canonicalize_selection_op_2(%cond: i1) -> () {
} }
spv.Return spv.Return
} }
// ----- // -----
// `spv.Return` as a block terminator. // `spv.Return` as a block terminator.
func @cannot_canonicalize_selection_op_3(%cond: i1) -> () { func @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
%0 = spv.constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
^then: ^then:
Show All 11 Linesfunc @cannot_canonicalize_selection_op_3(%cond: i1) -> () {
} }
spv.Return spv.Return
} }
// ----- // -----
// Different memory access attributes. // Different memory access attributes.
func @cannot_canonicalize_selection_op_4(%cond: i1) -> () { func @cannot_canonicalize_selection_op_4(%cond: i1) -> () {
%0 = spv.constant dense<[0, 1, 2]> : vector<3xi32> %0 = spv.Constant dense<[0, 1, 2]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_0:.*]] = spv.constant dense<[1, 2, 3]> : vector<3xi32> // CHECK: %[[SRC_VALUE_0:.*]] = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
%1 = spv.constant dense<[1, 2, 3]> : vector<3xi32> %1 = spv.Constant dense<[1, 2, 3]> : vector<3xi32>
// CHECK: %[[SRC_VALUE_1:.*]] = spv.constant dense<[2, 3, 4]> : vector<3xi32> // CHECK: %[[SRC_VALUE_1:.*]] = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, 3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, 3, 4]> : vector<3xi32>
// CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function> // CHECK: %[[DST_VAR:.*]] = spv.Variable init({{%.*}}) : !spv.ptr<vector<3xi32>, Function>
%3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function> %3 = spv.Variable init(%0) : !spv.ptr<vector<3xi32>, Function>
// CHECK: spv.selection { // CHECK: spv.selection {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
^then: ^then:
Show All 14 Lines

mlir/test/Dialect/SPIRV/Transforms/glsl_canonicalize.mlir

// RUN: mlir-opt -test-spirv-glsl-canonicalization -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -test-spirv-glsl-canonicalization -split-input-file -verify-diagnostics %s | FileCheck %s
// CHECK: func @clamp_fordlessthan(%[[INPUT:.*]]: f32) // CHECK: func @clamp_fordlessthan(%[[INPUT:.*]]: f32)
func @clamp_fordlessthan(%input: f32) -> f32 { func @clamp_fordlessthan(%input: f32) -> f32 {
// CHECK: %[[MIN:.*]] = spv.constant // CHECK: %[[MIN:.*]] = spv.Constant
%min = spv.constant 0.5 : f32 %min = spv.Constant 0.5 : f32
// CHECK: %[[MAX:.*]] = spv.constant // CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.constant 1.0 : f32 %max = spv.Constant 1.0 : f32
// CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.FOrdLessThan %min, %input : f32 %0 = spv.FOrdLessThan %min, %input : f32
%mid = spv.Select %0, %input, %min : i1, f32 %mid = spv.Select %0, %input, %min : i1, f32
%1 = spv.FOrdLessThan %mid, %max : f32 %1 = spv.FOrdLessThan %mid, %max : f32
%2 = spv.Select %1, %mid, %max : i1, f32 %2 = spv.Select %1, %mid, %max : i1, f32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : f32 spv.ReturnValue %2 : f32
} }
// ----- // -----
// CHECK: func @clamp_fordlessthanequal(%[[INPUT:.*]]: f32) // CHECK: func @clamp_fordlessthanequal(%[[INPUT:.*]]: f32)
func @clamp_fordlessthanequal(%input: f32) -> f32 { func @clamp_fordlessthanequal(%input: f32) -> f32 {
// CHECK: %[[MIN:.*]] = spv.constant // CHECK: %[[MIN:.*]] = spv.Constant
%min = spv.constant 0.5 : f32 %min = spv.Constant 0.5 : f32
// CHECK: %[[MAX:.*]] = spv.constant // CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.constant 1.0 : f32 %max = spv.Constant 1.0 : f32
// CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.FOrdLessThanEqual %min, %input : f32 %0 = spv.FOrdLessThanEqual %min, %input : f32
%mid = spv.Select %0, %input, %min : i1, f32 %mid = spv.Select %0, %input, %min : i1, f32
%1 = spv.FOrdLessThanEqual %mid, %max : f32 %1 = spv.FOrdLessThanEqual %mid, %max : f32
%2 = spv.Select %1, %mid, %max : i1, f32 %2 = spv.Select %1, %mid, %max : i1, f32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : f32 spv.ReturnValue %2 : f32
} }
// ----- // -----
// CHECK: func @clamp_slessthan(%[[INPUT:.*]]: si32) // CHECK: func @clamp_slessthan(%[[INPUT:.*]]: si32)
func @clamp_slessthan(%input: si32) -> si32 { func @clamp_slessthan(%input: si32) -> si32 {
// CHECK: %[[MIN:.*]] = spv.constant // CHECK: %[[MIN:.*]] = spv.Constant
%min = spv.constant 0 : si32 %min = spv.Constant 0 : si32
// CHECK: %[[MAX:.*]] = spv.constant // CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.constant 10 : si32 %max = spv.Constant 10 : si32
// CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.SLessThan %min, %input : si32 %0 = spv.SLessThan %min, %input : si32
%mid = spv.Select %0, %input, %min : i1, si32 %mid = spv.Select %0, %input, %min : i1, si32
%1 = spv.SLessThan %mid, %max : si32 %1 = spv.SLessThan %mid, %max : si32
%2 = spv.Select %1, %mid, %max : i1, si32 %2 = spv.Select %1, %mid, %max : i1, si32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : si32 spv.ReturnValue %2 : si32
} }
// ----- // -----
// CHECK: func @clamp_slessthanequal(%[[INPUT:.*]]: si32) // CHECK: func @clamp_slessthanequal(%[[INPUT:.*]]: si32)
func @clamp_slessthanequal(%input: si32) -> si32 { func @clamp_slessthanequal(%input: si32) -> si32 {
// CHECK: %[[MIN:.*]] = spv.constant // CHECK: %[[MIN:.*]] = spv.Constant
%min = spv.constant 0 : si32 %min = spv.Constant 0 : si32
// CHECK: %[[MAX:.*]] = spv.constant // CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.constant 10 : si32 %max = spv.Constant 10 : si32
// CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.SLessThanEqual %min, %input : si32 %0 = spv.SLessThanEqual %min, %input : si32
%mid = spv.Select %0, %input, %min : i1, si32 %mid = spv.Select %0, %input, %min : i1, si32
%1 = spv.SLessThanEqual %mid, %max : si32 %1 = spv.SLessThanEqual %mid, %max : si32
%2 = spv.Select %1, %mid, %max : i1, si32 %2 = spv.Select %1, %mid, %max : i1, si32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : si32 spv.ReturnValue %2 : si32
} }
// ----- // -----
// CHECK: func @clamp_ulessthan(%[[INPUT:.*]]: i32) // CHECK: func @clamp_ulessthan(%[[INPUT:.*]]: i32)
func @clamp_ulessthan(%input: i32) -> i32 { func @clamp_ulessthan(%input: i32) -> i32 {
// CHECK: %[[MIN:.*]] = spv.constant // CHECK: %[[MIN:.*]] = spv.Constant
%min = spv.constant 0 : i32 %min = spv.Constant 0 : i32
// CHECK: %[[MAX:.*]] = spv.constant // CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.constant 10 : i32 %max = spv.Constant 10 : i32
// CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.ULessThan %min, %input : i32 %0 = spv.ULessThan %min, %input : i32
%mid = spv.Select %0, %input, %min : i1, i32 %mid = spv.Select %0, %input, %min : i1, i32
%1 = spv.ULessThan %mid, %max : i32 %1 = spv.ULessThan %mid, %max : i32
%2 = spv.Select %1, %mid, %max : i1, i32 %2 = spv.Select %1, %mid, %max : i1, i32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : i32 spv.ReturnValue %2 : i32
} }
// ----- // -----
// CHECK: func @clamp_ulessthanequal(%[[INPUT:.*]]: i32) // CHECK: func @clamp_ulessthanequal(%[[INPUT:.*]]: i32)
func @clamp_ulessthanequal(%input: i32) -> i32 { func @clamp_ulessthanequal(%input: i32) -> i32 {
// CHECK: %[[MIN:.*]] = spv.constant // CHECK: %[[MIN:.*]] = spv.Constant
%min = spv.constant 0 : i32 %min = spv.Constant 0 : i32
// CHECK: %[[MAX:.*]] = spv.constant // CHECK: %[[MAX:.*]] = spv.Constant
%max = spv.constant 10 : i32 %max = spv.Constant 10 : i32
// CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]] // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
%0 = spv.ULessThanEqual %min, %input : i32 %0 = spv.ULessThanEqual %min, %input : i32
%mid = spv.Select %0, %input, %min : i1, i32 %mid = spv.Select %0, %input, %min : i1, i32
%1 = spv.ULessThanEqual %mid, %max : i32 %1 = spv.ULessThanEqual %mid, %max : i32
%2 = spv.Select %1, %mid, %max : i1, i32 %2 = spv.Select %1, %mid, %max : i1, i32
// CHECK-NEXT: spv.ReturnValue [[RES]] // CHECK-NEXT: spv.ReturnValue [[RES]]
spv.ReturnValue %2 : i32 spv.ReturnValue %2 : i32
} }

mlir/test/Dialect/SPIRV/Transforms/inlining.mlir

Show All 11 Lines spv.func @calling_single_block_ret_func() "None" {
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @callee() -> i32 "None" { spv.func @callee() -> i32 "None" {
%0 = spv.constant 42 : i32 %0 = spv.Constant 42 : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// CHECK-LABEL: @calling_single_block_retval_func // CHECK-LABEL: @calling_single_block_retval_func
spv.func @calling_single_block_retval_func() -> i32 "None" { spv.func @calling_single_block_retval_func() -> i32 "None" {
// CHECK-NEXT: %[[CST:.*]] = spv.constant 42 // CHECK-NEXT: %[[CST:.*]] = spv.Constant 42
%0 = spv.FunctionCall @callee() : () -> (i32) %0 = spv.FunctionCall @callee() : () -> (i32)
// CHECK-NEXT: spv.ReturnValue %[[CST]] // CHECK-NEXT: spv.ReturnValue %[[CST]]
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @data bind(0, 0) : !spv.ptr<!spv.struct<(!spv.rtarray<i32> [0])>, StorageBuffer> spv.globalVariable @data bind(0, 0) : !spv.ptr<!spv.struct<(!spv.rtarray<i32> [0])>, StorageBuffer>
spv.func @callee() "None" { spv.func @callee() "None" {
%0 = spv.mlir.addressof @data : !spv.ptr<!spv.struct<(!spv.rtarray<i32> [0])>, StorageBuffer> %0 = spv.mlir.addressof @data : !spv.ptr<!spv.struct<(!spv.rtarray<i32> [0])>, StorageBuffer>
%1 = spv.constant 0: i32 %1 = spv.Constant 0: i32
%2 = spv.AccessChain %0[%1, %1] : !spv.ptr<!spv.struct<(!spv.rtarray<i32> [0])>, StorageBuffer>, i32, i32 %2 = spv.AccessChain %0[%1, %1] : !spv.ptr<!spv.struct<(!spv.rtarray<i32> [0])>, StorageBuffer>, i32, i32
spv.Branch ^next spv.Branch ^next
^next: ^next:
%3 = spv.constant 42: i32 %3 = spv.Constant 42: i32
spv.Store "StorageBuffer" %2, %3 : i32 spv.Store "StorageBuffer" %2, %3 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @calling_multi_block_ret_func // CHECK-LABEL: @calling_multi_block_ret_func
spv.func @calling_multi_block_ret_func() "None" { spv.func @calling_multi_block_ret_func() "None" {
// CHECK-NEXT: spv.mlir.addressof // CHECK-NEXT: spv.mlir.addressof
// CHECK-NEXT: spv.constant 0 // CHECK-NEXT: spv.Constant 0
// CHECK-NEXT: spv.AccessChain // CHECK-NEXT: spv.AccessChain
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: spv.constant // CHECK-NEXT: spv.Constant
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
// CHECK-NEXT: spv.Branch ^bb2 // CHECK-NEXT: spv.Branch ^bb2
spv.FunctionCall @callee() : () -> () spv.FunctionCall @callee() : () -> ()
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
spv.Return spv.Return
} }
} }
Show All 11 Lines spv.func @callee(%cond : i1) -> () "None" {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// CHECK-LABEL: @calling_selection_ret_func // CHECK-LABEL: @calling_selection_ret_func
spv.func @calling_selection_ret_func() "None" { spv.func @calling_selection_ret_func() "None" {
%0 = spv.constant true %0 = spv.Constant true
// CHECK: spv.FunctionCall // CHECK: spv.FunctionCall
spv.FunctionCall @callee(%0) : (i1) -> () spv.FunctionCall @callee(%0) : (i1) -> ()
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @callee(%cond : i1) -> () "None" { spv.func @callee(%cond : i1) -> () "None" {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
^then: ^then:
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// CHECK-LABEL: @calling_selection_no_ret_func // CHECK-LABEL: @calling_selection_no_ret_func
spv.func @calling_selection_no_ret_func() "None" { spv.func @calling_selection_no_ret_func() "None" {
// CHECK-NEXT: %[[TRUE:.*]] = spv.constant true // CHECK-NEXT: %[[TRUE:.*]] = spv.Constant true
%0 = spv.constant true %0 = spv.Constant true
// CHECK-NEXT: spv.selection // CHECK-NEXT: spv.selection
// CHECK-NEXT: spv.BranchConditional %[[TRUE]], ^bb1, ^bb2 // CHECK-NEXT: spv.BranchConditional %[[TRUE]], ^bb1, ^bb2
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: spv.Branch ^bb2 // CHECK-NEXT: spv.Branch ^bb2
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.FunctionCall @callee(%0) : (i1) -> () spv.FunctionCall @callee(%0) : (i1) -> ()
spv.Return spv.Return
Show All 15 Lines spv.func @callee(%cond : i1) -> () "None" {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// CHECK-LABEL: @calling_loop_ret_func // CHECK-LABEL: @calling_loop_ret_func
spv.func @calling_loop_ret_func() "None" { spv.func @calling_loop_ret_func() "None" {
%0 = spv.constant true %0 = spv.Constant true
// CHECK: spv.FunctionCall // CHECK: spv.FunctionCall
spv.FunctionCall @callee(%0) : (i1) -> () spv.FunctionCall @callee(%0) : (i1) -> ()
spv.Return spv.Return
} }
} }
// ----- // -----
Show All 10 Lines spv.func @callee(%cond : i1) -> () "None" {
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// CHECK-LABEL: @calling_loop_no_ret_func // CHECK-LABEL: @calling_loop_no_ret_func
spv.func @calling_loop_no_ret_func() "None" { spv.func @calling_loop_no_ret_func() "None" {
// CHECK-NEXT: %[[TRUE:.*]] = spv.constant true // CHECK-NEXT: %[[TRUE:.*]] = spv.Constant true
%0 = spv.constant true %0 = spv.Constant true
// CHECK-NEXT: spv.loop // CHECK-NEXT: spv.loop
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: spv.BranchConditional %[[TRUE]], ^bb2, ^bb4 // CHECK-NEXT: spv.BranchConditional %[[TRUE]], ^bb2, ^bb4
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
// CHECK-NEXT: spv.Branch ^bb3 // CHECK-NEXT: spv.Branch ^bb3
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
// CHECK-NEXT: ^bb4: // CHECK-NEXT: ^bb4:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.FunctionCall @callee(%0) : (i1) -> () spv.FunctionCall @callee(%0) : (i1) -> ()
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer> spv.globalVariable @arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>
spv.globalVariable @arg_1 bind(0, 1) : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer> spv.globalVariable @arg_1 bind(0, 1) : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>
// CHECK: @inline_into_selection_region // CHECK: @inline_into_selection_region
spv.func @inline_into_selection_region() "None" { spv.func @inline_into_selection_region() "None" {
%1 = spv.constant 0 : i32 %1 = spv.Constant 0 : i32
// CHECK-DAG: [[ADDRESS_ARG0:%.*]] = spv.mlir.addressof @arg_0 // CHECK-DAG: [[ADDRESS_ARG0:%.*]] = spv.mlir.addressof @arg_0
// CHECK-DAG: [[ADDRESS_ARG1:%.*]] = spv.mlir.addressof @arg_1 // CHECK-DAG: [[ADDRESS_ARG1:%.*]] = spv.mlir.addressof @arg_1
// CHECK-DAG: [[LOADPTR:%.*]] = spv.AccessChain [[ADDRESS_ARG0]] // CHECK-DAG: [[LOADPTR:%.*]] = spv.AccessChain [[ADDRESS_ARG0]]
// CHECK: [[VAL:%.*]] = spv.Load "StorageBuffer" [[LOADPTR]] // CHECK: [[VAL:%.*]] = spv.Load "StorageBuffer" [[LOADPTR]]
%2 = spv.mlir.addressof @arg_0 : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer> %2 = spv.mlir.addressof @arg_0 : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>
%3 = spv.mlir.addressof @arg_1 : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer> %3 = spv.mlir.addressof @arg_1 : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>
%4 = spv.AccessChain %2[%1] : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>, i32 %4 = spv.AccessChain %2[%1] : !spv.ptr<!spv.struct<(i32 [0])>, StorageBuffer>, i32
%5 = spv.Load "StorageBuffer" %4 : i32 %5 = spv.Load "StorageBuffer" %4 : i32
Show All 28 Lines

mlir/test/Dialect/SPIRV/Transforms/layout-decoration.mlir

Show All 14 Linesspv.module Logical GLSL450 {
// CHECK: spv.globalVariable @var4 bind(1, 2) : !spv.ptr<!spv.struct<(!spv.struct<(!spv.struct<(i1 [0], i8 [1], i16 [2], i32 [4], i64 [8])> [0], f32 [16], i1 [20])> [0], i1 [24])>, StorageBuffer> // CHECK: spv.globalVariable @var4 bind(1, 2) : !spv.ptr<!spv.struct<(!spv.struct<(!spv.struct<(i1 [0], i8 [1], i16 [2], i32 [4], i64 [8])> [0], f32 [16], i1 [20])> [0], i1 [24])>, StorageBuffer>
spv.globalVariable @var4 bind(1,2) : !spv.ptr<!spv.struct<(!spv.struct<(!spv.struct<(i1, i8, i16, i32, i64)>, f32, i1)>, i1)>, StorageBuffer> spv.globalVariable @var4 bind(1,2) : !spv.ptr<!spv.struct<(!spv.struct<(!spv.struct<(i1, i8, i16, i32, i64)>, f32, i1)>, i1)>, StorageBuffer>
// CHECK: spv.globalVariable @var5 bind(1, 3) : !spv.ptr<!spv.struct<(!spv.array<256 x f32, stride=4> [0])>, StorageBuffer> // CHECK: spv.globalVariable @var5 bind(1, 3) : !spv.ptr<!spv.struct<(!spv.array<256 x f32, stride=4> [0])>, StorageBuffer>
spv.globalVariable @var5 bind(1,3) : !spv.ptr<!spv.struct<(!spv.array<256xf32>)>, StorageBuffer> spv.globalVariable @var5 bind(1,3) : !spv.ptr<!spv.struct<(!spv.array<256xf32>)>, StorageBuffer>
spv.func @kernel() -> () "None" { spv.func @kernel() -> () "None" {
%c0 = spv.constant 0 : i32 %c0 = spv.Constant 0 : i32
// CHECK: {{%.*}} = spv.mlir.addressof @var0 : !spv.ptr<!spv.struct<(i32 [0], !spv.struct<(f32 [0], i32 [4])> [4], f32 [12])>, Uniform> // CHECK: {{%.*}} = spv.mlir.addressof @var0 : !spv.ptr<!spv.struct<(i32 [0], !spv.struct<(f32 [0], i32 [4])> [4], f32 [12])>, Uniform>
%0 = spv.mlir.addressof @var0 : !spv.ptr<!spv.struct<(i32, !spv.struct<(f32, i32)>, f32)>, Uniform> %0 = spv.mlir.addressof @var0 : !spv.ptr<!spv.struct<(i32, !spv.struct<(f32, i32)>, f32)>, Uniform>
// CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.struct<(i32 [0], !spv.struct<(f32 [0], i32 [4])> [4], f32 [12])>, Uniform> // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.struct<(i32 [0], !spv.struct<(f32 [0], i32 [4])> [4], f32 [12])>, Uniform>
%1 = spv.AccessChain %0[%c0] : !spv.ptr<!spv.struct<(i32, !spv.struct<(f32, i32)>, f32)>, Uniform>, i32 %1 = spv.AccessChain %0[%c0] : !spv.ptr<!spv.struct<(i32, !spv.struct<(f32, i32)>, f32)>, Uniform>, i32
spv.Return spv.Return
} }
} }
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

mlir/test/Target/SPIRV/constant.mlir

// RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s // RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK-LABEL: @bool_const // CHECK-LABEL: @bool_const
spv.func @bool_const() -> () "None" { spv.func @bool_const() -> () "None" {
// CHECK: spv.constant true // CHECK: spv.Constant true
%0 = spv.constant true %0 = spv.Constant true
// CHECK: spv.constant false // CHECK: spv.Constant false
%1 = spv.constant false %1 = spv.Constant false
%2 = spv.Variable init(%0): !spv.ptr<i1, Function> %2 = spv.Variable init(%0): !spv.ptr<i1, Function>
%3 = spv.Variable init(%1): !spv.ptr<i1, Function> %3 = spv.Variable init(%1): !spv.ptr<i1, Function>
spv.Return spv.Return
} }
// CHECK-LABEL: @i32_const // CHECK-LABEL: @i32_const
spv.func @i32_const() -> () "None" { spv.func @i32_const() -> () "None" {
// CHECK: spv.constant 0 : i32 // CHECK: spv.Constant 0 : i32
%0 = spv.constant 0 : i32 %0 = spv.Constant 0 : i32
// CHECK: spv.constant 10 : i32 // CHECK: spv.Constant 10 : i32
%1 = spv.constant 10 : i32 %1 = spv.Constant 10 : i32
// CHECK: spv.constant -5 : i32 // CHECK: spv.Constant -5 : i32
%2 = spv.constant -5 : i32 %2 = spv.Constant -5 : i32
%3 = spv.IAdd %0, %1 : i32 %3 = spv.IAdd %0, %1 : i32
%4 = spv.IAdd %2, %3 : i32 %4 = spv.IAdd %2, %3 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @si32_const // CHECK-LABEL: @si32_const
spv.func @si32_const() -> () "None" { spv.func @si32_const() -> () "None" {
// CHECK: spv.constant 0 : si32 // CHECK: spv.Constant 0 : si32
%0 = spv.constant 0 : si32 %0 = spv.Constant 0 : si32
// CHECK: spv.constant 10 : si32 // CHECK: spv.Constant 10 : si32
%1 = spv.constant 10 : si32 %1 = spv.Constant 10 : si32
// CHECK: spv.constant -5 : si32 // CHECK: spv.Constant -5 : si32
%2 = spv.constant -5 : si32 %2 = spv.Constant -5 : si32
%3 = spv.IAdd %0, %1 : si32 %3 = spv.IAdd %0, %1 : si32
%4 = spv.IAdd %2, %3 : si32 %4 = spv.IAdd %2, %3 : si32
spv.Return spv.Return
} }
// CHECK-LABEL: @ui32_const // CHECK-LABEL: @ui32_const
// We cannot differentiate signless vs. unsigned integers in SPIR-V blob // We cannot differentiate signless vs. unsigned integers in SPIR-V blob
// because they all use 1 as the signedness bit. So we always treat them // because they all use 1 as the signedness bit. So we always treat them
// as signless integers. // as signless integers.
spv.func @ui32_const() -> () "None" { spv.func @ui32_const() -> () "None" {
// CHECK: spv.constant 0 : i32 // CHECK: spv.Constant 0 : i32
%0 = spv.constant 0 : ui32 %0 = spv.Constant 0 : ui32
// CHECK: spv.constant 10 : i32 // CHECK: spv.Constant 10 : i32
%1 = spv.constant 10 : ui32 %1 = spv.Constant 10 : ui32
// CHECK: spv.constant -5 : i32 // CHECK: spv.Constant -5 : i32
%2 = spv.constant 4294967291 : ui32 %2 = spv.Constant 4294967291 : ui32
%3 = spv.IAdd %0, %1 : ui32 %3 = spv.IAdd %0, %1 : ui32
%4 = spv.IAdd %2, %3 : ui32 %4 = spv.IAdd %2, %3 : ui32
spv.Return spv.Return
} }
// CHECK-LABEL: @i64_const // CHECK-LABEL: @i64_const
spv.func @i64_const() -> () "None" { spv.func @i64_const() -> () "None" {
// CHECK: spv.constant 4294967296 : i64 // CHECK: spv.Constant 4294967296 : i64
%0 = spv.constant 4294967296 : i64 // 2^32 %0 = spv.Constant 4294967296 : i64 // 2^32
// CHECK: spv.constant -4294967296 : i64 // CHECK: spv.Constant -4294967296 : i64
%1 = spv.constant -4294967296 : i64 // -2^32 %1 = spv.Constant -4294967296 : i64 // -2^32
// CHECK: spv.constant 9223372036854775807 : i64 // CHECK: spv.Constant 9223372036854775807 : i64
%2 = spv.constant 9223372036854775807 : i64 // 2^63 - 1 %2 = spv.Constant 9223372036854775807 : i64 // 2^63 - 1
// CHECK: spv.constant -9223372036854775808 : i64 // CHECK: spv.Constant -9223372036854775808 : i64
%3 = spv.constant -9223372036854775808 : i64 // -2^63 %3 = spv.Constant -9223372036854775808 : i64 // -2^63
%4 = spv.IAdd %0, %1 : i64 %4 = spv.IAdd %0, %1 : i64
%5 = spv.IAdd %2, %3 : i64 %5 = spv.IAdd %2, %3 : i64
spv.Return spv.Return
} }
// CHECK-LABEL: @i16_const // CHECK-LABEL: @i16_const
spv.func @i16_const() -> () "None" { spv.func @i16_const() -> () "None" {
// CHECK: spv.constant -32768 : i16 // CHECK: spv.Constant -32768 : i16
%0 = spv.constant -32768 : i16 // -2^15 %0 = spv.Constant -32768 : i16 // -2^15
// CHECK: spv.constant 32767 : i16 // CHECK: spv.Constant 32767 : i16
%1 = spv.constant 32767 : i16 // 2^15 - 1 %1 = spv.Constant 32767 : i16 // 2^15 - 1
%2 = spv.IAdd %0, %1 : i16 %2 = spv.IAdd %0, %1 : i16
spv.Return spv.Return
} }
// CHECK-LABEL: @float_const // CHECK-LABEL: @float_const
spv.func @float_const() -> () "None" { spv.func @float_const() -> () "None" {
// CHECK: spv.constant 0.000000e+00 : f32 // CHECK: spv.Constant 0.000000e+00 : f32
%0 = spv.constant 0. : f32 %0 = spv.Constant 0. : f32
// CHECK: spv.constant 1.000000e+00 : f32 // CHECK: spv.Constant 1.000000e+00 : f32
%1 = spv.constant 1. : f32 %1 = spv.Constant 1. : f32
// CHECK: spv.constant -0.000000e+00 : f32 // CHECK: spv.Constant -0.000000e+00 : f32
%2 = spv.constant -0. : f32 %2 = spv.Constant -0. : f32
// CHECK: spv.constant -1.000000e+00 : f32 // CHECK: spv.Constant -1.000000e+00 : f32
%3 = spv.constant -1. : f32 %3 = spv.Constant -1. : f32
// CHECK: spv.constant 7.500000e-01 : f32 // CHECK: spv.Constant 7.500000e-01 : f32
%4 = spv.constant 0.75 : f32 %4 = spv.Constant 0.75 : f32
// CHECK: spv.constant -2.500000e-01 : f32 // CHECK: spv.Constant -2.500000e-01 : f32
%5 = spv.constant -0.25 : f32 %5 = spv.Constant -0.25 : f32
%6 = spv.FAdd %0, %1 : f32 %6 = spv.FAdd %0, %1 : f32
%7 = spv.FAdd %2, %3 : f32 %7 = spv.FAdd %2, %3 : f32
%8 = spv.FAdd %4, %5 : f32 %8 = spv.FAdd %4, %5 : f32
spv.Return spv.Return
} }
// CHECK-LABEL: @double_const // CHECK-LABEL: @double_const
spv.func @double_const() -> () "None" { spv.func @double_const() -> () "None" {
// TODO: test range boundary values // TODO: test range boundary values
// CHECK: spv.constant 1.024000e+03 : f64 // CHECK: spv.Constant 1.024000e+03 : f64
%0 = spv.constant 1024. : f64 %0 = spv.Constant 1024. : f64
// CHECK: spv.constant -1.024000e+03 : f64 // CHECK: spv.Constant -1.024000e+03 : f64
%1 = spv.constant -1024. : f64 %1 = spv.Constant -1024. : f64
%2 = spv.FAdd %0, %1 : f64 %2 = spv.FAdd %0, %1 : f64
spv.Return spv.Return
} }
// CHECK-LABEL: @half_const // CHECK-LABEL: @half_const
spv.func @half_const() -> () "None" { spv.func @half_const() -> () "None" {
// CHECK: spv.constant 5.120000e+02 : f16 // CHECK: spv.Constant 5.120000e+02 : f16
%0 = spv.constant 512. : f16 %0 = spv.Constant 512. : f16
// CHECK: spv.constant -5.120000e+02 : f16 // CHECK: spv.Constant -5.120000e+02 : f16
%1 = spv.constant -512. : f16 %1 = spv.Constant -512. : f16
%2 = spv.FAdd %0, %1 : f16 %2 = spv.FAdd %0, %1 : f16
spv.Return spv.Return
} }
// CHECK-LABEL: @bool_vector_const // CHECK-LABEL: @bool_vector_const
spv.func @bool_vector_const() -> () "None" { spv.func @bool_vector_const() -> () "None" {
// CHECK: spv.constant dense<false> : vector<2xi1> // CHECK: spv.Constant dense<false> : vector<2xi1>
%0 = spv.constant dense<false> : vector<2xi1> %0 = spv.Constant dense<false> : vector<2xi1>
// CHECK: spv.constant dense<[true, true, true]> : vector<3xi1> // CHECK: spv.Constant dense<[true, true, true]> : vector<3xi1>
%1 = spv.constant dense<true> : vector<3xi1> %1 = spv.Constant dense<true> : vector<3xi1>
// CHECK: spv.constant dense<[false, true]> : vector<2xi1> // CHECK: spv.Constant dense<[false, true]> : vector<2xi1>
%2 = spv.constant dense<[false, true]> : vector<2xi1> %2 = spv.Constant dense<[false, true]> : vector<2xi1>
%3 = spv.Variable init(%0): !spv.ptr<vector<2xi1>, Function> %3 = spv.Variable init(%0): !spv.ptr<vector<2xi1>, Function>
%4 = spv.Variable init(%1): !spv.ptr<vector<3xi1>, Function> %4 = spv.Variable init(%1): !spv.ptr<vector<3xi1>, Function>
%5 = spv.Variable init(%2): !spv.ptr<vector<2xi1>, Function> %5 = spv.Variable init(%2): !spv.ptr<vector<2xi1>, Function>
spv.Return spv.Return
} }
// CHECK-LABEL: @int_vector_const // CHECK-LABEL: @int_vector_const
spv.func @int_vector_const() -> () "None" { spv.func @int_vector_const() -> () "None" {
// CHECK: spv.constant dense<0> : vector<3xi32> // CHECK: spv.Constant dense<0> : vector<3xi32>
%0 = spv.constant dense<0> : vector<3xi32> %0 = spv.Constant dense<0> : vector<3xi32>
// CHECK: spv.constant dense<1> : vector<3xi32> // CHECK: spv.Constant dense<1> : vector<3xi32>
%1 = spv.constant dense<1> : vector<3xi32> %1 = spv.Constant dense<1> : vector<3xi32>
// CHECK: spv.constant dense<[2, -3, 4]> : vector<3xi32> // CHECK: spv.Constant dense<[2, -3, 4]> : vector<3xi32>
%2 = spv.constant dense<[2, -3, 4]> : vector<3xi32> %2 = spv.Constant dense<[2, -3, 4]> : vector<3xi32>
%3 = spv.IAdd %0, %1 : vector<3xi32> %3 = spv.IAdd %0, %1 : vector<3xi32>
%4 = spv.IAdd %2, %3 : vector<3xi32> %4 = spv.IAdd %2, %3 : vector<3xi32>
spv.Return spv.Return
} }
// CHECK-LABEL: @fp_vector_const // CHECK-LABEL: @fp_vector_const
spv.func @fp_vector_const() -> () "None" { spv.func @fp_vector_const() -> () "None" {
// CHECK: spv.constant dense<0.000000e+00> : vector<4xf32> // CHECK: spv.Constant dense<0.000000e+00> : vector<4xf32>
%0 = spv.constant dense<0.> : vector<4xf32> %0 = spv.Constant dense<0.> : vector<4xf32>
// CHECK: spv.constant dense<-1.500000e+01> : vector<4xf32> // CHECK: spv.Constant dense<-1.500000e+01> : vector<4xf32>
%1 = spv.constant dense<-15.> : vector<4xf32> %1 = spv.Constant dense<-15.> : vector<4xf32>
// CHECK: spv.constant dense<[7.500000e-01, -2.500000e-01, 1.000000e+01, 4.200000e+01]> : vector<4xf32> // CHECK: spv.Constant dense<[7.500000e-01, -2.500000e-01, 1.000000e+01, 4.200000e+01]> : vector<4xf32>
%2 = spv.constant dense<[0.75, -0.25, 10., 42.]> : vector<4xf32> %2 = spv.Constant dense<[0.75, -0.25, 10., 42.]> : vector<4xf32>
%3 = spv.FAdd %0, %1 : vector<4xf32> %3 = spv.FAdd %0, %1 : vector<4xf32>
%4 = spv.FAdd %2, %3 : vector<4xf32> %4 = spv.FAdd %2, %3 : vector<4xf32>
spv.Return spv.Return
} }
// CHECK-LABEL: @ui64_array_const // CHECK-LABEL: @ui64_array_const
spv.func @ui64_array_const() -> (!spv.array<3xui64>) "None" { spv.func @ui64_array_const() -> (!spv.array<3xui64>) "None" {
// CHECK: spv.constant [5, 6, 7] : !spv.array<3 x i64> // CHECK: spv.Constant [5, 6, 7] : !spv.array<3 x i64>
%0 = spv.constant [5 : ui64, 6 : ui64, 7 : ui64] : !spv.array<3 x ui64> %0 = spv.Constant [5 : ui64, 6 : ui64, 7 : ui64] : !spv.array<3 x ui64>
spv.ReturnValue %0: !spv.array<3xui64> spv.ReturnValue %0: !spv.array<3xui64>
} }
// CHECK-LABEL: @si32_array_const // CHECK-LABEL: @si32_array_const
spv.func @si32_array_const() -> (!spv.array<3xsi32>) "None" { spv.func @si32_array_const() -> (!spv.array<3xsi32>) "None" {
// CHECK: spv.constant [5 : si32, 6 : si32, 7 : si32] : !spv.array<3 x si32> // CHECK: spv.Constant [5 : si32, 6 : si32, 7 : si32] : !spv.array<3 x si32>
%0 = spv.constant [5 : si32, 6 : si32, 7 : si32] : !spv.array<3 x si32> %0 = spv.Constant [5 : si32, 6 : si32, 7 : si32] : !spv.array<3 x si32>
spv.ReturnValue %0 : !spv.array<3xsi32> spv.ReturnValue %0 : !spv.array<3xsi32>
} }
// CHECK-LABEL: @float_array_const // CHECK-LABEL: @float_array_const
spv.func @float_array_const() -> (!spv.array<2 x vector<2xf32>>) "None" { spv.func @float_array_const() -> (!spv.array<2 x vector<2xf32>>) "None" {
// CHECK: spv.constant [dense<3.000000e+00> : vector<2xf32>, dense<[4.000000e+00, 5.000000e+00]> : vector<2xf32>] : !spv.array<2 x vector<2xf32>> // CHECK: spv.Constant [dense<3.000000e+00> : vector<2xf32>, dense<[4.000000e+00, 5.000000e+00]> : vector<2xf32>] : !spv.array<2 x vector<2xf32>>
%0 = spv.constant [dense<3.0> : vector<2xf32>, dense<[4., 5.]> : vector<2xf32>] : !spv.array<2 x vector<2xf32>> %0 = spv.Constant [dense<3.0> : vector<2xf32>, dense<[4., 5.]> : vector<2xf32>] : !spv.array<2 x vector<2xf32>>
spv.ReturnValue %0 : !spv.array<2 x vector<2xf32>> spv.ReturnValue %0 : !spv.array<2 x vector<2xf32>>
} }
// CHECK-LABEL: @ignore_not_used_const // CHECK-LABEL: @ignore_not_used_const
spv.func @ignore_not_used_const() -> () "None" { spv.func @ignore_not_used_const() -> () "None" {
%0 = spv.constant false %0 = spv.Constant false
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
spv.Return spv.Return
} }
// CHECK-LABEL: @materialize_const_at_each_use // CHECK-LABEL: @materialize_const_at_each_use
spv.func @materialize_const_at_each_use() -> (i32) "None" { spv.func @materialize_const_at_each_use() -> (i32) "None" {
// CHECK: %[[USE1:.*]] = spv.constant 42 : i32 // CHECK: %[[USE1:.*]] = spv.Constant 42 : i32
// CHECK: %[[USE2:.*]] = spv.constant 42 : i32 // CHECK: %[[USE2:.*]] = spv.Constant 42 : i32
// CHECK: spv.IAdd %[[USE1]], %[[USE2]] // CHECK: spv.IAdd %[[USE1]], %[[USE2]]
%0 = spv.constant 42 : i32 %0 = spv.Constant 42 : i32
%1 = spv.IAdd %0, %0 : i32 %1 = spv.IAdd %0, %0 : i32
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
// CHECK-LABEL: @const_variable // CHECK-LABEL: @const_variable
spv.func @const_variable(%arg0 : i32, %arg1 : i32) -> () "None" { spv.func @const_variable(%arg0 : i32, %arg1 : i32) -> () "None" {
// CHECK: %[[CONST:.*]] = spv.constant 5 : i32 // CHECK: %[[CONST:.*]] = spv.Constant 5 : i32
// CHECK: spv.Variable init(%[[CONST]]) : !spv.ptr<i32, Function> // CHECK: spv.Variable init(%[[CONST]]) : !spv.ptr<i32, Function>
// CHECK: spv.IAdd %arg0, %arg1 // CHECK: spv.IAdd %arg0, %arg1
%0 = spv.IAdd %arg0, %arg1 : i32 %0 = spv.IAdd %arg0, %arg1 : i32
%1 = spv.constant 5 : i32 %1 = spv.Constant 5 : i32
%2 = spv.Variable init(%1) : !spv.ptr<i32, Function> %2 = spv.Variable init(%1) : !spv.ptr<i32, Function>
%3 = spv.Load "Function" %2 : i32 %3 = spv.Load "Function" %2 : i32
%4 = spv.IAdd %0, %3 : i32 %4 = spv.IAdd %0, %3 : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @multi_dimensions_const // CHECK-LABEL: @multi_dimensions_const
spv.func @multi_dimensions_const() -> (!spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>) "None" { spv.func @multi_dimensions_const() -> (!spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>) "None" {
// CHECK: spv.constant {{\[}}{{\[}}[1 : i32, 2 : i32, 3 : i32], [4 : i32, 5 : i32, 6 : i32]], {{\[}}[7 : i32, 8 : i32, 9 : i32], [10 : i32, 11 : i32, 12 : i32]]] : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24> // CHECK: spv.Constant {{\[}}{{\[}}[1 : i32, 2 : i32, 3 : i32], [4 : i32, 5 : i32, 6 : i32]], {{\[}}[7 : i32, 8 : i32, 9 : i32], [10 : i32, 11 : i32, 12 : i32]]] : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>
%0 = spv.constant dense<[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]> : tensor<2x2x3xi32> : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24> %0 = spv.Constant dense<[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]> : tensor<2x2x3xi32> : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>
spv.ReturnValue %0 : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24> spv.ReturnValue %0 : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>
} }
// CHECK-LABEL: @multi_dimensions_splat_const // CHECK-LABEL: @multi_dimensions_splat_const
spv.func @multi_dimensions_splat_const() -> (!spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>) "None" { spv.func @multi_dimensions_splat_const() -> (!spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>) "None" {
// CHECK: spv.constant {{\[}}{{\[}}[1 : i32, 1 : i32, 1 : i32], [1 : i32, 1 : i32, 1 : i32]], {{\[}}[1 : i32, 1 : i32, 1 : i32], [1 : i32, 1 : i32, 1 : i32]]] : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24> // CHECK: spv.Constant {{\[}}{{\[}}[1 : i32, 1 : i32, 1 : i32], [1 : i32, 1 : i32, 1 : i32]], {{\[}}[1 : i32, 1 : i32, 1 : i32], [1 : i32, 1 : i32, 1 : i32]]] : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>
%0 = spv.constant dense<1> : tensor<2x2x3xi32> : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24> %0 = spv.Constant dense<1> : tensor<2x2x3xi32> : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>
spv.ReturnValue %0 : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24> spv.ReturnValue %0 : !spv.array<2 x !spv.array<2 x !spv.array<3 x i32, stride=4>, stride=12>, stride=24>
} }
} }

mlir/test/Target/SPIRV/cooperative-matrix-ops.mlir

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Linesspv.module Logical GLSL450 requires #spv.vce<v1.0, [CooperativeMatrixNV], [SPV_NV_cooperative_matrix]> {
spv.func @cooperative_matrix_fdiv(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" { spv.func @cooperative_matrix_fdiv(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.FDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: {{%.*}} = spv.FDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup>
%r = spv.FDiv %a, %b : !spv.coopmatrix<8x16xf32, Subgroup> %r = spv.FDiv %a, %b : !spv.coopmatrix<8x16xf32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_access_chain // CHECK-LABEL: @cooperative_matrix_access_chain
spv.func @cooperative_matrix_access_chain(%a : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>) -> !spv.ptr<f32, Function> "None" { spv.func @cooperative_matrix_access_chain(%a : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>) -> !spv.ptr<f32, Function> "None" {
%0 = spv.constant 0: i32 %0 = spv.Constant 0: i32
// CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32 // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32
%1 = spv.AccessChain %a[%0] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32 %1 = spv.AccessChain %a[%0] : !spv.ptr<!spv.coopmatrix<8x16xf32, Subgroup>, Function>, i32
spv.ReturnValue %1 : !spv.ptr<f32, Function> spv.ReturnValue %1 : !spv.ptr<f32, Function>
} }
} }

mlir/test/Target/SPIRV/debug.mlir

Show All 38 Linesspv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @group_non_uniform(%val: f32) "None" { spv.func @group_non_uniform(%val: f32) "None" {
// CHECK: loc({{".*debug.mlir"}}:42:10) // CHECK: loc({{".*debug.mlir"}}:42:10)
%0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFAdd "Workgroup" "Reduce" %val : f32
spv.Return spv.Return
} }
spv.func @local_var() "None" { spv.func @local_var() "None" {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
// CHECK: loc({{".*debug.mlir"}}:49:12) // CHECK: loc({{".*debug.mlir"}}:49:12)
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.Return spv.Return
} }
spv.func @logical(%arg0: i32, %arg1: i32) "None" { spv.func @logical(%arg0: i32, %arg1: i32) "None" {
// CHECK: loc({{".*debug.mlir"}}:55:10) // CHECK: loc({{".*debug.mlir"}}:55:10)
%0 = spv.IEqual %arg0, %arg1 : i32 %0 = spv.IEqual %arg0, %arg1 : i32
spv.Return spv.Return
} }
spv.func @memory_accesses(%arg0 : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, StorageBuffer>, %arg1 : i32, %arg2 : i32) "None" { spv.func @memory_accesses(%arg0 : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, StorageBuffer>, %arg1 : i32, %arg2 : i32) "None" {
// CHECK: loc({{".*debug.mlir"}}:61:10) // CHECK: loc({{".*debug.mlir"}}:61:10)
%2 = spv.AccessChain %arg0[%arg1, %arg2] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, StorageBuffer>, i32, i32 %2 = spv.AccessChain %arg0[%arg1, %arg2] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, StorageBuffer>, i32, i32
// CHECK: loc({{".*debug.mlir"}}:63:10) // CHECK: loc({{".*debug.mlir"}}:63:10)
%3 = spv.Load "StorageBuffer" %2 : f32 %3 = spv.Load "StorageBuffer" %2 : f32
// CHECK: loc({{.*debug.mlir"}}:65:5) // CHECK: loc({{.*debug.mlir"}}:65:5)
spv.Store "StorageBuffer" %2, %3 : f32 spv.Store "StorageBuffer" %2, %3 : f32
// CHECK: loc({{".*debug.mlir"}}:67:5) // CHECK: loc({{".*debug.mlir"}}:67:5)
spv.Return spv.Return
} }
spv.func @loop(%count : i32) -> () "None" { spv.func @loop(%count : i32) -> () "None" {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%ivar = spv.Variable init(%zero) : !spv.ptr<i32, Function> %ivar = spv.Variable init(%zero) : !spv.ptr<i32, Function>
%jvar = spv.Variable init(%zero) : !spv.ptr<i32, Function> %jvar = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.loop { spv.loop {
// CHECK: loc({{".*debug.mlir"}}:75:5) // CHECK: loc({{".*debug.mlir"}}:75:5)
spv.Branch ^header spv.Branch ^header
^header: ^header:
%ival0 = spv.Load "Function" %ivar : i32 %ival0 = spv.Load "Function" %ivar : i32
%icmp = spv.SLessThan %ival0, %count : i32 %icmp = spv.SLessThan %ival0, %count : i32
Show All 35 Lines ^merge:
// CHECK: loc({{".*debug.mlir"}}:75:5) // CHECK: loc({{".*debug.mlir"}}:75:5)
spv.mlir.merge spv.mlir.merge
// CHECK: loc({{".*debug.mlir"}}:75:5) // CHECK: loc({{".*debug.mlir"}}:75:5)
} }
spv.Return spv.Return
} }
spv.func @selection(%cond: i1) -> () "None" { spv.func @selection(%cond: i1) -> () "None" {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%two = spv.constant 2: i32 %two = spv.Constant 2: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.selection { spv.selection {
// CHECK: loc({{".*debug.mlir"}}:128:5) // CHECK: loc({{".*debug.mlir"}}:128:5)
spv.BranchConditional %cond [5, 10], ^then, ^else spv.BranchConditional %cond [5, 10], ^then, ^else
^then: ^then:
spv.Store "Function" %var, %one : i32 spv.Store "Function" %var, %one : i32
// CHECK: loc({{".*debug.mlir"}}:134:7) // CHECK: loc({{".*debug.mlir"}}:134:7)
spv.Branch ^merge spv.Branch ^merge
Show All 12 Lines

mlir/test/Target/SPIRV/function-call.mlir

// RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s // RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.globalVariable @var1 : !spv.ptr<!spv.array<4xf32>, Input> spv.globalVariable @var1 : !spv.ptr<!spv.array<4xf32>, Input>
spv.func @fmain() -> i32 "None" { spv.func @fmain() -> i32 "None" {
%0 = spv.constant 16 : i32 %0 = spv.Constant 16 : i32
%1 = spv.mlir.addressof @var1 : !spv.ptr<!spv.array<4xf32>, Input> %1 = spv.mlir.addressof @var1 : !spv.ptr<!spv.array<4xf32>, Input>
// CHECK: {{%.*}} = spv.FunctionCall @f_0({{%.*}}) : (i32) -> i32 // CHECK: {{%.*}} = spv.FunctionCall @f_0({{%.*}}) : (i32) -> i32
%3 = spv.FunctionCall @f_0(%0) : (i32) -> i32 %3 = spv.FunctionCall @f_0(%0) : (i32) -> i32
// CHECK: spv.FunctionCall @f_1({{%.*}}, {{%.*}}) : (i32, !spv.ptr<!spv.array<4 x f32>, Input>) -> () // CHECK: spv.FunctionCall @f_1({{%.*}}, {{%.*}}) : (i32, !spv.ptr<!spv.array<4 x f32>, Input>) -> ()
spv.FunctionCall @f_1(%3, %1) : (i32, !spv.ptr<!spv.array<4xf32>, Input>) -> () spv.FunctionCall @f_1(%3, %1) : (i32, !spv.ptr<!spv.array<4xf32>, Input>) -> ()
// CHECK: {{%.*}} = spv.FunctionCall @f_2({{%.*}}) : (!spv.ptr<!spv.array<4 x f32>, Input>) -> !spv.ptr<!spv.array<4 x f32>, Input> // CHECK: {{%.*}} = spv.FunctionCall @f_2({{%.*}}) : (!spv.ptr<!spv.array<4 x f32>, Input>) -> !spv.ptr<!spv.array<4 x f32>, Input>
%4 = spv.FunctionCall @f_2(%1) : (!spv.ptr<!spv.array<4xf32>, Input>) -> !spv.ptr<!spv.array<4xf32>, Input> %4 = spv.FunctionCall @f_2(%1) : (!spv.ptr<!spv.array<4xf32>, Input>) -> !spv.ptr<!spv.array<4xf32>, Input>
spv.ReturnValue %3 : i32 spv.ReturnValue %3 : i32
} }
spv.func @f_0(%arg0 : i32) -> i32 "None" { spv.func @f_0(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
spv.func @f_1(%arg0 : i32, %arg1 : !spv.ptr<!spv.array<4xf32>, Input>) -> () "None" { spv.func @f_1(%arg0 : i32, %arg1 : !spv.ptr<!spv.array<4xf32>, Input>) -> () "None" {
spv.Return spv.Return
} }
spv.func @f_2(%arg0 : !spv.ptr<!spv.array<4xf32>, Input>) -> !spv.ptr<!spv.array<4xf32>, Input> "None" { spv.func @f_2(%arg0 : !spv.ptr<!spv.array<4xf32>, Input>) -> !spv.ptr<!spv.array<4xf32>, Input> "None" {
spv.ReturnValue %arg0 : !spv.ptr<!spv.array<4xf32>, Input> spv.ReturnValue %arg0 : !spv.ptr<!spv.array<4xf32>, Input>
} }
spv.func @f_loop_with_function_call(%count : i32) -> () "None" { spv.func @f_loop_with_function_call(%count : i32) -> () "None" {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
spv.loop { spv.loop {
spv.Branch ^header spv.Branch ^header
^header: ^header:
%val0 = spv.Load "Function" %var : i32 %val0 = spv.Load "Function" %var : i32
%cmp = spv.SLessThan %val0, %count : i32 %cmp = spv.SLessThan %val0, %count : i32
spv.BranchConditional %cmp, ^body, ^merge spv.BranchConditional %cmp, ^body, ^merge
^body: ^body:
spv.Branch ^continue spv.Branch ^continue
^continue: ^continue:
// CHECK: spv.FunctionCall @f_inc({{%.*}}) : (!spv.ptr<i32, Function>) -> () // CHECK: spv.FunctionCall @f_inc({{%.*}}) : (!spv.ptr<i32, Function>) -> ()
spv.FunctionCall @f_inc(%var) : (!spv.ptr<i32, Function>) -> () spv.FunctionCall @f_inc(%var) : (!spv.ptr<i32, Function>) -> ()
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
spv.func @f_inc(%arg0 : !spv.ptr<i32, Function>) -> () "None" { spv.func @f_inc(%arg0 : !spv.ptr<i32, Function>) -> () "None" {
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
%0 = spv.Load "Function" %arg0 : i32 %0 = spv.Load "Function" %arg0 : i32
%1 = spv.IAdd %0, %one : i32 %1 = spv.IAdd %0, %one : i32
spv.Store "Function" %arg0, %1 : i32 spv.Store "Function" %arg0, %1 : i32
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/global-variable.mlir

Show All 22 Lines
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.globalVariable @globalInvocationID built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @globalInvocationID built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
spv.func @foo() "None" { spv.func @foo() "None" {
// CHECK: %[[ADDR:.*]] = spv.mlir.addressof @globalInvocationID : !spv.ptr<vector<3xi32>, Input> // CHECK: %[[ADDR:.*]] = spv.mlir.addressof @globalInvocationID : !spv.ptr<vector<3xi32>, Input>
%0 = spv.mlir.addressof @globalInvocationID : !spv.ptr<vector<3xi32>, Input> %0 = spv.mlir.addressof @globalInvocationID : !spv.ptr<vector<3xi32>, Input>
%1 = spv.constant 0: i32 %1 = spv.Constant 0: i32
// CHECK: spv.AccessChain %[[ADDR]] // CHECK: spv.AccessChain %[[ADDR]]
%2 = spv.AccessChain %0[%1] : !spv.ptr<vector<3xi32>, Input>, i32 %2 = spv.AccessChain %0[%1] : !spv.ptr<vector<3xi32>, Input>, i32
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/logical-ops.mlir

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Linesspv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.specConstant @condition_scalar = true spv.specConstant @condition_scalar = true
spv.func @select() -> () "None" { spv.func @select() -> () "None" {
%0 = spv.constant 4.0 : f32 %0 = spv.Constant 4.0 : f32
%1 = spv.constant 5.0 : f32 %1 = spv.Constant 5.0 : f32
%2 = spv.mlir.referenceof @condition_scalar : i1 %2 = spv.mlir.referenceof @condition_scalar : i1
// CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : i1, f32 // CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : i1, f32
%3 = spv.Select %2, %0, %1 : i1, f32 %3 = spv.Select %2, %0, %1 : i1, f32
%4 = spv.constant dense<[2.0, 3.0, 4.0, 5.0]> : vector<4xf32> %4 = spv.Constant dense<[2.0, 3.0, 4.0, 5.0]> : vector<4xf32>
%5 = spv.constant dense<[6.0, 7.0, 8.0, 9.0]> : vector<4xf32> %5 = spv.Constant dense<[6.0, 7.0, 8.0, 9.0]> : vector<4xf32>
// CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : i1, vector<4xf32> // CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : i1, vector<4xf32>
%6 = spv.Select %2, %4, %5 : i1, vector<4xf32> %6 = spv.Select %2, %4, %5 : i1, vector<4xf32>
%7 = spv.constant dense<[true, true, true, true]> : vector<4xi1> %7 = spv.Constant dense<[true, true, true, true]> : vector<4xi1>
// CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : vector<4xi1>, vector<4xf32> // CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : vector<4xi1>, vector<4xf32>
%8 = spv.Select %7, %4, %5 : vector<4xi1>, vector<4xf32> %8 = spv.Select %7, %4, %5 : vector<4xi1>, vector<4xf32>
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/loop.mlir

// RUN: mlir-translate -split-input-file -test-spirv-roundtrip %s | FileCheck %s // RUN: mlir-translate -split-input-file -test-spirv-roundtrip %s | FileCheck %s
// Single loop // Single loop
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// for (int i = 0; i < count; ++i) {} // for (int i = 0; i < count; ++i) {}
spv.func @loop(%count : i32) -> () "None" { spv.func @loop(%count : i32) -> () "None" {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: spv.loop // CHECK-NEXT: spv.loop
spv.loop { spv.loop {
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
Show All 12 Lines ^body:
// Do nothing // Do nothing
// CHECK-NEXT: spv.Branch ^bb3 // CHECK-NEXT: spv.Branch ^bb3
spv.Branch ^continue spv.Branch ^continue
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
^continue: ^continue:
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
%val1 = spv.Load "Function" %var : i32 %val1 = spv.Load "Function" %var : i32
// CHECK-NEXT: spv.constant 1 // CHECK-NEXT: spv.Constant 1
// CHECK-NEXT: spv.IAdd // CHECK-NEXT: spv.IAdd
%add = spv.IAdd %val1, %one : i32 %add = spv.IAdd %val1, %one : i32
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
spv.Store "Function" %var, %add : i32 spv.Store "Function" %var, %add : i32
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
// CHECK-NEXT: ^bb4: // CHECK-NEXT: ^bb4:
Show All 12 Lines
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.globalVariable @GV1 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer> spv.globalVariable @GV1 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
spv.globalVariable @GV2 bind(0, 1) : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer> spv.globalVariable @GV2 bind(0, 1) : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
spv.func @loop_kernel() "None" { spv.func @loop_kernel() "None" {
%0 = spv.mlir.addressof @GV1 : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer> %0 = spv.mlir.addressof @GV1 : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
%1 = spv.constant 0 : i32 %1 = spv.Constant 0 : i32
%2 = spv.AccessChain %0[%1] : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>, i32 %2 = spv.AccessChain %0[%1] : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>, i32
%3 = spv.mlir.addressof @GV2 : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer> %3 = spv.mlir.addressof @GV2 : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>
%5 = spv.AccessChain %3[%1] : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>, i32 %5 = spv.AccessChain %3[%1] : !spv.ptr<!spv.struct<(!spv.array<10 x f32, stride=4> [0])>, StorageBuffer>, i32
%6 = spv.constant 4 : i32 %6 = spv.Constant 4 : i32
%7 = spv.constant 42 : i32 %7 = spv.Constant 42 : i32
%8 = spv.constant 2 : i32 %8 = spv.Constant 2 : i32
// CHECK: spv.Branch ^bb1(%{{.*}} : i32) // CHECK: spv.Branch ^bb1(%{{.*}} : i32)
// CHECK-NEXT: ^bb1(%[[OUTARG:.*]]: i32): // CHECK-NEXT: ^bb1(%[[OUTARG:.*]]: i32):
// CHECK-NEXT: spv.loop { // CHECK-NEXT: spv.loop {
spv.loop { spv.loop {
// CHECK-NEXT: spv.Branch ^bb1(%[[OUTARG]] : i32) // CHECK-NEXT: spv.Branch ^bb1(%[[OUTARG]] : i32)
spv.Branch ^header(%6 : i32) spv.Branch ^header(%6 : i32)
// CHECK-NEXT: ^bb1(%[[HEADARG:.*]]: i32): // CHECK-NEXT: ^bb1(%[[HEADARG:.*]]: i32):
^header(%9: i32): ^header(%9: i32):
Show All 25 Lines
// Nested loop // Nested loop
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// for (int i = 0; i < count; ++i) { // for (int i = 0; i < count; ++i) {
// for (int j = 0; j < count; ++j) { } // for (int j = 0; j < count; ++j) { }
// } // }
spv.func @loop(%count : i32) -> () "None" { spv.func @loop(%count : i32) -> () "None" {
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%ivar = spv.Variable init(%zero) : !spv.ptr<i32, Function> %ivar = spv.Variable init(%zero) : !spv.ptr<i32, Function>
%jvar = spv.Variable init(%zero) : !spv.ptr<i32, Function> %jvar = spv.Variable init(%zero) : !spv.ptr<i32, Function>
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: spv.loop control(Unroll) // CHECK-NEXT: spv.loop control(Unroll)
spv.loop control(Unroll) { spv.loop control(Unroll) {
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
^header: ^header:
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
%ival0 = spv.Load "Function" %ivar : i32 %ival0 = spv.Load "Function" %ivar : i32
// CHECK-NEXT: spv.SLessThan // CHECK-NEXT: spv.SLessThan
%icmp = spv.SLessThan %ival0, %count : i32 %icmp = spv.SLessThan %ival0, %count : i32
// CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb2, ^bb5 // CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb2, ^bb5
spv.BranchConditional %icmp, ^body, ^merge spv.BranchConditional %icmp, ^body, ^merge
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^body: ^body:
// CHECK-NEXT: spv.constant 0 // CHECK-NEXT: spv.Constant 0
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
spv.Store "Function" %jvar, %zero : i32 spv.Store "Function" %jvar, %zero : i32
// CHECK-NEXT: spv.Branch ^bb3 // CHECK-NEXT: spv.Branch ^bb3
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
// CHECK-NEXT: spv.loop control(DontUnroll) // CHECK-NEXT: spv.loop control(DontUnroll)
spv.loop control(DontUnroll) { spv.loop control(DontUnroll) {
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
Show All 12 Lines// CHECK-NEXT: ^bb2:
// Do nothing // Do nothing
// CHECK-NEXT: spv.Branch ^bb3 // CHECK-NEXT: spv.Branch ^bb3
spv.Branch ^continue spv.Branch ^continue
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
^continue: ^continue:
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
%jval1 = spv.Load "Function" %jvar : i32 %jval1 = spv.Load "Function" %jvar : i32
// CHECK-NEXT: spv.constant 1 // CHECK-NEXT: spv.Constant 1
// CHECK-NEXT: spv.IAdd // CHECK-NEXT: spv.IAdd
%add = spv.IAdd %jval1, %one : i32 %add = spv.IAdd %jval1, %one : i32
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
spv.Store "Function" %jvar, %add : i32 spv.Store "Function" %jvar, %add : i32
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
// CHECK-NEXT: ^bb4: // CHECK-NEXT: ^bb4:
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} // end inner loop } // end inner loop
// CHECK: spv.Branch ^bb4 // CHECK: spv.Branch ^bb4
spv.Branch ^continue spv.Branch ^continue
// CHECK-NEXT: ^bb4: // CHECK-NEXT: ^bb4:
^continue: ^continue:
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
%ival1 = spv.Load "Function" %ivar : i32 %ival1 = spv.Load "Function" %ivar : i32
// CHECK-NEXT: spv.constant 1 // CHECK-NEXT: spv.Constant 1
// CHECK-NEXT: spv.IAdd // CHECK-NEXT: spv.IAdd
%add = spv.IAdd %ival1, %one : i32 %add = spv.IAdd %ival1, %one : i32
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
spv.Store "Function" %ivar, %add : i32 spv.Store "Function" %ivar, %add : i32
// CHECK-NEXT: spv.Branch ^bb1 // CHECK-NEXT: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
// CHECK-NEXT: ^bb5: // CHECK-NEXT: ^bb5:
Show All 13 Lines

mlir/test/Target/SPIRV/memory-ops.mlir

Show All 24 Lines
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @load_store_zero_rank_float(%arg0: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, %arg1: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>) "None" { spv.func @load_store_zero_rank_float(%arg0: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, %arg1: !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>) "None" {
// CHECK: [[LOAD_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])> // CHECK: [[LOAD_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>
// CHECK-NEXT: [[VAL:%.*]] = spv.Load "StorageBuffer" [[LOAD_PTR]] : f32 // CHECK-NEXT: [[VAL:%.*]] = spv.Load "StorageBuffer" [[LOAD_PTR]] : f32
%0 = spv.constant 0 : i32 %0 = spv.Constant 0 : i32
%1 = spv.AccessChain %arg0[%0, %0] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, i32, i32 %1 = spv.AccessChain %arg0[%0, %0] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, i32, i32
%2 = spv.Load "StorageBuffer" %1 : f32 %2 = spv.Load "StorageBuffer" %1 : f32
// CHECK: [[STORE_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])> // CHECK: [[STORE_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>
// CHECK-NEXT: spv.Store "StorageBuffer" [[STORE_PTR]], [[VAL]] : f32 // CHECK-NEXT: spv.Store "StorageBuffer" [[STORE_PTR]], [[VAL]] : f32
%3 = spv.constant 0 : i32 %3 = spv.Constant 0 : i32
%4 = spv.AccessChain %arg1[%3, %3] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, i32, i32 %4 = spv.AccessChain %arg1[%3, %3] : !spv.ptr<!spv.struct<(!spv.array<1 x f32, stride=4> [0])>, StorageBuffer>, i32, i32
spv.Store "StorageBuffer" %4, %2 : f32 spv.Store "StorageBuffer" %4, %2 : f32
spv.Return spv.Return
} }
spv.func @load_store_zero_rank_int(%arg0: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, %arg1: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>) "None" { spv.func @load_store_zero_rank_int(%arg0: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, %arg1: !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>) "None" {
// CHECK: [[LOAD_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])> // CHECK: [[LOAD_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>
// CHECK-NEXT: [[VAL:%.*]] = spv.Load "StorageBuffer" [[LOAD_PTR]] : i32 // CHECK-NEXT: [[VAL:%.*]] = spv.Load "StorageBuffer" [[LOAD_PTR]] : i32
%0 = spv.constant 0 : i32 %0 = spv.Constant 0 : i32
%1 = spv.AccessChain %arg0[%0, %0] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, i32, i32 %1 = spv.AccessChain %arg0[%0, %0] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, i32, i32
%2 = spv.Load "StorageBuffer" %1 : i32 %2 = spv.Load "StorageBuffer" %1 : i32
// CHECK: [[STORE_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])> // CHECK: [[STORE_PTR:%.*]] = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>
// CHECK-NEXT: spv.Store "StorageBuffer" [[STORE_PTR]], [[VAL]] : i32 // CHECK-NEXT: spv.Store "StorageBuffer" [[STORE_PTR]], [[VAL]] : i32
%3 = spv.constant 0 : i32 %3 = spv.Constant 0 : i32
%4 = spv.AccessChain %arg1[%3, %3] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, i32, i32 %4 = spv.AccessChain %arg1[%3, %3] : !spv.ptr<!spv.struct<(!spv.array<1 x i32, stride=4> [0])>, StorageBuffer>, i32, i32
spv.Store "StorageBuffer" %4, %2 : i32 spv.Store "StorageBuffer" %4, %2 : i32
spv.Return spv.Return
} }
} }
// ----- // -----
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

mlir/test/Target/SPIRV/non-uniform-ops.mlir

// RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s // RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK-LABEL: @group_non_uniform_ballot // CHECK-LABEL: @group_non_uniform_ballot
spv.func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> "None" { spv.func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> "None" {
// CHECK: %{{.*}} = spv.GroupNonUniformBallot Workgroup %{{.*}}: vector<4xi32> // CHECK: %{{.*}} = spv.GroupNonUniformBallot Workgroup %{{.*}}: vector<4xi32>
%0 = spv.GroupNonUniformBallot Workgroup %predicate : vector<4xi32> %0 = spv.GroupNonUniformBallot Workgroup %predicate : vector<4xi32>
spv.ReturnValue %0: vector<4xi32> spv.ReturnValue %0: vector<4xi32>
} }
// CHECK-LABEL: @group_non_uniform_broadcast // CHECK-LABEL: @group_non_uniform_broadcast
spv.func @group_non_uniform_broadcast(%value: f32) -> f32 "None" { spv.func @group_non_uniform_broadcast(%value: f32) -> f32 "None" {
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
// CHECK: spv.GroupNonUniformBroadcast Subgroup %{{.*}}, %{{.*}} : f32, i32 // CHECK: spv.GroupNonUniformBroadcast Subgroup %{{.*}}, %{{.*}} : f32, i32
%0 = spv.GroupNonUniformBroadcast Subgroup %value, %one : f32, i32 %0 = spv.GroupNonUniformBroadcast Subgroup %value, %one : f32, i32
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @group_non_uniform_elect // CHECK-LABEL: @group_non_uniform_elect
spv.func @group_non_uniform_elect() -> i1 "None" { spv.func @group_non_uniform_elect() -> i1 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformElect Workgroup : i1 // CHECK: %{{.+}} = spv.GroupNonUniformElect Workgroup : i1
Show All 33 Linesspv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @group_non_uniform_iadd_reduce(%val: i32) -> i32 "None" { spv.func @group_non_uniform_iadd_reduce(%val: i32) -> i32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformIAdd "Workgroup" "Reduce" %val : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
// CHECK-LABEL: @group_non_uniform_iadd_clustered_reduce // CHECK-LABEL: @group_non_uniform_iadd_clustered_reduce
spv.func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> "None" { spv.func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> "None" {
%four = spv.constant 4 : i32 %four = spv.Constant 4 : i32
// CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xi32> // CHECK: %{{.+}} = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %{{.+}} cluster_size(%{{.+}}) : vector<2xi32>
%0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xi32> %0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val cluster_size(%four) : vector<2xi32>
spv.ReturnValue %0: vector<2xi32> spv.ReturnValue %0: vector<2xi32>
} }
// CHECK-LABEL: @group_non_uniform_imul_reduce // CHECK-LABEL: @group_non_uniform_imul_reduce
spv.func @group_non_uniform_imul_reduce(%val: i32) -> i32 "None" { spv.func @group_non_uniform_imul_reduce(%val: i32) -> i32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformIMul "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformIMul "Workgroup" "Reduce" %{{.+}} : i32
Show All 32 Lines

mlir/test/Target/SPIRV/phi.mlir

// RUN: mlir-translate -split-input-file -test-spirv-roundtrip %s | FileCheck %s // RUN: mlir-translate -split-input-file -test-spirv-roundtrip %s | FileCheck %s
// Test branch with one block argument // Test branch with one block argument
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// CHECK: %[[CST:.*]] = spv.constant 0 // CHECK: %[[CST:.*]] = spv.Constant 0
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK-NEXT: spv.Branch ^bb1(%[[CST]] : i32) // CHECK-NEXT: spv.Branch ^bb1(%[[CST]] : i32)
spv.Branch ^bb1(%zero : i32) spv.Branch ^bb1(%zero : i32)
// CHECK-NEXT: ^bb1(%{{.*}}: i32): // CHECK-NEXT: ^bb1(%{{.*}}: i32):
^bb1(%arg0: i32): ^bb1(%arg0: i32):
spv.Return spv.Return
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
} }
// ----- // -----
// Test branch with multiple block arguments // Test branch with multiple block arguments
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// CHECK: %[[ZERO:.*]] = spv.constant 0 // CHECK: %[[ZERO:.*]] = spv.Constant 0
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK-NEXT: %[[ONE:.*]] = spv.constant 1 // CHECK-NEXT: %[[ONE:.*]] = spv.Constant 1
%one = spv.constant 1.0 : f32 %one = spv.Constant 1.0 : f32
// CHECK-NEXT: spv.Branch ^bb1(%[[ZERO]], %[[ONE]] : i32, f32) // CHECK-NEXT: spv.Branch ^bb1(%[[ZERO]], %[[ONE]] : i32, f32)
spv.Branch ^bb1(%zero, %one : i32, f32) spv.Branch ^bb1(%zero, %one : i32, f32)
// CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: f32): // pred: ^bb0 // CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: f32): // pred: ^bb0
^bb1(%arg0: i32, %arg1: f32): ^bb1(%arg0: i32, %arg1: f32):
spv.Return spv.Return
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
} }
// ----- // -----
// Test using block arguments within branch // Test using block arguments within branch
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// CHECK: %[[CST0:.*]] = spv.constant 0 // CHECK: %[[CST0:.*]] = spv.Constant 0
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK-NEXT: spv.Branch ^bb1(%[[CST0]] : i32) // CHECK-NEXT: spv.Branch ^bb1(%[[CST0]] : i32)
spv.Branch ^bb1(%zero : i32) spv.Branch ^bb1(%zero : i32)
// CHECK-NEXT: ^bb1(%[[ARG:.*]]: i32): // CHECK-NEXT: ^bb1(%[[ARG:.*]]: i32):
^bb1(%arg0: i32): ^bb1(%arg0: i32):
// CHECK-NEXT: %[[ADD:.*]] = spv.IAdd %[[ARG]], %[[ARG]] : i32 // CHECK-NEXT: %[[ADD:.*]] = spv.IAdd %[[ARG]], %[[ARG]] : i32
%0 = spv.IAdd %arg0, %arg0 : i32 %0 = spv.IAdd %arg0, %arg0 : i32
// CHECK-NEXT: %[[CST1:.*]] = spv.constant 0 // CHECK-NEXT: %[[CST1:.*]] = spv.Constant 0
// CHECK-NEXT: spv.Branch ^bb2(%[[CST1]], %[[ADD]] : i32, i32) // CHECK-NEXT: spv.Branch ^bb2(%[[CST1]], %[[ADD]] : i32, i32)
spv.Branch ^bb2(%zero, %0 : i32, i32) spv.Branch ^bb2(%zero, %0 : i32, i32)
// CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: i32): // CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: i32):
^bb2(%arg1: i32, %arg2: i32): ^bb2(%arg1: i32, %arg2: i32):
spv.Return spv.Return
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
} }
// ----- // -----
// Test block not following domination order // Test block not following domination order
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
spv.Branch ^bb1 spv.Branch ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: %[[ZERO:.*]] = spv.constant 0 // CHECK-NEXT: %[[ZERO:.*]] = spv.Constant 0
// CHECK-NEXT: %[[ONE:.*]] = spv.constant 1 // CHECK-NEXT: %[[ONE:.*]] = spv.Constant 1
// CHECK-NEXT: spv.Branch ^bb2(%[[ZERO]], %[[ONE]] : i32, f32) // CHECK-NEXT: spv.Branch ^bb2(%[[ZERO]], %[[ONE]] : i32, f32)
// CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: f32): // CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: f32):
^bb2(%arg0: i32, %arg1: f32): ^bb2(%arg0: i32, %arg1: f32):
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
spv.Return spv.Return
// This block is reordered to follow domination order. // This block is reordered to follow domination order.
^bb1: ^bb1:
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
%one = spv.constant 1.0 : f32 %one = spv.Constant 1.0 : f32
spv.Branch ^bb2(%zero, %one : i32, f32) spv.Branch ^bb2(%zero, %one : i32, f32)
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
} }
// ----- // -----
// Test multiple predecessors // Test multiple predecessors
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
%var = spv.Variable : !spv.ptr<i32, Function> %var = spv.Variable : !spv.ptr<i32, Function>
// CHECK: spv.selection // CHECK: spv.selection
spv.selection { spv.selection {
%true = spv.constant true %true = spv.Constant true
// CHECK: spv.BranchConditional %{{.*}}, ^bb1, ^bb2 // CHECK: spv.BranchConditional %{{.*}}, ^bb1, ^bb2
spv.BranchConditional %true, ^true, ^false spv.BranchConditional %true, ^true, ^false
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
^true: ^true:
// CHECK-NEXT: %[[ZERO:.*]] = spv.constant 0 // CHECK-NEXT: %[[ZERO:.*]] = spv.Constant 0
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
// CHECK-NEXT: spv.Branch ^bb3(%[[ZERO]] : i32) // CHECK-NEXT: spv.Branch ^bb3(%[[ZERO]] : i32)
spv.Branch ^phi(%zero: i32) spv.Branch ^phi(%zero: i32)
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^false: ^false:
// CHECK-NEXT: %[[ONE:.*]] = spv.constant 1 // CHECK-NEXT: %[[ONE:.*]] = spv.Constant 1
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
// CHECK-NEXT: spv.Branch ^bb3(%[[ONE]] : i32) // CHECK-NEXT: spv.Branch ^bb3(%[[ONE]] : i32)
spv.Branch ^phi(%one: i32) spv.Branch ^phi(%one: i32)
// CHECK-NEXT: ^bb3(%[[ARG:.*]]: i32): // CHECK-NEXT: ^bb3(%[[ARG:.*]]: i32):
^phi(%arg: i32): ^phi(%arg: i32):
// CHECK-NEXT: spv.Store "Function" %{{.*}}, %[[ARG]] : i32 // CHECK-NEXT: spv.Store "Function" %{{.*}}, %[[ARG]] : i32
spv.Store "Function" %var, %arg : i32 spv.Store "Function" %var, %arg : i32
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
Show All 16 Lines
// ----- // -----
// Test nested loops with block arguments // Test nested loops with block arguments
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.globalVariable @__builtin_var_NumWorkgroups__ built_in("NumWorkgroups") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @__builtin_var_NumWorkgroups__ built_in("NumWorkgroups") : !spv.ptr<vector<3xi32>, Input>
spv.globalVariable @__builtin_var_WorkgroupId__ built_in("WorkgroupId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @__builtin_var_WorkgroupId__ built_in("WorkgroupId") : !spv.ptr<vector<3xi32>, Input>
spv.func @fmul_kernel() "None" { spv.func @fmul_kernel() "None" {
%3 = spv.constant 12 : i32 %3 = spv.Constant 12 : i32
%4 = spv.constant 32 : i32 %4 = spv.Constant 32 : i32
%5 = spv.constant 4 : i32 %5 = spv.Constant 4 : i32
%6 = spv.mlir.addressof @__builtin_var_WorkgroupId__ : !spv.ptr<vector<3xi32>, Input> %6 = spv.mlir.addressof @__builtin_var_WorkgroupId__ : !spv.ptr<vector<3xi32>, Input>
%7 = spv.Load "Input" %6 : vector<3xi32> %7 = spv.Load "Input" %6 : vector<3xi32>
%8 = spv.CompositeExtract %7[0 : i32] : vector<3xi32> %8 = spv.CompositeExtract %7[0 : i32] : vector<3xi32>
%9 = spv.mlir.addressof @__builtin_var_WorkgroupId__ : !spv.ptr<vector<3xi32>, Input> %9 = spv.mlir.addressof @__builtin_var_WorkgroupId__ : !spv.ptr<vector<3xi32>, Input>
%10 = spv.Load "Input" %9 : vector<3xi32> %10 = spv.Load "Input" %9 : vector<3xi32>
%11 = spv.CompositeExtract %10[1 : i32] : vector<3xi32> %11 = spv.CompositeExtract %10[1 : i32] : vector<3xi32>
%18 = spv.mlir.addressof @__builtin_var_NumWorkgroups__ : !spv.ptr<vector<3xi32>, Input> %18 = spv.mlir.addressof @__builtin_var_NumWorkgroups__ : !spv.ptr<vector<3xi32>, Input>
%19 = spv.Load "Input" %18 : vector<3xi32> %19 = spv.Load "Input" %18 : vector<3xi32>
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
} }
// ----- // -----
// Test back-to-back loops with block arguments // Test back-to-back loops with block arguments
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @fmul_kernel() "None" { spv.func @fmul_kernel() "None" {
%cst4 = spv.constant 4 : i32 %cst4 = spv.Constant 4 : i32
%val1 = spv.constant 43 : i32 %val1 = spv.Constant 43 : i32
%val2 = spv.constant 44 : i32 %val2 = spv.Constant 44 : i32
// CHECK: spv.constant 43 // CHECK: spv.Constant 43
// CHECK-NEXT: spv.Branch ^[[BB1:.+]](%{{.+}} : i32) // CHECK-NEXT: spv.Branch ^[[BB1:.+]](%{{.+}} : i32)
// CHECK-NEXT: ^[[BB1]](%{{.+}}: i32): // CHECK-NEXT: ^[[BB1]](%{{.+}}: i32):
// CHECK-NEXT: spv.loop // CHECK-NEXT: spv.loop
spv.loop { // loop 1 spv.loop { // loop 1
spv.Branch ^bb1(%val1 : i32) spv.Branch ^bb1(%val1 : i32)
^bb1(%loop1_bb_arg: i32): ^bb1(%loop1_bb_arg: i32):
%loop1_lt = spv.SLessThan %loop1_bb_arg, %cst4 : i32 %loop1_lt = spv.SLessThan %loop1_bb_arg, %cst4 : i32
spv.BranchConditional %loop1_lt, ^bb2, ^bb3 spv.BranchConditional %loop1_lt, ^bb2, ^bb3
^bb2: ^bb2:
%loop1_add = spv.IAdd %loop1_bb_arg, %cst4 : i32 %loop1_add = spv.IAdd %loop1_bb_arg, %cst4 : i32
spv.Branch ^bb1(%loop1_add : i32) spv.Branch ^bb1(%loop1_add : i32)
^bb3: ^bb3:
spv.mlir.merge spv.mlir.merge
} }
// CHECK: spv.constant 44 // CHECK: spv.Constant 44
// CHECK-NEXT: spv.Branch ^[[BB2:.+]](%{{.+}} : i32) // CHECK-NEXT: spv.Branch ^[[BB2:.+]](%{{.+}} : i32)
// CHECK-NEXT: ^[[BB2]](%{{.+}}: i32): // CHECK-NEXT: ^[[BB2]](%{{.+}}: i32):
// CHECK-NEXT: spv.loop // CHECK-NEXT: spv.loop
spv.loop { // loop 2 spv.loop { // loop 2
spv.Branch ^bb1(%val2 : i32) spv.Branch ^bb1(%val2 : i32)
^bb1(%loop2_bb_arg: i32): ^bb1(%loop2_bb_arg: i32):
%loop2_lt = spv.SLessThan %loop2_bb_arg, %cst4 : i32 %loop2_lt = spv.SLessThan %loop2_bb_arg, %cst4 : i32
spv.BranchConditional %loop2_lt, ^bb2, ^bb3 spv.BranchConditional %loop2_lt, ^bb2, ^bb3
Show All 13 Lines

mlir/test/Target/SPIRV/selection.mlir

// RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s // RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s
// Selection with both then and else branches // Selection with both then and else branches
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @selection(%cond: i1) -> () "None" { spv.func @selection(%cond: i1) -> () "None" {
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
%zero = spv.constant 0: i32 %zero = spv.Constant 0: i32
%one = spv.constant 1: i32 %one = spv.Constant 1: i32
%two = spv.constant 2: i32 %two = spv.Constant 2: i32
%var = spv.Variable init(%zero) : !spv.ptr<i32, Function> %var = spv.Variable init(%zero) : !spv.ptr<i32, Function>
// CHECK-NEXT: spv.selection control(Flatten) // CHECK-NEXT: spv.selection control(Flatten)
// CHECK-NEXT: spv.constant 0 // CHECK-NEXT: spv.Constant 0
// CHECK-NEXT: spv.Variable // CHECK-NEXT: spv.Variable
spv.selection control(Flatten) { spv.selection control(Flatten) {
// CHECK-NEXT: spv.BranchConditional %{{.*}} [5, 10], ^bb1, ^bb2 // CHECK-NEXT: spv.BranchConditional %{{.*}} [5, 10], ^bb1, ^bb2
spv.BranchConditional %cond [5, 10], ^then, ^else spv.BranchConditional %cond [5, 10], ^then, ^else
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
^then: ^then:
// CHECK-NEXT: spv.constant 1 // CHECK-NEXT: spv.Constant 1
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
spv.Store "Function" %var, %one : i32 spv.Store "Function" %var, %one : i32
// CHECK-NEXT: spv.Branch ^bb3 // CHECK-NEXT: spv.Branch ^bb3
spv.Branch ^merge spv.Branch ^merge
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^else: ^else:
// CHECK-NEXT: spv.constant 2 // CHECK-NEXT: spv.Constant 2
// CHECK-NEXT: spv.Store // CHECK-NEXT: spv.Store
spv.Store "Function" %var, %two : i32 spv.Store "Function" %var, %two : i32
// CHECK-NEXT: spv.Branch ^bb3 // CHECK-NEXT: spv.Branch ^bb3
spv.Branch ^merge spv.Branch ^merge
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
Show All 22 Lines
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
// CHECK-NEXT: spv.selection // CHECK-NEXT: spv.selection
spv.selection { spv.selection {
// CHECK-NEXT: spv.BranchConditional %[[ARG]], ^bb1, ^bb2 // CHECK-NEXT: spv.BranchConditional %[[ARG]], ^bb1, ^bb2
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
// CHECK: ^bb1: // CHECK: ^bb1:
^then: ^then:
%zero = spv.constant 0 : i32 %zero = spv.Constant 0 : i32
spv.ReturnValue %zero : i32 spv.ReturnValue %zero : i32
// CHECK: ^bb2: // CHECK: ^bb2:
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
%one = spv.constant 1 : i32 %one = spv.Constant 1 : i32
spv.ReturnValue %one : i32 spv.ReturnValue %one : i32
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
spv.ExecutionMode @main "LocalSize", 1, 1, 1 spv.ExecutionMode @main "LocalSize", 1, 1, 1
} }

mlir/test/Target/SPIRV/spec-constant.mlir

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.specConstant @sc_i32_1 = 1 : i32 spv.specConstant @sc_i32_1 = 1 : i32
spv.func @use_composite() -> (i32) "None" { spv.func @use_composite() -> (i32) "None" {
// CHECK: [[USE1:%.*]] = spv.mlir.referenceof @sc_i32_1 : i32 // CHECK: [[USE1:%.*]] = spv.mlir.referenceof @sc_i32_1 : i32
// CHECK: [[USE2:%.*]] = spv.constant 0 : i32 // CHECK: [[USE2:%.*]] = spv.Constant 0 : i32
// CHECK: [[RES1:%.*]] = spv.SpecConstantOperation wraps "spv.ISub"([[USE1]], [[USE2]]) : (i32, i32) -> i32 // CHECK: [[RES1:%.*]] = spv.SpecConstantOperation wraps "spv.ISub"([[USE1]], [[USE2]]) : (i32, i32) -> i32
// CHECK: [[USE3:%.*]] = spv.mlir.referenceof @sc_i32_1 : i32 // CHECK: [[USE3:%.*]] = spv.mlir.referenceof @sc_i32_1 : i32
// CHECK: [[USE4:%.*]] = spv.constant 0 : i32 // CHECK: [[USE4:%.*]] = spv.Constant 0 : i32
// CHECK: [[RES2:%.*]] = spv.SpecConstantOperation wraps "spv.ISub"([[USE3]], [[USE4]]) : (i32, i32) -> i32 // CHECK: [[RES2:%.*]] = spv.SpecConstantOperation wraps "spv.ISub"([[USE3]], [[USE4]]) : (i32, i32) -> i32
%0 = spv.mlir.referenceof @sc_i32_1 : i32 %0 = spv.mlir.referenceof @sc_i32_1 : i32
%1 = spv.constant 0 : i32 %1 = spv.Constant 0 : i32
%2 = spv.SpecConstantOperation wraps "spv.ISub"(%0, %1) : (i32, i32) -> i32 %2 = spv.SpecConstantOperation wraps "spv.ISub"(%0, %1) : (i32, i32) -> i32
// CHECK: [[RES3:%.*]] = spv.SpecConstantOperation wraps "spv.IMul"([[RES1]], [[RES2]]) : (i32, i32) -> i32 // CHECK: [[RES3:%.*]] = spv.SpecConstantOperation wraps "spv.IMul"([[RES1]], [[RES2]]) : (i32, i32) -> i32
%3 = spv.SpecConstantOperation wraps "spv.IMul"(%2, %2) : (i32, i32) -> i32 %3 = spv.SpecConstantOperation wraps "spv.IMul"(%2, %2) : (i32, i32) -> i32
// Make sure deserialization continues from the right place after creating // Make sure deserialization continues from the right place after creating
// the previous op. // the previous op.
// CHECK: spv.ReturnValue [[RES3]] // CHECK: spv.ReturnValue [[RES3]]
spv.ReturnValue %3 : i32 spv.ReturnValue %3 : i32
} }
} }

mlir/test/Target/SPIRV/undef.mlir

Show All 9 Lines spv.func @foo() -> () "None" {
// CHECK: {{%.*}} = spv.undef : vector<4xi32> // CHECK: {{%.*}} = spv.undef : vector<4xi32>
%3 = spv.undef : vector<4xi32> %3 = spv.undef : vector<4xi32>
%4 = spv.CompositeExtract %3[1 : i32] : vector<4xi32> %4 = spv.CompositeExtract %3[1 : i32] : vector<4xi32>
// CHECK: {{%.*}} = spv.undef : !spv.array<4 x !spv.array<4 x i32>> // CHECK: {{%.*}} = spv.undef : !spv.array<4 x !spv.array<4 x i32>>
%5 = spv.undef : !spv.array<4x!spv.array<4xi32>> %5 = spv.undef : !spv.array<4x!spv.array<4xi32>>
%6 = spv.CompositeExtract %5[1 : i32, 2 : i32] : !spv.array<4x!spv.array<4xi32>> %6 = spv.CompositeExtract %5[1 : i32, 2 : i32] : !spv.array<4x!spv.array<4xi32>>
// CHECK: {{%.*}} = spv.undef : !spv.ptr<!spv.struct<(f32)>, StorageBuffer> // CHECK: {{%.*}} = spv.undef : !spv.ptr<!spv.struct<(f32)>, StorageBuffer>
%7 = spv.undef : !spv.ptr<!spv.struct<(f32)>, StorageBuffer> %7 = spv.undef : !spv.ptr<!spv.struct<(f32)>, StorageBuffer>
%8 = spv.constant 0 : i32 %8 = spv.Constant 0 : i32
%9 = spv.AccessChain %7[%8] : !spv.ptr<!spv.struct<(f32)>, StorageBuffer>, i32 %9 = spv.AccessChain %7[%8] : !spv.ptr<!spv.struct<(f32)>, StorageBuffer>, i32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: spv.func {{@.*}} // CHECK: spv.func {{@.*}}
spv.func @ignore_unused_undef() -> () "None" { spv.func @ignore_unused_undef() -> () "None" {
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
%0 = spv.undef : f32 %0 = spv.undef : f32
spv.Return spv.Return
} }
} }