This is an archive of the discontinued LLVM Phabricator instance.

Differential D93407

[mlir][spirv] NFC: Shuffle code around to better follow convention
ClosedPublic

Authored by antiagainst on Dec 16 2020, 10:11 AM.

Details

Reviewers
mravishankar
aartbik
ftynse
herhut
ThomasRaoux
hanchung
Commits
rG01178654121b: [mlir][spirv] NFC: Shuffle code around to better follow convention
Summary

This commit shuffles SPIR-V code around to better follow MLIR
convention. Specifically,

  • Created IR/, Transforms/, Linking/, and Utils/ subdirectories and moved suitable code inside.
  • Created SPIRVEnums.{h|cpp} for SPIR-V C/C++ enums generated from SPIR-V spec. Previously they are cluttered inside SPIRVTypes.{h|cpp}.
  • Fixed include guards in various header files (both .h and .td).
  • Moved serialization tests under test/Target/SPIRV.
  • Renamed TableGen backend -gen-spirv-op-utils into -gen-spirv-attr-utils as it is only generating utility functions for attributes.

Diff Detail

Unit TestsFailed

TimeTest
80 msx64 windows > LLVM.CodeGen/XCore::threads.ll

Event Timeline

antiagainst created this revision.Dec 16 2020, 10:11 AM
Herald added a reviewer: mravishankar. · View Herald TranscriptDec 16 2020, 10:11 AM
Herald added a reviewer: aartbik. · View Herald Transcript
Herald added a reviewer: ftynse. · View Herald Transcript
Herald added subscribers: mravishankar, teijeong, rdzhabarov and 20 others. · View Herald Transcript
antiagainst requested review of this revision.Dec 16 2020, 10:11 AM
Herald added a reviewer: herhut. · View Herald TranscriptDec 16 2020, 10:11 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
antiagainst added reviewers: ThomasRaoux, hanchung.Dec 16 2020, 10:31 AM
Harbormaster completed remote builds in B82663: Diff 312251.Dec 16 2020, 10:36 AM
mravishankar accepted this revision.Dec 16 2020, 11:11 AM

Thanks for doing this!

This revision is now accepted and ready to land.Dec 16 2020, 11:11 AM
This revision was landed with ongoing or failed builds.Dec 17 2020, 8:03 AM
Closed by commit rG01178654121b: [mlir][spirv] NFC: Shuffle code around to better follow convention (authored by antiagainst). · Explain Why
This revision was automatically updated to reflect the committed changes.
antiagainst added a commit: rG01178654121b: [mlir][spirv] NFC: Shuffle code around to better follow convention.

Revision Contents

PathSize
mlir/
docs/
Dialects/
29 lines
include/
mlir/
Dialect/
SPIRV/
47 lines
IR/
13 lines
11 lines
8 lines
6 lines
20 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
6 lines
8 lines
6 lines
8 lines
6 lines
8 lines
25 lines
38 lines
8 lines
43 lines
8 lines
8 lines
IR/
57 lines
Linking/
8 lines
Transforms/
7 lines
Transforms/
13 lines
6 lines
SPIRVConversion.h
SPIRVLowering.h
16 lines
Utils/
9 lines
2 lines
2 lines
Target/
SPIRV/
2 lines
lib/
Conversion/
GPUToSPIRV/
1 line
8 lines
6 lines
8 lines
GPUToVulkan/
4 lines
LinalgToSPIRV/
1 line
6 lines
4 lines
SCFToSPIRV/
1 line
6 lines
SPIRVToLLVM/
1 line
2 lines
6 lines
2 lines
StandardToSPIRV/
2 lines
8 lines
4 lines
2 lines
VectorToSPIRV/
1 line
8 lines
Dialect/
SPIRV/
38 lines
IR/
11 lines
16 lines
7 lines
2 lines
18 lines
18 lines
103 lines
4 lines
IR/
94 lines
Linking/
ModuleCombiner/
6 lines
Transforms/
26 lines
DecorateCompositeTypeLayoutPass.cpp
DecorateSPIRVCompositeTypeLayoutPass.cpp
10 lines
10 lines
2 lines
4 lines
10 lines
Transforms/
SPIRVConversion.cpp
SPIRVLowering.cpp
11 lines
Utils/
10 lines
Utils/
7 lines
Target/
SPIRV/
10 lines
2 lines
10 lines
6 lines
test/
Dialect/
SPIRV/
IR/
221 lines
166 lines
51 lines
77 lines
285 lines
791 lines
cooperative-matrix-ops.mlir
cooperative-matrix.mlir
158 lines
glsl-ops.mlir
glslops.mlir
347 lines
103 lines
127 lines
126 lines
280 lines
168 lines
1355 lines
815 lines
261 lines
191 lines
524 lines
Linking/
ModuleCombiner/
conflict-resolution.mlir
conflict_resolution.mlir
705 lines
deduplication.mlir
deduplication_basic.mlir
244 lines
Serialization/
Transforms/
713 lines
Target/
SPIRV/
Dialect/
SPIRV/
Serialization/
84 lines
18 lines
32 lines
24 lines
58 lines
73 lines
24 lines
241 lines
146 lines
51 lines
27 lines
10 lines
53 lines
36 lines
51 lines
46 lines
102 lines
209 lines
59 lines
111 lines
32 lines
103 lines
23 lines
288 lines
89 lines
87 lines
52 lines
27 lines
33 lines
cooperative-matrix-ops.mlir/
Serialization/
cooperative-matrix.mlir
102 lines
lib/
Dialect/
SPIRV/
1 line
6 lines
4 lines
7 lines
Transforms/
2 lines
tools/
mlir-spirv-cpu-runner/
8 lines
4 lines
mlir-tblgen/
30 lines
mlir-vulkan-runner/
4 lines
unittests/
Dialect/
SPIRV/
6 lines
10 lines

Diff 312251

mlir/docs/Dialects/SPIR-V.md

Show First 20 Lines • Show All 1,143 Lines • ▼ Show 20 Lines* From standard dialect: headers are at
[include/mlir/Conversion/StandardTOSPIRV][MlirStdToSpirvHeaders]; libraries [include/mlir/Conversion/StandardTOSPIRV][MlirStdToSpirvHeaders]; libraries
are at [lib/Conversion/StandardToSPIRV][MlirStdToSpirvLibs]. are at [lib/Conversion/StandardToSPIRV][MlirStdToSpirvLibs].
These dialect to dialect conversions have their dedicated libraries, These dialect to dialect conversions have their dedicated libraries,
`MLIRGPUToSPIRVTransforms` and `MLIRStandardToSPIRVTransforms`, respectively. `MLIRGPUToSPIRVTransforms` and `MLIRStandardToSPIRVTransforms`, respectively.
There are also common utilities when targeting SPIR-V from any dialect: There are also common utilities when targeting SPIR-V from any dialect:
* [include/mlir/Dialect/SPIRV/Passes.h][MlirSpirvPasses] contains SPIR-V * [include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h][MlirSpirvConversion]
specific analyses and transformations. contains type converters and other utility functions.
* [include/mlir/Dialect/SPIRV/SPIRVLowering.h][MlirSpirvLowering] contains * [include/mlir/Dialect/SPIRV/Transforms/Passes.h][MlirSpirvPasses] contains
type converters and other utility functions. SPIR-V specific analyses and transformations.
These common utilities are implemented in the `MLIRSPIRVTransforms` library. These common utilities are implemented in the `MLIRSPIRVConversion` and
`MLIRSPIRVTransforms` library, respectively.
## Rationale ## Rationale
### Lowering `memref`s to `!spv.array<..>` and `!spv.rtarray<..>`. ### Lowering `memref`s to `!spv.array<..>` and `!spv.rtarray<..>`.
The LLVM dialect lowers `memref` types to a `MemrefDescriptor`: The LLVM dialect lowers `memref` types to a `MemrefDescriptor`:
``` ```
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Lines
[MlirSpirvHeaders]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Dialect/SPIRV [MlirSpirvHeaders]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Dialect/SPIRV
[MlirSpirvLibs]: https://github.com/llvm/llvm-project/tree/master/mlir/lib/Dialect/SPIRV [MlirSpirvLibs]: https://github.com/llvm/llvm-project/tree/master/mlir/lib/Dialect/SPIRV
[MlirSpirvTests]: https://github.com/llvm/llvm-project/tree/master/mlir/test/Dialect/SPIRV [MlirSpirvTests]: https://github.com/llvm/llvm-project/tree/master/mlir/test/Dialect/SPIRV
[MlirSpirvUnittests]: https://github.com/llvm/llvm-project/tree/master/mlir/unittests/Dialect/SPIRV [MlirSpirvUnittests]: https://github.com/llvm/llvm-project/tree/master/mlir/unittests/Dialect/SPIRV
[MlirGpuToSpirvHeaders]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Conversion/GPUToSPIRV [MlirGpuToSpirvHeaders]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Conversion/GPUToSPIRV
[MlirGpuToSpirvLibs]: https://github.com/llvm/llvm-project/tree/master/mlir/lib/Conversion/GPUToSPIRV [MlirGpuToSpirvLibs]: https://github.com/llvm/llvm-project/tree/master/mlir/lib/Conversion/GPUToSPIRV
[MlirStdToSpirvHeaders]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Conversion/StandardToSPIRV [MlirStdToSpirvHeaders]: https://github.com/llvm/llvm-project/tree/master/mlir/include/mlir/Conversion/StandardToSPIRV
[MlirStdToSpirvLibs]: https://github.com/llvm/llvm-project/tree/master/mlir/lib/Conversion/StandardToSPIRV [MlirStdToSpirvLibs]: https://github.com/llvm/llvm-project/tree/master/mlir/lib/Conversion/StandardToSPIRV
[MlirSpirvDialect]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVDialect.h [MlirSpirvDialect]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVDialect.h
[MlirSpirvTypes]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h [MlirSpirvTypes]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h
[MlirSpirvOpsH]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h [MlirSpirvOpsH]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.h
[MlirSpirvSerialization]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/Serialization.h [MlirSpirvSerialization]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Target/SPIRV/Serialization.h
[MlirSpirvBase]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td [MlirSpirvBase]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td
[MlirSpirvPasses]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/Passes.h [MlirSpirvPasses]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h
[MlirSpirvLowering]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h [MlirSpirvConversion]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h
[MlirSpirvAbi]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/TargetAndABI.h [MlirSpirvAbi]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/IR/TargetAndABI.h
[MlirSpirvOpsCpp]: https://github.com/llvm/llvm-project/blob/master/mlir/lib/Dialect/SPIRV/SPIRVOps.cpp [MlirSpirvOpsCpp]: https://github.com/llvm/llvm-project/blob/master/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
[GitHubDialectTracking]: https://github.com/tensorflow/mlir/issues/302 [GitHubDialectTracking]: https://github.com/tensorflow/mlir/issues/302
[GitHubLoweringTracking]: https://github.com/tensorflow/mlir/issues/303 [GitHubLoweringTracking]: https://github.com/tensorflow/mlir/issues/303
[GenSpirvUtilsPy]: https://github.com/llvm/llvm-project/blob/master/mlir/utils/spirv/gen_spirv_dialect.py [GenSpirvUtilsPy]: https://github.com/llvm/llvm-project/blob/master/mlir/utils/spirv/gen_spirv_dialect.py
[CustomTypeAttrTutorial]: ../Tutorials/DefiningAttributesAndTypes.md [CustomTypeAttrTutorial]: ../Tutorials/DefiningAttributesAndTypes.md
[VulkanExtensionPhysicalStorageBuffer]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_physical_storage_buffer.html [VulkanExtensionPhysicalStorageBuffer]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_physical_storage_buffer.html
[VulkanExtensionVariablePointers]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_variable_pointers.html [VulkanExtensionVariablePointers]: https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_variable_pointers.html
[VulkanSpirv]: https://renderdoc.org/vkspec_chunked/chap40.html#spirvenv [VulkanSpirv]: https://renderdoc.org/vkspec_chunked/chap40.html#spirvenv
[VulkanShaderInterface]: https://renderdoc.org/vkspec_chunked/chap14.html#interfaces-resources [VulkanShaderInterface]: https://renderdoc.org/vkspec_chunked/chap14.html#interfaces-resources
[VulkanShaderInterfaceStorageClass]: https://renderdoc.org/vkspec_chunked/chap15.html#interfaces [VulkanShaderInterfaceStorageClass]: https://renderdoc.org/vkspec_chunked/chap15.html#interfaces
[VulkanResourceLimits]: https://renderdoc.org/vkspec_chunked/chap36.html#limits [VulkanResourceLimits]: https://renderdoc.org/vkspec_chunked/chap36.html#limits
[VulkanGPUInfoMaxPerStageDescriptorStorageBuffers]: https://vulkan.gpuinfo.org/displaydevicelimit.php?name=maxPerStageDescriptorStorageBuffers&platform=android [VulkanGPUInfoMaxPerStageDescriptorStorageBuffers]: https://vulkan.gpuinfo.org/displaydevicelimit.php?name=maxPerStageDescriptorStorageBuffers&platform=android
[VulkanPushConstants]: https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html [VulkanPushConstants]: https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html

mlir/include/mlir/Dialect/SPIRV/CMakeLists.txt

  • This file was copied to mlir/include/mlir/Dialect/SPIRV/IR/CMakeLists.txt.
add_mlir_dialect(SPIRVOps spv) add_subdirectory(IR)
add_mlir_doc(SPIRVOps -gen-op-doc SPIRVOps Dialects/) add_subdirectory(Transforms)
set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
mlir_tablegen(SPIRVEnums.h.inc -gen-enum-decls)
mlir_tablegen(SPIRVEnums.cpp.inc -gen-enum-defs)
add_public_tablegen_target(MLIRSPIRVEnumsIncGen)
add_dependencies(mlir-headers MLIRSPIRVEnumsIncGen)
set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
mlir_tablegen(SPIRVEnumAvailability.h.inc -gen-spirv-enum-avail-decls)
mlir_tablegen(SPIRVEnumAvailability.cpp.inc -gen-spirv-enum-avail-defs)
mlir_tablegen(SPIRVCapabilityImplication.inc -gen-spirv-capability-implication)
add_public_tablegen_target(MLIRSPIRVEnumAvailabilityIncGen)
add_dependencies(mlir-headers MLIRSPIRVEnumAvailabilityIncGen)
set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
mlir_tablegen(SPIRVAvailability.h.inc -gen-avail-interface-decls)
mlir_tablegen(SPIRVAvailability.cpp.inc -gen-avail-interface-defs)
mlir_tablegen(SPIRVOpAvailabilityImpl.inc -gen-spirv-avail-impls)
add_public_tablegen_target(MLIRSPIRVAvailabilityIncGen)
add_dependencies(mlir-headers MLIRSPIRVAvailabilityIncGen)
set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
mlir_tablegen(SPIRVSerialization.inc -gen-spirv-serialization)
add_public_tablegen_target(MLIRSPIRVSerializationGen)
add_dependencies(mlir-headers MLIRSPIRVSerializationGen)
set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
mlir_tablegen(SPIRVOpUtils.inc -gen-spirv-op-utils)
add_public_tablegen_target(MLIRSPIRVOpUtilsGen)
add_dependencies(mlir-headers MLIRSPIRVOpUtilsGen)
set(LLVM_TARGET_DEFINITIONS TargetAndABI.td)
mlir_tablegen(TargetAndABI.h.inc -gen-struct-attr-decls)
mlir_tablegen(TargetAndABI.cpp.inc -gen-struct-attr-defs)
add_public_tablegen_target(MLIRSPIRVTargetAndABIIncGen)
add_dependencies(mlir-headers MLIRSPIRVTargetAndABIIncGen)
set(LLVM_TARGET_DEFINITIONS Passes.td)
mlir_tablegen(Passes.h.inc -gen-pass-decls -name SPIRV)
add_public_tablegen_target(MLIRSPIRVPassIncGen)
add_dependencies(mlir-headers MLIRSPIRVPassIncGen)
add_mlir_doc(Passes -gen-pass-doc SPIRVPasses ./)

mlir/include/mlir/Dialect/SPIRV/IR/CMakeLists.txt

  • This file was copied from mlir/include/mlir/Dialect/SPIRV/CMakeLists.txt.
Show All 21 Lines
add_dependencies(mlir-headers MLIRSPIRVAvailabilityIncGen) add_dependencies(mlir-headers MLIRSPIRVAvailabilityIncGen)
set(LLVM_TARGET_DEFINITIONS SPIRVOps.td) set(LLVM_TARGET_DEFINITIONS SPIRVOps.td)
mlir_tablegen(SPIRVSerialization.inc -gen-spirv-serialization) mlir_tablegen(SPIRVSerialization.inc -gen-spirv-serialization)
add_public_tablegen_target(MLIRSPIRVSerializationGen) add_public_tablegen_target(MLIRSPIRVSerializationGen)
add_dependencies(mlir-headers MLIRSPIRVSerializationGen) add_dependencies(mlir-headers MLIRSPIRVSerializationGen)
set(LLVM_TARGET_DEFINITIONS SPIRVBase.td) set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
mlir_tablegen(SPIRVOpUtils.inc -gen-spirv-op-utils) mlir_tablegen(SPIRVAttrUtils.inc -gen-spirv-attr-utils)
add_public_tablegen_target(MLIRSPIRVOpUtilsGen) add_public_tablegen_target(MLIRSPIRVAttrUtilsGen)
add_dependencies(mlir-headers MLIRSPIRVOpUtilsGen) add_dependencies(mlir-headers MLIRSPIRVAttrUtilsGen)
set(LLVM_TARGET_DEFINITIONS TargetAndABI.td) set(LLVM_TARGET_DEFINITIONS TargetAndABI.td)
mlir_tablegen(TargetAndABI.h.inc -gen-struct-attr-decls) mlir_tablegen(TargetAndABI.h.inc -gen-struct-attr-decls)
mlir_tablegen(TargetAndABI.cpp.inc -gen-struct-attr-defs) mlir_tablegen(TargetAndABI.cpp.inc -gen-struct-attr-defs)
add_public_tablegen_target(MLIRSPIRVTargetAndABIIncGen) add_public_tablegen_target(MLIRSPIRVTargetAndABIIncGen)
add_dependencies(mlir-headers MLIRSPIRVTargetAndABIIncGen) add_dependencies(mlir-headers MLIRSPIRVTargetAndABIIncGen)
set(LLVM_TARGET_DEFINITIONS Passes.td)
mlir_tablegen(Passes.h.inc -gen-pass-decls -name SPIRV)
add_public_tablegen_target(MLIRSPIRVPassIncGen)
add_dependencies(mlir-headers MLIRSPIRVPassIncGen)
add_mlir_doc(Passes -gen-pass-doc SPIRVPasses ./)

mlir/include/mlir/Dialect/SPIRV/IR/ParserUtils.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/ParserUtils.h.
//===------------ ParserUtils.h - Parse text to SPIR-V ops ----------------===// //===------------ ParserUtils.h - Parse text to SPIR-V ops ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines utilities used for parsing types and ops for SPIR-V // This file defines utilities used for parsing types and ops for SPIR-V
// dialect. // dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_PARSERUTILS_H_
#define MLIR_DIALECT_SPIRV_PARSERUTILS_H_
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #ifndef MLIR_DIALECT_SPIRV_IR_PARSERUTILS_H_
#define MLIR_DIALECT_SPIRV_IR_PARSERUTILS_H_
#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpDefinition.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
namespace mlir { namespace mlir {
/// Parses the next keyword in `parser` as an enumerant of the given /// Parses the next keyword in `parser` as an enumerant of the given
/// `EnumClass`. /// `EnumClass`.
template <typename EnumClass, typename ParserType> template <typename EnumClass, typename ParserType>
static ParseResult static ParseResult
parseEnumKeywordAttr(EnumClass &value, ParserType &parser, parseEnumKeywordAttr(EnumClass &value, ParserType &parser,
StringRef attrName = spirv::attributeName<EnumClass>()) { StringRef attrName = spirv::attributeName<EnumClass>()) {
StringRef keyword; StringRef keyword;
SmallVector<NamedAttribute, 1> attr; SmallVector<NamedAttribute, 1> attr;
auto loc = parser.getCurrentLocation(); auto loc = parser.getCurrentLocation();
if (parser.parseKeyword(&keyword)) if (parser.parseKeyword(&keyword))
return failure(); return failure();
if (Optional<EnumClass> attr = spirv::symbolizeEnum<EnumClass>(keyword)) { if (Optional<EnumClass> attr = spirv::symbolizeEnum<EnumClass>(keyword)) {
value = attr.getValue(); value = attr.getValue();
return success(); return success();
} }
return parser.emitError(loc, "invalid ") return parser.emitError(loc, "invalid ")
<< attrName << " attribute specification: " << keyword; << attrName << " attribute specification: " << keyword;
} }
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_PARSERUTILS_H_ #endif // MLIR_DIALECT_SPIRV_IR_PARSERUTILS_H_

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVArithmeticOps.td.
//===-- SPIRVArithmeticOps.td - MLIR SPIR-V Arithmetic Ops -*- tablegen -*-===// //===-- SPIRVArithmeticOps.td - MLIR SPIR-V Arithmetic Ops -*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains arithmetic ops for the SPIR-V dialect. It corresponds // This file contains arithmetic ops for the SPIR-V dialect. It corresponds
// to "3.32.13. Arithmetic Instructions" of the SPIR-V specification. // to "3.32.13. Arithmetic Instructions" of the SPIR-V specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_ARITHMETIC_OPS #ifndef MLIR_DIALECT_SPIRV_IR_ARITHMETIC_OPS
#define SPIRV_ARITHMETIC_OPS #define MLIR_DIALECT_SPIRV_IR_ARITHMETIC_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
class SPV_ArithmeticBinaryOp<string mnemonic, Type type, class SPV_ArithmeticBinaryOp<string mnemonic, Type type,
list<OpTrait> traits = []> : list<OpTrait> traits = []> :
// Operands type same as result type. // Operands type same as result type.
SPV_BinaryOp<mnemonic, type, type, SPV_BinaryOp<mnemonic, type, type,
!listconcat(traits, !listconcat(traits,
[NoSideEffect, SameOperandsAndResultType])> { [NoSideEffect, SameOperandsAndResultType])> {
▲ Show 20 Lines • Show All 545 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%4 = spv.UMod %0, %1 : i32 %4 = spv.UMod %0, %1 : i32
%5 = spv.UMod %2, %3 : vector<4xi32> %5 = spv.UMod %2, %3 : vector<4xi32>
``` ```
}]; }];
} }
#endif // SPIRV_ARITHMETIC_OPS #endif // MLIR_DIALECT_SPIRV_IR_ARITHMETIC_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVAtomicOps.td.
//===-- SPIRVAtomicOps.td - MLIR SPIR-V Atomic Ops ---------*- tablegen -*-===// //===-- SPIRVAtomicOps.td - MLIR SPIR-V Atomic Ops ---------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains atomic ops for the SPIR-V dialect. It corresponds to // This file contains atomic ops for the SPIR-V dialect. It corresponds to
// "3.32.18. Atomic Instructions" of the SPIR-V specification. // "3.32.18. Atomic Instructions" of the SPIR-V specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_ATOMIC_OPS #ifndef MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS
#define SPIRV_ATOMIC_OPS #define MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS
class SPV_AtomicUpdateOp<string mnemonic, list<OpTrait> traits = []> : class SPV_AtomicUpdateOp<string mnemonic, list<OpTrait> traits = []> :
SPV_Op<mnemonic, traits> { SPV_Op<mnemonic, traits> {
let parser = [{ return ::parseAtomicUpdateOp(parser, result, false); }]; let parser = [{ return ::parseAtomicUpdateOp(parser, result, false); }];
let printer = [{ return ::printAtomicUpdateOp(getOperation(), p); }]; let printer = [{ return ::printAtomicUpdateOp(getOperation(), p); }];
let verifier = [{ return ::verifyAtomicUpdateOp(getOperation()); }]; let verifier = [{ return ::verifyAtomicUpdateOp(getOperation()); }];
let arguments = (ins let arguments = (ins
▲ Show 20 Lines • Show All 535 Lines • ▼ Show 20 Lines let description = [{
%0 = spv.AtomicXor "Device" "None" %pointer, %value : %0 = spv.AtomicXor "Device" "None" %pointer, %value :
!spv.ptr<i32, StorageBuffer> !spv.ptr<i32, StorageBuffer>
``` ```
}]; }];
} }
// ----- // -----
#endif // SPIRV_ATOMIC_OPS #endif // MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h.
//===- SPIRVAttributes.h - SPIR-V attribute declarations -------*- C++ -*-===// //===- SPIRVAttributes.h - SPIR-V attribute declarations -------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares SPIR-V dialect specific attributes. // This file declares SPIR-V dialect specific attributes.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H #ifndef MLIR_DIALECT_SPIRV_IR_SPIRVATTRIBUTES_H
#define MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H #define MLIR_DIALECT_SPIRV_IR_SPIRVATTRIBUTES_H
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/BuiltinAttributes.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
// Pull in SPIR-V attribute definitions for target and ABI. // Pull in TableGen'erated SPIR-V attribute definitions for target and ABI.
#include "mlir/Dialect/SPIRV/TargetAndABI.h.inc" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h.inc"
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
enum class Capability : uint32_t; enum class Capability : uint32_t;
enum class DeviceType; enum class DeviceType;
enum class Extension; enum class Extension;
enum class Vendor; enum class Vendor;
enum class Version : uint32_t; enum class Version : uint32_t;
namespace detail { namespace detail {
struct InterfaceVarABIAttributeStorage; struct InterfaceVarABIAttributeStorage;
struct TargetEnvAttributeStorage; struct TargetEnvAttributeStorage;
struct VerCapExtAttributeStorage; struct VerCapExtAttributeStorage;
} // namespace detail } // namespace detail
// TableGen'erated helper functions.
//
// Get the name used in the Op to refer to an enum value of the given
// `EnumClass`.
// template <typename EnumClass> StringRef attributeName();
//
#include "mlir/Dialect/SPIRV/IR/SPIRVAttrUtils.inc"
/// An attribute that specifies the information regarding the interface /// An attribute that specifies the information regarding the interface
/// variable: descriptor set, binding, storage class. /// variable: descriptor set, binding, storage class.
class InterfaceVarABIAttr class InterfaceVarABIAttr
: public Attribute::AttrBase<InterfaceVarABIAttr, Attribute, : public Attribute::AttrBase<InterfaceVarABIAttr, Attribute,
detail::InterfaceVarABIAttributeStorage> { detail::InterfaceVarABIAttributeStorage> {
public: public:
using Base::Base; using Base::Base;
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 Linespublic:
static LogicalResult static LogicalResult
verifyConstructionInvariants(Location loc, VerCapExtAttr triple, verifyConstructionInvariants(Location loc, VerCapExtAttr triple,
Vendor vendorID, DeviceType deviceType, Vendor vendorID, DeviceType deviceType,
uint32_t deviceID, DictionaryAttr limits); uint32_t deviceID, DictionaryAttr limits);
}; };
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H #endif // MLIR_DIALECT_SPIRV_IR_SPIRVATTRIBUTES_H

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVAvailability.td.
//===- SPIRVAvailability.td - Op Availability Base file ----*- tablegen -*-===// //===- SPIRVAvailability.td - Op Availability Base file ----*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_AVAILABILITY #ifndef MLIR_DIALECT_SPIRV_IR_AVAILABILITY
#define SPIRV_AVAILABILITY #define MLIR_DIALECT_SPIRV_IR_AVAILABILITY
include "mlir/IR/OpBase.td" include "mlir/IR/OpBase.td"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Op availability definitions // Op availability definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// The base class for defining op availability dimensions. // The base class for defining op availability dimensions.
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines let mergeAction = "$overall = static_cast<" # scheme.returnType # ">("
"std::min($overall, $instance))"; "std::min($overall, $instance))";
let initializer = "static_cast<" # scheme.returnType # ">(~uint32_t(0))"; let initializer = "static_cast<" # scheme.returnType # ">(~uint32_t(0))";
let instanceType = scheme.cppNamespace # "::" # scheme.className; let instanceType = scheme.cppNamespace # "::" # scheme.className;
let instance = scheme.cppNamespace # "::" # scheme.className # "::" # let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
max.symbol; max.symbol;
} }
#endif // SPIRV_AVAILABILITY #endif // MLIR_DIALECT_SPIRV_IR_AVAILABILITY

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td.
//===- SPIRVBase.td - MLIR SPIR-V Op Definitions Base file -*- tablegen -*-===// //===- SPIRVBase.td - MLIR SPIR-V Op Definitions Base file -*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This is the base file for SPIR-V operation definition specification. // This is the base file for SPIR-V operation definition specification.
// This file defines the SPIR-V dialect, common SPIR-V types, and utilities // This file defines the SPIR-V dialect, common SPIR-V types, and utilities
// for facilitating defining SPIR-V ops. // for facilitating defining SPIR-V ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_BASE #ifndef MLIR_DIALECT_SPIRV_IR_BASE
#define SPIRV_BASE #define MLIR_DIALECT_SPIRV_IR_BASE
include "mlir/IR/OpBase.td" include "mlir/IR/OpBase.td"
include "mlir/Dialect/SPIRV/SPIRVAvailability.td" include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.td"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SPIR-V dialect definitions // SPIR-V dialect definitions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def SPIRV_Dialect : Dialect { def SPIRV_Dialect : Dialect {
let name = "spv"; let name = "spv";
▲ Show 20 Lines • Show All 3,447 Lines • ▼ Show 20 Linesclass SPV_ExtInstOp<string mnemonic, string setPrefix, string setName,
// Opcode within extended instruction set. // Opcode within extended instruction set.
int extendedInstOpcode = opcode; int extendedInstOpcode = opcode;
// Name used to import the extended instruction set. // Name used to import the extended instruction set.
string extendedInstSetName = setName; string extendedInstSetName = setName;
} }
#endif // SPIRV_BASE #endif // MLIR_DIALECT_SPIRV_IR_BASE

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVBitOps.td.
//===-- SPIRVBitOps.td - MLIR SPIR-V Bit Ops -*- tablegen -*-===// //===-- SPIRVBitOps.td - MLIR SPIR-V Bit Ops -*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains bit ops for the SPIR-V dialect. It corresponds // This file contains bit ops for the SPIR-V dialect. It corresponds
// to "3.32.13. Bit Instructions" of the SPIR-V specification. // to "3.32.13. Bit Instructions" of the SPIR-V specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_BIT_OPS #ifndef MLIR_DIALECT_SPIRV_IR_BIT_OPS
#define SPIRV_BIT_OPS #define MLIR_DIALECT_SPIRV_IR_BIT_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
class SPV_BitBinaryOp<string mnemonic, list<OpTrait> traits = []> : class SPV_BitBinaryOp<string mnemonic, list<OpTrait> traits = []> :
// All the operands type used in bit instructions are SPV_Integer. // All the operands type used in bit instructions are SPV_Integer.
SPV_BinaryOp<mnemonic, SPV_Integer, SPV_Integer, SPV_BinaryOp<mnemonic, SPV_Integer, SPV_Integer,
!listconcat(traits, !listconcat(traits,
[NoSideEffect, SameOperandsAndResultType])>; [NoSideEffect, SameOperandsAndResultType])>;
▲ Show 20 Lines • Show All 577 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%2 = spv.Not %0 : i32 %2 = spv.Not %0 : i32
%3 = spv.Not %1 : vector<4xi32> %3 = spv.Not %1 : vector<4xi32>
``` ```
}]; }];
} }
#endif // SPIRV_BIT_OPS #endif // MLIR_DIALECT_SPIRV_IR_BIT_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVCastOps.td.
//===-- SPIRVCastOps.td - MLIR SPIR-V Cast Ops -------*- tablegen -*-------===// //===-- SPIRVCastOps.td - MLIR SPIR-V Cast Ops -------*- tablegen -*-------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains cast ops for the SPIR-V dialect. It corresponds // This file contains cast ops for the SPIR-V dialect. It corresponds
// to "3.32.11. Conversion Instructions" of the SPIR-V specification. // to "3.32.11. Conversion Instructions" of the SPIR-V specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_CAST_OPS #ifndef MLIR_DIALECT_SPIRV_IR_CAST_OPS
#define SPIRV_CAST_OPS #define MLIR_DIALECT_SPIRV_IR_CAST_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
class SPV_CastOp<string mnemonic, Type resultType, Type operandType, class SPV_CastOp<string mnemonic, Type resultType, Type operandType,
list<OpTrait> traits = []> : list<OpTrait> traits = []> :
SPV_Op<mnemonic, SPV_Op<mnemonic,
!listconcat(traits, !listconcat(traits,
[NoSideEffect, SameOperandsAndResultShape])> { [NoSideEffect, SameOperandsAndResultShape])> {
let arguments = (ins let arguments = (ins
▲ Show 20 Lines • Show All 300 Lines • ▼ Show 20 Lines let description = [{
%1 = spv.UConvertOp %0 : i32 to i64 %1 = spv.UConvertOp %0 : i32 to i64
%3 = spv.UConvertOp %2 : vector<3xi32> to vector<3xi64> %3 = spv.UConvertOp %2 : vector<3xi32> to vector<3xi64>
``` ```
}]; }];
let verifier = [{ return verifyCastOp(this->getOperation(), false); }]; let verifier = [{ return verifyCastOp(this->getOperation(), false); }];
} }
#endif // SPIRV_CAST_OPS #endif // MLIR_DIALECT_SPIRV_IR_CAST_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVCompositeOps.td.
//===-- SPIRVCompositeOps.td - MLIR SPIR-V Composite Ops ---*- tablegen -*-===// //===-- SPIRVCompositeOps.td - MLIR SPIR-V Composite Ops ---*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains composite ops for SPIR-V dialect. It corresponds // This file contains composite ops for SPIR-V dialect. It corresponds
// to "3.32.12. Composite Instructions" of the SPIR-V spec. // to "3.32.12. Composite Instructions" of the SPIR-V spec.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_COMPOSITE_OPS #ifndef MLIR_DIALECT_SPIRV_IR_COMPOSITE_OPS
#define SPIRV_COMPOSITE_OPS #define MLIR_DIALECT_SPIRV_IR_COMPOSITE_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
// ----- // -----
def SPV_CompositeConstructOp : SPV_Op<"CompositeConstruct", [NoSideEffect]> { def SPV_CompositeConstructOp : SPV_Op<"CompositeConstruct", [NoSideEffect]> {
let summary = [{ let summary = [{
Construct a new composite object from a set of constituent objects that Construct a new composite object from a set of constituent objects that
will fully form it. will fully form it.
▲ Show 20 Lines • Show All 258 Lines • ▼ Show 20 Linesdef SPV_VectorInsertDynamicOp : SPV_Op<"VectorInsertDynamic",
let assemblyFormat = [{ let assemblyFormat = [{
$component `,` $vector `[` $index `]` attr-dict `:` type($vector) `,` type($index) $component `,` $vector `[` $index `]` attr-dict `:` type($vector) `,` type($index)
}]; }];
} }
// ----- // -----
#endif // SPIRV_COMPOSITE_OPS #endif // MLIR_DIALECT_SPIRV_IR_COMPOSITE_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td.
//===-- SPIRVControlFlowOps.td - SPIR-V Control Flow Ops ---*- tablegen -*-===// //===-- SPIRVControlFlowOps.td - SPIR-V Control Flow Ops ---*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains control flow ops for the SPIR-V dialect. It corresponds // This file contains control flow ops for the SPIR-V dialect. It corresponds
// to "3.32.17. Control-Flow Instructions" of the SPIR-V specification. // to "3.32.17. Control-Flow Instructions" of the SPIR-V specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_CONTROLFLOW_OPS #ifndef MLIR_DIALECT_SPIRV_IR_CONTROLFLOW_OPS
#define SPIRV_CONTROLFLOW_OPS #define MLIR_DIALECT_SPIRV_IR_CONTROLFLOW_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/CallInterfaces.td" include "mlir/Interfaces/CallInterfaces.td"
include "mlir/Interfaces/ControlFlowInterfaces.td" include "mlir/Interfaces/ControlFlowInterfaces.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
// ----- // -----
def SPV_BranchOp : SPV_Op<"Branch", [ def SPV_BranchOp : SPV_Op<"Branch", [
DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, NoSideEffect, DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, NoSideEffect,
▲ Show 20 Lines • Show All 441 Lines • ▼ Show 20 Linesdef SPV_SelectionOp : SPV_Op<"selection", [InFunctionScope]> {
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
let hasCanonicalizer = 1; let hasCanonicalizer = 1;
} }
#endif // SPIRV_CONTROLFLOW_OPS #endif // MLIR_DIALECT_SPIRV_IR_CONTROLFLOW_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVCooperativeMatrixOps.td.
//===- SPIRVCooperativeMatrixOps.td - cooperative matmul ---*- tablegen -*-===// //===- SPIRVCooperativeMatrixOps.td - cooperative matmul ---*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This is the op definition spec of cooperative matrix multiply extension ops. // This is the op definition spec of cooperative matrix multiply extension ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_COOPERATIVE_MATRIX_OPS #ifndef MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
#define SPIRV_COOPERATIVE_MATRIX_OPS #define MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
// ----- // -----
def SPV_CooperativeMatrixLengthNVOp : SPV_Op<"CooperativeMatrixLengthNV", def SPV_CooperativeMatrixLengthNVOp : SPV_Op<"CooperativeMatrixLengthNV",
[NoSideEffect]> { [NoSideEffect]> {
let summary = "See extension SPV_NV_cooperative_matrix"; let summary = "See extension SPV_NV_cooperative_matrix";
let description = [{ let description = [{
▲ Show 20 Lines • Show All 255 Lines • ▼ Show 20 Linesdef SPV_CooperativeMatrixStoreNVOp : SPV_Op<"CooperativeMatrixStoreNV", []> {
let verifier = [{ let verifier = [{
return verifyPointerAndCoopMatrixType(*this, pointer().getType(), return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
object().getType()); object().getType());
}]; }];
} }
// ----- // -----
#endif // SPIRV_COOPERATIVE_MATRIX_OPS #endif // MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVDialect.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVDialect.h.
//===- SPIRVDialect.h - MLIR SPIR-V dialect ---------------------*- C++ -*-===// //===- SPIRVDialect.h - MLIR SPIR-V dialect ---------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares the SPIR-V dialect in MLIR. // This file declares the SPIR-V dialect in MLIR.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_SPIRVDIALECT_H_ #ifndef MLIR_DIALECT_SPIRV_IR_SPIRVDIALECT_H_
#define MLIR_DIALECT_SPIRV_SPIRVDIALECT_H_ #define MLIR_DIALECT_SPIRV_IR_SPIRVDIALECT_H_
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
enum class Decoration : uint32_t; enum class Decoration : uint32_t;
} // end namespace spirv } // end namespace spirv
} // end namespace mlir } // end namespace mlir
#include "mlir/Dialect/SPIRV/SPIRVOpsDialect.h.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVOpsDialect.h.inc"
#endif // MLIR_DIALECT_SPIRV_SPIRVDIALECT_H_ #endif // MLIR_DIALECT_SPIRV_IR_SPIRVDIALECT_H_

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVEnums.h

  • This file was added.
//===- SPIRVEnums.h - MLIR SPIR-V Enums -------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file declares the C/C++ enums from SPIR-V spec.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_IR_SPIRVENUMS_H_
#define MLIR_DIALECT_SPIRV_IR_SPIRVENUMS_H_
#include "mlir/Support/LLVM.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/StringRef.h"
// Forward declare enum classes related to op availability. Their definitions
// are in the TableGen'erated SPIRVEnums.h.inc and can be referenced by other
// declarations in SPIRVEnums.h.inc.
namespace mlir {
namespace spirv {
enum class Version : uint32_t;
enum class Extension;
enum class Capability : uint32_t;
} // namespace spirv
} // namespace mlir
// Pull in all enum type definitions and utility function declarations
#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h.inc"
// Pull in all enum type availability query function declarations
#include "mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.h.inc"
namespace mlir {
namespace spirv {
/// Returns the implied extensions for the given version. These extensions are
/// incorporated into the current version so they are implicitly declared when
/// targeting the given version.
ArrayRef<Extension> getImpliedExtensions(Version version);
/// Returns the directly implied capabilities for the given capability. These
/// capabilities are implicitly declared by the given capability.
ArrayRef<Capability> getDirectImpliedCapabilities(Capability cap);
/// Returns the recursively implied capabilities for the given capability. These
/// capabilities are implicitly declared by the given capability. Compared to
/// the above function, this function collects implied capabilities recursively:
/// if an implicitly declared capability implicitly declares a third one, the
/// third one will also be returned.
SmallVector<Capability, 0> getRecursiveImpliedCapabilities(Capability cap);
} // end namespace spirv
} // end namespace mlir
#endif // MLIR_DIALECT_SPIRV_IR_SPIRVENUMS_H_

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVGLSLOps.td.
//===- SPIRVGLSLOps.td - GLSL extended insts spec file -----*- tablegen -*-===// //===- SPIRVGLSLOps.td - GLSL extended insts spec file -----*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This is the op definition spec of GLSL extension ops. // This is the op definition spec of GLSL extension ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_GLSL_OPS #ifndef MLIR_DIALECT_SPIRV_IR_GLSL_OPS
#define SPIRV_GLSL_OPS #define MLIR_DIALECT_SPIRV_IR_GLSL_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SPIR-V GLSL 4.50 opcode specification. // SPIR-V GLSL 4.50 opcode specification.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Base class for all GLSL ops. // Base class for all GLSL ops.
class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> : class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
▲ Show 20 Lines • Show All 942 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%2 = spv.GLSL.SClamp %x, %min, %max : si32 %2 = spv.GLSL.SClamp %x, %min, %max : si32
%3 = spv.GLSL.SClamp %x, %min, %max : vector<3xsi16> %3 = spv.GLSL.SClamp %x, %min, %max : vector<3xsi16>
``` ```
}]; }];
} }
#endif // SPIRV_GLSL_OPS #endif // MLIR_DIALECT_SPIRV_IR_GLSL_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVGroupOps.td.
//===-- SPIRVGroupOps.td - MLIR SPIR-V (Sub)Group Ops ------*- tablegen -*-===// //===-- SPIRVGroupOps.td - MLIR SPIR-V (Sub)Group Ops ------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains group and subgroup ops for the SPIR-V dialect. It // This file contains group and subgroup ops for the SPIR-V dialect. It
// corresponds to "3.32.21. Group and Subgroup Instructions" of the SPIR-V // corresponds to "3.32.21. Group and Subgroup Instructions" of the SPIR-V
// specification. // specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_GROUP_OPS #ifndef MLIR_DIALECT_SPIRV_IR_GROUP_OPS
#define SPIRV_GROUP_OPS #define MLIR_DIALECT_SPIRV_IR_GROUP_OPS
// ----- // -----
def SPV_GroupBroadcastOp : SPV_Op<"GroupBroadcast", def SPV_GroupBroadcastOp : SPV_Op<"GroupBroadcast",
[NoSideEffect, AllTypesMatch<["value", "result"]>]> { [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
let summary = [{ let summary = [{
Return the Value of the invocation identified by the local id LocalId to Return the Value of the invocation identified by the local id LocalId to
all invocations in the group. all invocations in the group.
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines let arguments = (ins
SPV_Type:$value SPV_Type:$value
); );
let results = (outs); let results = (outs);
} }
// ----- // -----
#endif // SPIRV_GROUP_OPS #endif // MLIR_DIALECT_SPIRV_IR_GROUP_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVLogicalOps.td.
//===-- SPIRVLogicalOps.td - MLIR SPIR-V Logical Ops -------*- tablegen -*-===// //===-- SPIRVLogicalOps.td - MLIR SPIR-V Logical Ops -------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains arithmetic ops for the SPIR-V dialect. It corresponds // This file contains arithmetic ops for the SPIR-V dialect. It corresponds
// to "3.32.15. Relational and Logical Instructions" of the SPIR-V spec. // to "3.32.15. Relational and Logical Instructions" of the SPIR-V spec.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_LOGICAL_OPS #ifndef MLIR_DIALECT_SPIRV_IR_LOGICAL_OPS
#define SPIRV_LOGICAL_OPS #define MLIR_DIALECT_SPIRV_IR_LOGICAL_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
class SPV_LogicalBinaryOp<string mnemonic, Type operandsType, class SPV_LogicalBinaryOp<string mnemonic, Type operandsType,
list<OpTrait> traits = []> : list<OpTrait> traits = []> :
// Result type is SPV_Bool. // Result type is SPV_Bool.
SPV_BinaryOp<mnemonic, SPV_Bool, operandsType, SPV_BinaryOp<mnemonic, SPV_Bool, operandsType,
!listconcat(traits, !listconcat(traits,
[NoSideEffect, SameTypeOperands, [NoSideEffect, SameTypeOperands,
▲ Show 20 Lines • Show All 971 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%4 = spv.ULessThanEqual %0, %1 : i32 %4 = spv.ULessThanEqual %0, %1 : i32
%5 = spv.ULessThanEqual %2, %3 : vector<4xi32> %5 = spv.ULessThanEqual %2, %3 : vector<4xi32>
``` ```
}]; }];
} }
#endif // SPIRV_LOGICAL_OPS #endif // MLIR_DIALECT_SPIRV_IR_LOGICAL_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td.
//===-- SPIRVMatrixOps.td - MLIR SPIR-V Matrix Ops ---------*- tablegen -*-===// //===-- SPIRVMatrixOps.td - MLIR SPIR-V Matrix Ops ---------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains matrix operations for the SPIR-V dialect. // This file contains matrix operations for the SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_MATRIX_OPS #ifndef MLIR_DIALECT_SPIRV_IR_MATRIX_OPS
#define SPIRV_MATRIX_OPS #define MLIR_DIALECT_SPIRV_IR_MATRIX_OPS
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
// ----- // -----
def SPV_MatrixTimesMatrixOp : SPV_Op<"MatrixTimesMatrix", [NoSideEffect]> { def SPV_MatrixTimesMatrixOp : SPV_Op<"MatrixTimesMatrix", [NoSideEffect]> {
let summary = "Linear-algebraic multiply of LeftMatrix X RightMatrix."; let summary = "Linear-algebraic multiply of LeftMatrix X RightMatrix.";
let description = [{ let description = [{
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines let assemblyFormat = [{
operands attr-dict `:` type($matrix) `->` type($result) operands attr-dict `:` type($matrix) `->` type($result)
}]; }];
let verifier = [{ return verifyTranspose(*this); }]; let verifier = [{ return verifyTranspose(*this); }];
} }
// ----- // -----
#endif // SPIRV_MATRIX_OPS #endif // MLIR_DIALECT_SPIRV_IR_MATRIX_OPS

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVModule.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVModule.h.
//===- SPIRVModule.h - SPIR-V Module Utilities ------------------*- C++ -*-===// //===- SPIRVModule.h - SPIR-V Module Utilities ------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_SPIRVMODULE_H #ifndef MLIR_DIALECT_SPIRV_IR_SPIRVMODULE_H
#define MLIR_DIALECT_SPIRV_SPIRVMODULE_H #define MLIR_DIALECT_SPIRV_IR_SPIRVMODULE_H
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/IR/OwningOpRef.h" #include "mlir/IR/OwningOpRef.h"
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
/// This class acts as an owning reference to a SPIR-V module, and will /// This class acts as an owning reference to a SPIR-V module, and will
/// automatically destroy the held module on destruction if the held module /// automatically destroy the held module on destruction if the held module
/// is valid. /// is valid.
// TODO: Remove this class in favor of using OwningOpRef directly. // TODO: Remove this class in favor of using OwningOpRef directly.
class OwningSPIRVModuleRef : public OwningOpRef<spirv::ModuleOp> { class OwningSPIRVModuleRef : public OwningOpRef<spirv::ModuleOp> {
public: public:
using OwningOpRef<spirv::ModuleOp>::OwningOpRef; using OwningOpRef<spirv::ModuleOp>::OwningOpRef;
}; };
} // end namespace spirv } // end namespace spirv
} // end namespace mlir } // end namespace mlir
#endif // MLIR_DIALECT_SPIRV_SPIRVMODULE_H #endif // MLIR_DIALECT_SPIRV_IR_SPIRVMODULE_H

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVNonUniformOps.td.
//===-- SPIRVNonUniformOps.td - MLIR SPIR-V NonUniform Ops -*- tablegen -*-===// //===-- SPIRVNonUniformOps.td - MLIR SPIR-V NonUniform Ops -*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains non-uniform ops for the SPIR-V dialect. It corresponds to // This file contains non-uniform ops for the SPIR-V dialect. It corresponds to
// "3.32.24. Non-Uniform Instructions" of the SPIR-V specification. // "3.32.24. Non-Uniform Instructions" of the SPIR-V specification.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_NON_UNIFORM_OPS #ifndef MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
#define SPIRV_NON_UNIFORM_OPS #define MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
class SPV_GroupNonUniformArithmeticOp<string mnemonic, Type type, class SPV_GroupNonUniformArithmeticOp<string mnemonic, Type type,
list<OpTrait> traits = []> : SPV_Op<mnemonic, traits> { list<OpTrait> traits = []> : SPV_Op<mnemonic, traits> {
let availability = [ let availability = [
MinVersion<SPV_V_1_3>, MinVersion<SPV_V_1_3>,
MaxVersion<SPV_V_1_5>, MaxVersion<SPV_V_1_5>,
Extension<[]>, Extension<[]>,
▲ Show 20 Lines • Show All 701 Lines • ▼ Show 20 Lines let description = [{
%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>
``` ```
}]; }];
} }
// ----- // -----
#endif // SPIRV_NON_UNIFORM_OPS #endif // MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVOCLOps.td.
//===- SPIRVOCLOps.td - OpenCL extended insts spec file ----*- tablegen -*-===// //===- SPIRVOCLOps.td - OpenCL extended insts spec file ----*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This is the op definition spec of OpenCL extension ops. // This is the op definition spec of OpenCL extension ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_OCL_OPS #ifndef MLIR_DIALECT_SPIRV_IR_OCL_OPS
#define SPIRV_OCL_OPS #define MLIR_DIALECT_SPIRV_IR_OCL_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SPIR-V OpenCL opcode specification. // SPIR-V OpenCL opcode specification.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Base class for all OpenCL ops. // Base class for all OpenCL ops.
class SPV_OCLOp<string mnemonic, int opcode, list<OpTrait> traits = []> : class SPV_OCLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits>; SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits>;
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines let description = [{
```mlir ```mlir
%2 = spv.OCL.s_abs %0 : i32 %2 = spv.OCL.s_abs %0 : i32
%3 = spv.OCL.s_abs %1 : vector<3xi16> %3 = spv.OCL.s_abs %1 : vector<3xi16>
``` ```
}]; }];
} }
#endif // SPIRV_OCL_OPS #endif // MLIR_DIALECT_SPIRV_IR_OCL_OPS

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h.
//===- SPIRVOps.h - MLIR SPIR-V operations ----------------------*- C++ -*-===// //===- SPIRVOps.h - MLIR SPIR-V operations ----------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares the operations in the SPIR-V dialect. // This file declares the operations in the SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_SPIRVOPS_H_ #ifndef MLIR_DIALECT_SPIRV_IR_SPIRVOPS_H_
#define MLIR_DIALECT_SPIRV_SPIRVOPS_H_ #define MLIR_DIALECT_SPIRV_IR_SPIRVOPS_H_
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Interfaces/ControlFlowInterfaces.h" #include "mlir/Interfaces/ControlFlowInterfaces.h"
#include "mlir/Interfaces/SideEffectInterfaces.h" #include "mlir/Interfaces/SideEffectInterfaces.h"
#include "llvm/Support/PointerLikeTypeTraits.h" #include "llvm/Support/PointerLikeTypeTraits.h"
namespace mlir { namespace mlir {
class OpBuilder; class OpBuilder;
namespace spirv { namespace spirv {
class VerCapExtAttr; class VerCapExtAttr;
// TableGen'erated operation interfaces for querying versions, extensions, and // TableGen'erated operation interfaces for querying versions, extensions, and
// capabilities. // capabilities.
#include "mlir/Dialect/SPIRV/SPIRVAvailability.h.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.h.inc"
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
// TablenGen'erated operation declarations. // TablenGen'erated operation declarations.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/SPIRV/SPIRVOps.h.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h.inc"
namespace mlir {
namespace spirv {
// TableGen'erated helper functions.
//
// Get the name used in the Op to refer to an enum value of the given
// `EnumClass`.
// template <typename EnumClass> StringRef attributeName();
//
#include "mlir/Dialect/SPIRV/SPIRVOpUtils.inc"
} // end namespace spirv
} // end namespace mlir
namespace llvm { namespace llvm {
/// spirv::Function ops hash just like pointers. /// spirv::Function ops hash just like pointers.
template <> template <>
struct DenseMapInfo<mlir::spirv::FuncOp> { struct DenseMapInfo<mlir::spirv::FuncOp> {
static mlir::spirv::FuncOp getEmptyKey() { static mlir::spirv::FuncOp getEmptyKey() {
auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey(); auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
Show All 21 Linespublic:
static inline mlir::spirv::FuncOp getFromVoidPointer(void *P) { static inline mlir::spirv::FuncOp getFromVoidPointer(void *P) {
return mlir::spirv::FuncOp::getFromOpaquePointer(P); return mlir::spirv::FuncOp::getFromOpaquePointer(P);
} }
static constexpr int NumLowBitsAvailable = 3; static constexpr int NumLowBitsAvailable = 3;
}; };
} // namespace llvm } // namespace llvm
#endif // MLIR_DIALECT_SPIRV_SPIRVOPS_H_ #endif // MLIR_DIALECT_SPIRV_IR_SPIRVOPS_H_

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td.
Show All 12 Lines
// Note that for each op in this file and the included files for specific op // Note that for each op in this file and the included files for specific op
// categories, we use a tool to automatically generate certain sections in its // categories, we use a tool to automatically generate certain sections in its
// definition: basic structure, summary, description. So modifications to these // definition: basic structure, summary, description. So modifications to these
// sections will not be respected. Modifications to op traits, arguments, // sections will not be respected. Modifications to op traits, arguments,
// results, and sections after the results are retained. Besides, ops must be // results, and sections after the results are retained. Besides, ops must be
// separated via the '// -----' marker. // separated via the '// -----' marker.
#ifndef SPIRV_OPS #ifndef MLIR_DIALECT_SPIRV_IR_OPS
#define SPIRV_OPS #define MLIR_DIALECT_SPIRV_IR_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/Dialect/SPIRV/SPIRVArithmeticOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVArithmeticOps.td"
include "mlir/Dialect/SPIRV/SPIRVAtomicOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVAtomicOps.td"
include "mlir/Dialect/SPIRV/SPIRVBitOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVBitOps.td"
include "mlir/Dialect/SPIRV/SPIRVCastOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVCastOps.td"
include "mlir/Dialect/SPIRV/SPIRVCompositeOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVCompositeOps.td"
include "mlir/Dialect/SPIRV/SPIRVControlFlowOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVControlFlowOps.td"
include "mlir/Dialect/SPIRV/SPIRVCooperativeMatrixOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVCooperativeMatrixOps.td"
include "mlir/Dialect/SPIRV/SPIRVGLSLOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td"
include "mlir/Dialect/SPIRV/SPIRVGroupOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVGroupOps.td"
include "mlir/Dialect/SPIRV/SPIRVLogicalOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVLogicalOps.td"
include "mlir/Dialect/SPIRV/SPIRVMatrixOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVMatrixOps.td"
include "mlir/Dialect/SPIRV/SPIRVNonUniformOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td"
include "mlir/Dialect/SPIRV/SPIRVOCLOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td"
include "mlir/Dialect/SPIRV/SPIRVStructureOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
// ----- // -----
def SPV_AccessChainOp : SPV_Op<"AccessChain", [NoSideEffect]> { def SPV_AccessChainOp : SPV_Op<"AccessChain", [NoSideEffect]> {
let summary = [{ let summary = [{
Create a pointer into a composite object that can be used with OpLoad Create a pointer into a composite object that can be used with OpLoad
and OpStore. and OpStore.
▲ Show 20 Lines • Show All 477 Lines • ▼ Show 20 Linesdef SPV_VariableOp : SPV_Op<"Variable", []> {
let results = (outs let results = (outs
SPV_AnyPtr:$pointer SPV_AnyPtr:$pointer
); );
} }
// ----- // -----
#endif // SPIRV_OPS #endif // MLIR_DIALECT_SPIRV_IR_OPS

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td.
//===-- SPIRVStructureOps.td - MLIR SPIR-V Structure Ops ---*- tablegen -*-===// //===-- SPIRVStructureOps.td - MLIR SPIR-V Structure Ops ---*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains ops for defining the SPIR-V structure: module, function, // This file contains ops for defining the SPIR-V structure: module, function,
// and module-level operations. The representational form of these ops deviate // and module-level operations. The representational form of these ops deviate
// from the SPIR-V binary format in order to utilize MLIR mechanisms. // from the SPIR-V binary format in order to utilize MLIR mechanisms.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_STRUCTURE_OPS #ifndef MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS
#define SPIRV_STRUCTURE_OPS #define MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
include "mlir/IR/SymbolInterfaces.td" include "mlir/IR/SymbolInterfaces.td"
include "mlir/Interfaces/CallInterfaces.td" include "mlir/Interfaces/CallInterfaces.td"
include "mlir/Interfaces/SideEffectInterfaces.td" include "mlir/Interfaces/SideEffectInterfaces.td"
// ----- // -----
def SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> { def SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> {
let summary = "Get the address of a global variable."; let summary = "Get the address of a global variable.";
▲ Show 20 Lines • Show All 702 Lines • ▼ Show 20 Linesdef SPV_SpecConstantOperationOp : SPV_Op<"SpecConstantOperation", [
let hasOpcode = 0; let hasOpcode = 0;
let autogenSerialization = 0; let autogenSerialization = 0;
} }
// ----- // -----
#endif // SPIRV_STRUCTURE_OPS #endif // MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h.
//===- SPIRVTypes.h - MLIR SPIR-V Types -------------------------*- C++ -*-===// //===- SPIRVTypes.h - MLIR SPIR-V Types -------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares the types in the SPIR-V dialect. // This file declares the types in the SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_SPIRVTYPES_H_ #ifndef MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_
#define MLIR_DIALECT_SPIRV_SPIRVTYPES_H_ #define MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_
#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Diagnostics.h" #include "mlir/IR/Diagnostics.h"
#include "mlir/IR/Location.h" #include "mlir/IR/Location.h"
#include "mlir/IR/TypeSupport.h" #include "mlir/IR/TypeSupport.h"
#include "mlir/IR/Types.h" #include "mlir/IR/Types.h"
#include <tuple> #include <tuple>
// Forward declare enum classes related to op availability. Their definitions
// are in the TableGen'erated SPIRVEnums.h.inc and can be referenced by other
// declarations in SPIRVEnums.h.inc.
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
enum class Version : uint32_t;
enum class Extension;
enum class Capability : uint32_t;
} // namespace spirv
} // namespace mlir
// Pull in all enum type definitions and utility function declarations
#include "mlir/Dialect/SPIRV/SPIRVEnums.h.inc"
// Pull in all enum type availability query function declarations
#include "mlir/Dialect/SPIRV/SPIRVEnumAvailability.h.inc"
namespace mlir {
namespace spirv {
/// Returns the implied extensions for the given version. These extensions are
/// incorporated into the current version so they are implicitly declared when
/// targeting the given version.
ArrayRef<Extension> getImpliedExtensions(Version version);
/// Returns the directly implied capabilities for the given capability. These
/// capabilities are implicitly declared by the given capability.
ArrayRef<Capability> getDirectImpliedCapabilities(Capability cap);
/// Returns the recursively implied capabilities for the given capability. These
/// capabilities are implicitly declared by the given capability. Compared to
/// the above function, this function collects implied capabilities recursively:
/// if an implicitly declared capability implicitly declares a third one, the
/// third one will also be returned.
SmallVector<Capability, 0> getRecursiveImpliedCapabilities(Capability cap);
namespace detail { namespace detail {
struct ArrayTypeStorage; struct ArrayTypeStorage;
struct CooperativeMatrixTypeStorage; struct CooperativeMatrixTypeStorage;
struct ImageTypeStorage; struct ImageTypeStorage;
struct MatrixTypeStorage; struct MatrixTypeStorage;
struct PointerTypeStorage; struct PointerTypeStorage;
struct RuntimeArrayTypeStorage; struct RuntimeArrayTypeStorage;
▲ Show 20 Lines • Show All 311 Lines • ▼ Show 20 Linespublic:
// Returns in `memberDecorations` the Decorations (apart from Offset) // Returns in `memberDecorations` the Decorations (apart from Offset)
// associated with all members of the StructType. // associated with all members of the StructType.
void getMemberDecorations(SmallVectorImpl<StructType::MemberDecorationInfo> void getMemberDecorations(SmallVectorImpl<StructType::MemberDecorationInfo>
&memberDecorations) const; &memberDecorations) const;
// Returns in `decorationsInfo` all the Decorations (apart from Offset) // Returns in `decorationsInfo` all the Decorations (apart from Offset)
// associated with the `i`-th member of the StructType. // associated with the `i`-th member of the StructType.
void getMemberDecorations(unsigned i, void getMemberDecorations(
SmallVectorImpl<StructType::MemberDecorationInfo> unsigned i,
&decorationsInfo) const; SmallVectorImpl<StructType::MemberDecorationInfo> &decorationsInfo) const;
/// Sets the contents of an incomplete identified StructType. This method must /// Sets the contents of an incomplete identified StructType. This method must
/// be called only for identified StructTypes and it must be called only once /// be called only for identified StructTypes and it must be called only once
/// per instance. Otherwise, failure() is returned. /// per instance. Otherwise, failure() is returned.
LogicalResult LogicalResult
trySetBody(ArrayRef<Type> memberTypes, ArrayRef<OffsetInfo> offsetInfo = {}, trySetBody(ArrayRef<Type> memberTypes, ArrayRef<OffsetInfo> offsetInfo = {},
ArrayRef<MemberDecorationInfo> memberDecorations = {}); ArrayRef<MemberDecorationInfo> memberDecorations = {});
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
Optional<StorageClass> storage = llvm::None); Optional<StorageClass> storage = llvm::None);
void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities, void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
Optional<StorageClass> storage = llvm::None); Optional<StorageClass> storage = llvm::None);
}; };
} // end namespace spirv } // end namespace spirv
} // end namespace mlir } // end namespace mlir
#endif // MLIR_DIALECT_SPIRV_SPIRVTYPES_H_ #endif // MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_

mlir/include/mlir/Dialect/SPIRV/IR/TargetAndABI.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/TargetAndABI.h.
//===- TargetAndABI.h - SPIR-V target and ABI utilities --------*- C++ -*-===// //===- TargetAndABI.h - SPIR-V target and ABI utilities --------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares utilities for SPIR-V target and shader interface ABI. // This file declares utilities for SPIR-V target and shader interface ABI.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_TARGETANDABI_H #ifndef MLIR_DIALECT_SPIRV_IR_TARGETANDABI_H
#define MLIR_DIALECT_SPIRV_TARGETANDABI_H #define MLIR_DIALECT_SPIRV_IR_TARGETANDABI_H
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Support/LLVM.h" #include "mlir/Support/LLVM.h"
#include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallSet.h"
namespace mlir { namespace mlir {
class Operation; class Operation;
namespace spirv { namespace spirv {
enum class StorageClass : uint32_t; enum class StorageClass : uint32_t;
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
/// Returns memory model selected based on target environment. /// Returns memory model selected based on target environment.
/// Returns failure if it cannot be selected. /// Returns failure if it cannot be selected.
FailureOr<MemoryModel> getMemoryModel(TargetEnvAttr targetAttr); FailureOr<MemoryModel> getMemoryModel(TargetEnvAttr targetAttr);
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_TARGETANDABI_H #endif // MLIR_DIALECT_SPIRV_IR_TARGETANDABI_H

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

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/TargetAndABI.td.
Show All 12 Lines
// the execution environment regarding the resources that are used in the SPIR-V // the execution environment regarding the resources that are used in the SPIR-V
// module and get populated with data via the client API. The shader interface // module and get populated with data via the client API. The shader interface
// (or ABI) is passed into SPIR-V lowering path via attributes defined in this // (or ABI) is passed into SPIR-V lowering path via attributes defined in this
// file. A compilation flow targeting SPIR-V is expected to attach such // file. A compilation flow targeting SPIR-V is expected to attach such
// attributes to resources and other suitable places. // attributes to resources and other suitable places.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef SPIRV_TARGET_AND_ABI #ifndef MLIR_DIALECT_SPIRV_IR_TARGET_AND_ABI
#define SPIRV_TARGET_AND_ABI #define MLIR_DIALECT_SPIRV_IR_TARGET_AND_ABI
include "mlir/Dialect/SPIRV/SPIRVBase.td" include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
// For entry functions, this attribute specifies information related to entry // For entry functions, this attribute specifies information related to entry
// points in the generated SPIR-V module: // points in the generated SPIR-V module:
// 1) WorkGroup Size. // 1) WorkGroup Size.
def SPV_EntryPointABIAttr : StructAttr<"EntryPointABIAttr", SPIRV_Dialect, [ def SPV_EntryPointABIAttr : StructAttr<"EntryPointABIAttr", SPIRV_Dialect, [
StructFieldAttr<"local_size", I32ElementsAttr> StructFieldAttr<"local_size", I32ElementsAttr>
]>; ]>;
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesdef SPV_ResourceLimitsAttr : StructAttr<"ResourceLimitsAttr", SPIRV_Dialect, [
// The configurations of cooperative matrix operations // The configurations of cooperative matrix operations
// supported. Default is an empty list. // supported. Default is an empty list.
StructFieldAttr< StructFieldAttr<
"cooperative_matrix_properties_nv", "cooperative_matrix_properties_nv",
DefaultValuedAttr<SPV_CooperativeMatrixPropertiesNVArrayAttr, "{}">> DefaultValuedAttr<SPV_CooperativeMatrixPropertiesNVArrayAttr, "{}">>
]>; ]>;
#endif // SPIRV_TARGET_AND_ABI #endif // MLIR_DIALECT_SPIRV_IR_TARGET_AND_ABI

mlir/include/mlir/Dialect/SPIRV/LayoutUtils.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/Utils/LayoutUtils.h.

mlir/include/mlir/Dialect/SPIRV/Linking/ModuleCombiner.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/ModuleCombiner.h.
//===- ModuleCombiner.h - MLIR SPIR-V Module Combiner -----------*- C++ -*-===// //===- ModuleCombiner.h - MLIR SPIR-V Module Combiner -----------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares the entry point to the SPIR-V module combiner library. // This file declares the entry point to the SPIR-V module combiner library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_MODULECOMBINER_H_ #ifndef MLIR_DIALECT_SPIRV_LINKING_MODULECOMBINER_H_
#define MLIR_DIALECT_SPIRV_MODULECOMBINER_H_ #define MLIR_DIALECT_SPIRV_LINKING_MODULECOMBINER_H_
#include "mlir/Dialect/SPIRV/SPIRVModule.h" #include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
namespace mlir { namespace mlir {
class OpBuilder; class OpBuilder;
namespace spirv { namespace spirv {
class ModuleOp; class ModuleOp;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
OwningSPIRVModuleRef OwningSPIRVModuleRef
combine(llvm::MutableArrayRef<ModuleOp> modules, combine(llvm::MutableArrayRef<ModuleOp> modules,
OpBuilder &combinedModuleBuilder, OpBuilder &combinedModuleBuilder,
llvm::function_ref<void(ModuleOp, StringRef, StringRef)> llvm::function_ref<void(ModuleOp, StringRef, StringRef)>
symbRenameListener); symbRenameListener);
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_MODULECOMBINER_H_ #endif // MLIR_DIALECT_SPIRV_LINKING_MODULECOMBINER_H_

mlir/include/mlir/Dialect/SPIRV/ModuleCombiner.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/Linking/ModuleCombiner.h.

mlir/include/mlir/Dialect/SPIRV/ParserUtils.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/ParserUtils.h.

mlir/include/mlir/Dialect/SPIRV/Passes.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h.

mlir/include/mlir/Dialect/SPIRV/Passes.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVArithmeticOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVArithmeticOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVAtomicOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAtomicOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h.

mlir/include/mlir/Dialect/SPIRV/SPIRVAvailability.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVBitOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBitOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVCastOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCastOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVCompositeOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCompositeOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVControlFlowOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVCooperativeMatrixOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCooperativeMatrixOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVDialect.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVDialect.h.

mlir/include/mlir/Dialect/SPIRV/SPIRVGLSLOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVGroupOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGroupOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVLogicalOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVLogicalOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h.

mlir/include/mlir/Dialect/SPIRV/SPIRVMatrixOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMatrixOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVModule.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVModule.h.

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

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVOCLOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.h.

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.td.

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

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td.

mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h.

mlir/include/mlir/Dialect/SPIRV/TargetAndABI.h

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/TargetAndABI.h.

mlir/include/mlir/Dialect/SPIRV/TargetAndABI.td

  • This file was moved to mlir/include/mlir/Dialect/SPIRV/IR/TargetAndABI.td.

mlir/include/mlir/Dialect/SPIRV/Transforms/CMakeLists.txt

  • This file was added.
set(LLVM_TARGET_DEFINITIONS Passes.td)
mlir_tablegen(Passes.h.inc -gen-pass-decls -name SPIRV)
add_public_tablegen_target(MLIRSPIRVPassIncGen)
add_dependencies(mlir-headers MLIRSPIRVPassIncGen)
add_mlir_doc(Passes -gen-pass-doc SPIRVPasses ./)

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/Passes.h.
//===- Passes.h - SPIR-V pass entry points ----------------------*- C++ -*-===// //===- Passes.h - SPIR-V pass entry points ----------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This header file defines prototypes that expose pass constructors. // This header file defines prototypes that expose pass constructors.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_PASSES_H_ #ifndef MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES_H_
#define MLIR_DIALECT_SPIRV_PASSES_H_ #define MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES_H_
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
class ModuleOp; class ModuleOp;
//===----------------------------------------------------------------------===//
// Passes
//===----------------------------------------------------------------------===//
/// Creates a module pass that converts composite types used by objects in the /// Creates a module pass that converts composite types used by objects in the
/// StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage /// StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage
/// classes with layout information. /// classes with layout information.
/// Right now this pass only supports Vulkan layout rules. /// Right now this pass only supports Vulkan layout rules.
std::unique_ptr<OperationPass<mlir::ModuleOp>> std::unique_ptr<OperationPass<mlir::ModuleOp>>
createDecorateSPIRVCompositeTypeLayoutPass(); createDecorateSPIRVCompositeTypeLayoutPass();
/// Creates an operation pass that deduces and attaches the minimal version/ /// Creates an operation pass that deduces and attaches the minimal version/
Show All 21 Lines
std::unique_ptr<OperationPass<spirv::ModuleOp>> createRewriteInsertsPass(); std::unique_ptr<OperationPass<spirv::ModuleOp>> createRewriteInsertsPass();
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Registration // Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Generate the code for registering passes. /// Generate the code for registering passes.
#define GEN_PASS_REGISTRATION #define GEN_PASS_REGISTRATION
#include "mlir/Dialect/SPIRV/Passes.h.inc" #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_PASSES_H_ #endif // MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.td

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/Passes.td.
//===-- Passes.td - SPIRV pass definition file -------------*- tablegen -*-===// //===-- Passes.td - SPIRV pass definition file -------------*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_PASSES #ifndef MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
#define MLIR_DIALECT_SPIRV_PASSES #define MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
include "mlir/Pass/PassBase.td" include "mlir/Pass/PassBase.td"
def SPIRVCompositeTypeLayout def SPIRVCompositeTypeLayout
: Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> { : Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> {
let summary = "Decorate SPIR-V composite type with layout info"; let summary = "Decorate SPIR-V composite type with layout info";
let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()"; let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
} }
Show All 10 Lines
} }
def SPIRVUpdateVCE : Pass<"spirv-update-vce", "spirv::ModuleOp"> { def SPIRVUpdateVCE : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
let summary = "Deduce and attach minimal (version, capabilities, extensions) " let summary = "Deduce and attach minimal (version, capabilities, extensions) "
"requirements to spv.module ops"; "requirements to spv.module ops";
let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()"; let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()";
} }
#endif // MLIR_DIALECT_SPIRV_PASSES #endif // MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h.
//===- SPIRVLowering.h - SPIR-V lowering utilities -------------*- C++ -*-===// //===- SPIRVConversion.h - SPIR-V Conversion Utilities ----------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Defines utilities to use while targeting SPIR-V dialect. // Defines utilities to use while converting to the SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_SPIRVLOWERING_H #ifndef MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: header guard does not follow preferred style [llvm-header-guard]
not useful

Lint: Pre-merge checks: clang-tidy: warning: header guard does not follow preferred style [llvm-header-guard] [[https…
#define MLIR_DIALECT_SPIRV_SPIRVLOWERING_H #define MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallSet.h"
namespace mlir { namespace mlir {
/// Type conversion from builtin types to SPIR-V types for shader interface. /// Type conversion from builtin types to SPIR-V types for shader interface.
/// ///
/// Non-32-bit scalar types require special hardware support that may not exist /// Non-32-bit scalar types require special hardware support that may not exist
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
/// Sets the InterfaceVarABIAttr and EntryPointABIAttr for a function and its /// Sets the InterfaceVarABIAttr and EntryPointABIAttr for a function and its
/// arguments. /// arguments.
LogicalResult setABIAttrs(spirv::FuncOp funcOp, LogicalResult setABIAttrs(spirv::FuncOp funcOp,
EntryPointABIAttr entryPointInfo, EntryPointABIAttr entryPointInfo,
ArrayRef<InterfaceVarABIAttr> argABIInfo); ArrayRef<InterfaceVarABIAttr> argABIInfo);
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_SPIRVLOWERING_H #endif // MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H

mlir/include/mlir/Dialect/SPIRV/Utils/LayoutUtils.h

  • This file was moved from mlir/include/mlir/Dialect/SPIRV/LayoutUtils.h.
//===-- LayoutUtils.h - Decorate composite type with layout information ---===// //===-- LayoutUtils.h - Vulkan Layout Util functions ------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines utilities used to get alignment and layout information for // This file defines utilities used to get alignment and layout information for
// types in SPIR-V dialect. // types in SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_DIALECT_SPIRV_LAYOUTUTILS_H_
#define MLIR_DIALECT_SPIRV_LAYOUTUTILS_H_ #ifndef MLIR_DIALECT_SPIRV_UTILS_LAYOUTUTILS_H_
#define MLIR_DIALECT_SPIRV_UTILS_LAYOUTUTILS_H_
#include <cstdint> #include <cstdint>
namespace mlir { namespace mlir {
class Type; class Type;
class VectorType; class VectorType;
namespace spirv { namespace spirv {
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines static spirv::StructType decorateType(spirv::StructType structType,
Size &size, Size &alignment); Size &size, Size &alignment);
/// Calculates the alignment for the given scalar type. /// Calculates the alignment for the given scalar type.
static Size getScalarTypeAlignment(Type scalarType); static Size getScalarTypeAlignment(Type scalarType);
}; };
} // namespace mlir } // namespace mlir
#endif // MLIR_DIALECT_SPIRV_LAYOUTUTILS_H_ #endif // MLIR_DIALECT_SPIRV_UTILS_LAYOUTUTILS_H_

mlir/include/mlir/InitAllDialects.h

Show All 28 Lines
#include "mlir/Dialect/Linalg/IR/LinalgOps.h" #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
#include "mlir/Dialect/OpenACC/OpenACC.h" #include "mlir/Dialect/OpenACC/OpenACC.h"
#include "mlir/Dialect/OpenMP/OpenMPDialect.h" #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
#include "mlir/Dialect/PDL/IR/PDL.h" #include "mlir/Dialect/PDL/IR/PDL.h"
#include "mlir/Dialect/PDLInterp/IR/PDLInterp.h" #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
#include "mlir/Dialect/Quant/QuantOps.h" #include "mlir/Dialect/Quant/QuantOps.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SDBM/SDBMDialect.h" #include "mlir/Dialect/SDBM/SDBMDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/Shape/IR/Shape.h" #include "mlir/Dialect/Shape/IR/Shape.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h" #include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/Dialect/Tosa/IR/TosaOps.h" #include "mlir/Dialect/Tosa/IR/TosaOps.h"
#include "mlir/Dialect/Vector/VectorOps.h" #include "mlir/Dialect/Vector/VectorOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
namespace mlir { namespace mlir {
Show All 36 Lines

mlir/include/mlir/InitAllPasses.h

Show All 16 Lines
#include "mlir/Conversion/Passes.h" #include "mlir/Conversion/Passes.h"
#include "mlir/Dialect/Affine/Passes.h" #include "mlir/Dialect/Affine/Passes.h"
#include "mlir/Dialect/Async/Passes.h" #include "mlir/Dialect/Async/Passes.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
#include "mlir/Dialect/LLVMIR/Transforms/Passes.h" #include "mlir/Dialect/LLVMIR/Transforms/Passes.h"
#include "mlir/Dialect/Linalg/Passes.h" #include "mlir/Dialect/Linalg/Passes.h"
#include "mlir/Dialect/Quant/Passes.h" #include "mlir/Dialect/Quant/Passes.h"
#include "mlir/Dialect/SCF/Passes.h" #include "mlir/Dialect/SCF/Passes.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Dialect/Shape/Transforms/Passes.h" #include "mlir/Dialect/Shape/Transforms/Passes.h"
#include "mlir/Dialect/StandardOps/Transforms/Passes.h" #include "mlir/Dialect/StandardOps/Transforms/Passes.h"
#include "mlir/Dialect/Tensor/Transforms/Passes.h" #include "mlir/Dialect/Tensor/Transforms/Passes.h"
#include "mlir/Dialect/Tosa/Transforms/Passes.h" #include "mlir/Dialect/Tosa/Transforms/Passes.h"
#include "mlir/Transforms/Passes.h" #include "mlir/Transforms/Passes.h"
#include <cstdlib> #include <cstdlib>
Show All 34 Lines

mlir/include/mlir/Target/SPIRV/SPIRVBinaryUtils.h

//===- SPIRVBinaryUtils.cpp - SPIR-V Binary Module Utils --------*- C++ -*-===// //===- SPIRVBinaryUtils.cpp - SPIR-V Binary Module Utils --------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file declares common utilities for SPIR-V binary module. // This file declares common utilities for SPIR-V binary module.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef MLIR_TARGET_SPIRV_BINARY_UTILS_H_ #ifndef MLIR_TARGET_SPIRV_BINARY_UTILS_H_
#define MLIR_TARGET_SPIRV_BINARY_UTILS_H_ #define MLIR_TARGET_SPIRV_BINARY_UTILS_H_
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include <cstdint> #include <cstdint>
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
/// SPIR-V binary header word count /// SPIR-V binary header word count
Show All 23 Lines

mlir/lib/Conversion/GPUToSPIRV/CMakeLists.txt

Show All 10 Linesadd_mlir_conversion_library(MLIRGPUToSPIRVTransforms
MLIRGPUToSPIRVIncGen MLIRGPUToSPIRVIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRGPU MLIRGPU
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSCFToSPIRV MLIRSCFToSPIRV
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion
MLIRStandard MLIRStandard
MLIRStandardToSPIRVTransforms MLIRStandardToSPIRVTransforms
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

//===- ConvertGPUToSPIRV.cpp - Convert GPU ops to SPIR-V dialect ----------===// //===- ConvertGPUToSPIRV.cpp - Convert GPU ops to SPIR-V dialect ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the conversion patterns from GPU ops to SPIR-V dialect. // This file implements the conversion patterns from GPU ops to SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h" #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
using namespace mlir; using namespace mlir;
static constexpr const char kSPIRVModule[] = "__spv__"; static constexpr const char kSPIRVModule[] = "__spv__";
namespace { namespace {
/// Pattern lowering GPU block/thread size/id to loading SPIR-V invocation /// Pattern lowering GPU block/thread size/id to loading SPIR-V invocation
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.cpp

Show All 12 Lines
#include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h" #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h"
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h" #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// Pass to lower GPU Dialect to SPIR-V. The pass only converts the gpu.func ops /// Pass to lower GPU Dialect to SPIR-V. The pass only converts the gpu.func ops
/// inside gpu.module ops. i.e., the function that are referenced in /// inside gpu.module ops. i.e., the function that are referenced in
/// gpu.launch_func ops. For each such function /// gpu.launch_func ops. For each such function
/// ///
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.td

//===-- GPUToSPIRV.td - GPU to SPIR-V Dialect Lowerings ----*- tablegen -*-===// //===-- GPUToSPIRV.td - GPU to SPIR-V Dialect Lowerings ----*- tablegen -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains patterns to lower GPU dialect ops to to SPIR-V ops. // This file contains patterns to lower GPU dialect ops to to SPIR-V ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef CONVERT_GPU_TO_SPIRV #ifndef MLIR_CONVERSION_GPU_TO_SPIRV
#define CONVERT_GPU_TO_SPIRV #define MLIR_CONVERSION_GPU_TO_SPIRV
include "mlir/Dialect/GPU/GPUOps.td" include "mlir/Dialect/GPU/GPUOps.td"
include "mlir/Dialect/SPIRV/SPIRVStructureOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td"
def : Pat<(GPU_ModuleEndOp), (SPV_ModuleEndOp)>; def : Pat<(GPU_ModuleEndOp), (SPV_ModuleEndOp)>;
#endif // CONVERT_GPU_TO_SPIRV #endif // MLIR_CONVERSION_GPU_TO_SPIRV

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

Show All 10 Lines
// using `spirv::serialize` function, attaches binary data and entry point name // using `spirv::serialize` function, attaches binary data and entry point name
// as an attributes to vulkan launch call op. // as an attributes to vulkan launch call op.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/Attributes.h" #include "mlir/IR/Attributes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/Target/SPIRV/Serialization.h" #include "mlir/Target/SPIRV/Serialization.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToSPIRV/CMakeLists.txt

Show All 9 Linesadd_mlir_conversion_library(MLIRLinalgToSPIRVTransforms
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRIR MLIRIR
MLIRLinalg MLIRLinalg
MLIRLinalgUtils MLIRLinalgUtils
MLIRPass MLIRPass
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion
MLIRSupport MLIRSupport
) )

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

//===- LinalgToSPIRV.cpp - Linalg to SPIR-V dialect conversion ------------===// //===- LinalgToSPIRV.cpp - Linalg to SPIR-V dialect conversion ------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
#include "mlir/Dialect/Linalg/IR/LinalgOps.h" #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
#include "mlir/Dialect/Linalg/Utils/Utils.h" #include "mlir/Dialect/Linalg/Utils/Utils.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/Dialect/Utils/StructuredOpsUtils.h" #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
#include "mlir/IR/AffineExpr.h" #include "mlir/IR/AffineExpr.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Utilities // Utilities
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

//===- LinalgToSPIRVPass.cpp - Linalg to SPIR-V conversion pass -----------===// //===- LinalgToSPIRVPass.cpp - Linalg to SPIR-V conversion pass -----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h" #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// A pass converting MLIR Linalg ops into SPIR-V ops. /// A pass converting MLIR Linalg ops into SPIR-V ops.
class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> { class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
void runOnOperation() override; void runOnOperation() override;
}; };
Show All 29 Lines

mlir/lib/Conversion/SCFToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRSCFToSPIRV add_mlir_conversion_library(MLIRSCFToSPIRV
SCFToSPIRV.cpp SCFToSPIRV.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToSPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SCFToSPIRV
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRAffine MLIRAffine
MLIRAffineToStandard MLIRAffineToStandard
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion
MLIRIR MLIRIR
MLIRLinalg MLIRLinalg
MLIRPass MLIRPass
MLIRStandard MLIRStandard
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp

//===- SCFToSPIRV.cpp - Convert SCF ops to SPIR-V dialect -----------------===// //===- SCFToSPIRV.cpp - Convert SCF ops to SPIR-V dialect -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the conversion patterns from SCF ops to SPIR-V dialect. // This file implements the conversion patterns from SCF ops to SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h" #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
using namespace mlir; using namespace mlir;
namespace mlir { namespace mlir {
struct ScfToSPIRVContextImpl { struct ScfToSPIRVContextImpl {
// Map between the spirv region control flow operation (spv.loop or // Map between the spirv region control flow operation (spv.loop or
// spv.selection) to the VariableOp created to store the region results. The // spv.selection) to the VariableOp created to store the region results. The
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

mlir/lib/Conversion/SPIRVToLLVM/CMakeLists.txt

add_mlir_conversion_library(MLIRSPIRVToLLVM add_mlir_conversion_library(MLIRSPIRVToLLVM
ConvertLaunchFuncToLLVMCalls.cpp ConvertLaunchFuncToLLVMCalls.cpp
ConvertSPIRVToLLVM.cpp ConvertSPIRVToLLVM.cpp
ConvertSPIRVToLLVMPass.cpp ConvertSPIRVToLLVMPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SPIRVToLLVM ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/SPIRVToLLVM
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRGPU MLIRGPU
MLIRSPIRV MLIRSPIRV
MLIRSPIRVUtils
MLIRLLVMIR MLIRLLVMIR
MLIRStandardToLLVM MLIRStandardToLLVM
MLIRIR MLIRIR
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

Show All 11 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h" #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h"
#include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

//===- ConvertSPIRVToLLVM.cpp - SPIR-V dialect to LLVM dialect conversion -===// //===- ConvertSPIRVToLLVM.cpp - SPIR-V dialect to LLVM dialect conversion -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements patterns to convert SPIR-V dialect to LLVM dialect. // This file implements patterns to convert SPIR-V dialect to LLVM dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h" #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/SPIRV/LayoutUtils.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
▲ Show 20 Lines • Show All 1,533 Lines • Show Last 20 Lines

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.cpp

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h" #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// A pass converting MLIR SPIR-V operations into LLVM dialect. /// A pass converting MLIR SPIR-V operations into LLVM dialect.
class ConvertSPIRVToLLVMPass class ConvertSPIRVToLLVMPass
: public ConvertSPIRVToLLVMBase<ConvertSPIRVToLLVMPass> { : public ConvertSPIRVToLLVMBase<ConvertSPIRVToLLVMPass> {
void runOnOperation() override; void runOnOperation() override;
Show All 34 Lines

mlir/lib/Conversion/StandardToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRStandardToSPIRVTransforms add_mlir_conversion_library(MLIRStandardToSPIRVTransforms
ConvertStandardToSPIRV.cpp ConvertStandardToSPIRV.cpp
ConvertStandardToSPIRVPass.cpp ConvertStandardToSPIRVPass.cpp
LegalizeStandardForSPIRV.cpp LegalizeStandardForSPIRV.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion
MLIRSupport MLIRSupport
MLIRTransformUtils MLIRTransformUtils
MLIRSPIRV
MLIRStandard MLIRStandard
) )

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

//===- ConvertStandardToSPIRV.cpp - Standard to SPIR-V dialect conversion--===// //===- ConvertStandardToSPIRV.cpp - Standard to SPIR-V dialect conversion--===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements patterns to convert standard ops to SPIR-V ops. // This file implements patterns to convert standard ops to SPIR-V ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/LayoutUtils.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/AffineMap.h" #include "mlir/IR/AffineMap.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#define DEBUG_TYPE "std-to-spirv-pattern" #define DEBUG_TYPE "std-to-spirv-pattern"
▲ Show 20 Lines • Show All 1,103 Lines • Show Last 20 Lines

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.cpp

//===- ConvertStandardToSPIRVPass.cpp - Convert Std Ops to SPIR-V Ops -----===// //===- ConvertStandardToSPIRVPass.cpp - Convert Std Ops to SPIR-V Ops -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to convert MLIR standard ops into the SPIR-V // This file implements a pass to convert MLIR standard ops into the SPIR-V
// ops. // ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h" #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// A pass converting MLIR Standard operations into the SPIR-V dialect. /// A pass converting MLIR Standard operations into the SPIR-V dialect.
class ConvertStandardToSPIRVPass class ConvertStandardToSPIRVPass
: public ConvertStandardToSPIRVBase<ConvertStandardToSPIRVPass> { : public ConvertStandardToSPIRVBase<ConvertStandardToSPIRVPass> {
void runOnOperation() override; void runOnOperation() override;
Show All 24 Lines

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

//===- LegalizeStandardForSPIRV.cpp - Legalize ops for SPIR-V lowering ----===// //===- LegalizeStandardForSPIRV.cpp - Legalize ops for SPIR-V lowering ----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This transformation pass legalizes operations before the conversion to SPIR-V // This transformation pass legalizes operations before the conversion to SPIR-V
// dialect to handle ops that cannot be lowered directly. // dialect to handle ops that cannot be lowered directly.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h" #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/Dialect/Vector/VectorOps.h" #include "mlir/Dialect/Vector/VectorOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/Transforms/GreedyPatternRewriteDriver.h" #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

mlir/lib/Conversion/VectorToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRVectorToSPIRV add_mlir_conversion_library(MLIRVectorToSPIRV
VectorToSPIRV.cpp VectorToSPIRV.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToSPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToSPIRV
DEPENDS DEPENDS
MLIRConversionPassIncGen MLIRConversionPassIncGen
intrinsics_gen intrinsics_gen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion
MLIRVector MLIRVector
MLIRTransforms MLIRTransforms
) )

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

//===------- VectorToSPIRV.cpp - Vector to SPIRV lowering passes ----------===// //===------- VectorToSPIRV.cpp - Vector to SPIRV lowering passes ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to generate SPIRV operations for Vector // This file implements a pass to generate SPIRV operations for Vector
// operations. // operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../PassDetail.h" #include "../PassDetail.h"
#include "mlir/Conversion/VectorToSPIRV/ConvertVectorToSPIRV.h" #include "mlir/Conversion/VectorToSPIRV/ConvertVectorToSPIRV.h"
#include "mlir/Conversion/VectorToSPIRV/ConvertVectorToSPIRVPass.h" #include "mlir/Conversion/VectorToSPIRV/ConvertVectorToSPIRVPass.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/Vector/VectorOps.h" #include "mlir/Dialect/Vector/VectorOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
struct VectorBroadcastConvert final struct VectorBroadcastConvert final
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/CMakeLists.txt

  • This file was copied to mlir/lib/Dialect/SPIRV/IR/CMakeLists.txt.
add_subdirectory(IR)
set(LLVM_TARGET_DEFINITIONS SPIRVCanonicalization.td)
mlir_tablegen(SPIRVCanonicalization.inc -gen-rewriters)
add_public_tablegen_target(MLIRSPIRVCanonicalizationIncGen)
add_mlir_dialect_library(MLIRSPIRV
LayoutUtils.cpp
SPIRVAttributes.cpp
SPIRVCanonicalization.cpp
SPIRVDialect.cpp
SPIRVOps.cpp
SPIRVLowering.cpp
SPIRVTypes.cpp
TargetAndABI.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
DEPENDS
MLIRSPIRVAvailabilityIncGen
MLIRSPIRVCanonicalizationIncGen
MLIRSPIRVEnumAvailabilityIncGen
MLIRSPIRVEnumsIncGen
MLIRSPIRVOpsIncGen
MLIRSPIRVOpUtilsGen
MLIRSPIRVTargetAndABIIncGen
LINK_LIBS PUBLIC
MLIRControlFlowInterfaces
MLIRIR
MLIRParser
MLIRSideEffectInterfaces
MLIRSupport
MLIRTransforms
)
add_subdirectory(Linking) add_subdirectory(Linking)
add_subdirectory(Transforms) add_subdirectory(Transforms)
add_subdirectory(Utils)

mlir/lib/Dialect/SPIRV/IR/CMakeLists.txt

  • This file was copied from mlir/lib/Dialect/SPIRV/CMakeLists.txt.
set(LLVM_TARGET_DEFINITIONS SPIRVCanonicalization.td) set(LLVM_TARGET_DEFINITIONS SPIRVCanonicalization.td)
mlir_tablegen(SPIRVCanonicalization.inc -gen-rewriters) mlir_tablegen(SPIRVCanonicalization.inc -gen-rewriters)
add_public_tablegen_target(MLIRSPIRVCanonicalizationIncGen) add_public_tablegen_target(MLIRSPIRVCanonicalizationIncGen)
add_mlir_dialect_library(MLIRSPIRV add_mlir_dialect_library(MLIRSPIRV
LayoutUtils.cpp
SPIRVAttributes.cpp SPIRVAttributes.cpp
SPIRVCanonicalization.cpp SPIRVCanonicalization.cpp
SPIRVDialect.cpp SPIRVDialect.cpp
SPIRVEnums.cpp
SPIRVOps.cpp SPIRVOps.cpp
SPIRVLowering.cpp
SPIRVTypes.cpp SPIRVTypes.cpp
TargetAndABI.cpp TargetAndABI.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
DEPENDS DEPENDS
MLIRSPIRVAttrUtilsGen
MLIRSPIRVAvailabilityIncGen MLIRSPIRVAvailabilityIncGen
MLIRSPIRVCanonicalizationIncGen MLIRSPIRVCanonicalizationIncGen
MLIRSPIRVEnumAvailabilityIncGen MLIRSPIRVEnumAvailabilityIncGen
MLIRSPIRVEnumsIncGen MLIRSPIRVEnumsIncGen
MLIRSPIRVOpsIncGen MLIRSPIRVOpsIncGen
MLIRSPIRVOpUtilsGen
MLIRSPIRVTargetAndABIIncGen MLIRSPIRVTargetAndABIIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRControlFlowInterfaces MLIRControlFlowInterfaces
MLIRIR MLIRIR
MLIRParser MLIRParser
MLIRSideEffectInterfaces MLIRSideEffectInterfaces
MLIRSupport MLIRSupport
MLIRTransforms MLIRTransforms
) )
add_subdirectory(Linking)
add_subdirectory(Transforms)

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

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVAttributes.cpp.
//===- SPIRVAttributes.cpp - SPIR-V attribute definitions -----------------===// //===- SPIRVAttributes.cpp - SPIR-V attribute definitions -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TableGen'erated attribute utility functions
//===----------------------------------------------------------------------===//
namespace mlir {
namespace spirv {
#include "mlir/Dialect/SPIRV/IR/SPIRVAttrUtils.inc"
} // namespace spirv
} // namespace mlir
//===----------------------------------------------------------------------===//
// DictionaryDict derived attributes // DictionaryDict derived attributes
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/TargetAndABI.cpp.inc" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.cpp.inc"
namespace mlir { namespace mlir {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Attribute storage classes // Attribute storage classes
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace spirv { namespace spirv {
▲ Show 20 Lines • Show All 312 Lines • Show Last 20 Lines

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

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp.
//===- SPIRVCanonicalization.cpp - MLIR SPIR-V canonicalization patterns --===// //===- SPIRVCanonicalization.cpp - MLIR SPIR-V canonicalization patterns --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the folders and canonicalization patterns for SPIR-V ops. // This file defines the folders and canonicalization patterns for SPIR-V ops.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/CommonFolders.h" #include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/Matchers.h" #include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h" #include "mlir/IR/PatternMatch.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Common utility functions // Common utility functions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 325 Lines • ▼ Show 20 Lines bool onlyContainsBranchConditionalOp(Block *block) const {
return std::next(block->begin()) == block->end() && return std::next(block->begin()) == block->end() &&
isa<spirv::BranchConditionalOp>(block->front()); isa<spirv::BranchConditionalOp>(block->front());
} }
bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const { bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
return lhs->getAttrDictionary() == rhs->getAttrDictionary(); return lhs->getAttrDictionary() == rhs->getAttrDictionary();
} }
// Returns a source value for the given block. // Returns a source value for the given block.
Value getSrcValue(Block *block) const { Value getSrcValue(Block *block) const {
auto storeOp = cast<spirv::StoreOp>(block->front()); auto storeOp = cast<spirv::StoreOp>(block->front());
return storeOp.value(); return storeOp.value();
} }
// Returns a destination value for the given block. // Returns a destination value for the given block.
Value getDstPtr(Block *block) const { Value getDstPtr(Block *block) const {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.td.
//==- SPIRVCanonicalization.td - Canonicalization Patterns ---*- tablegen -*==// //==- SPIRVCanonicalization.td - Canonicalization Patterns ---*- tablegen -*==//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines SPIR-V canonicalization patterns. // This file defines SPIR-V canonicalization patterns.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
include "mlir/Dialect/SPIRV/SPIRVOps.td" include "mlir/Dialect/SPIRV/IR/SPIRVOps.td"
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Bitcast // spv.Bitcast
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def ConvertChainedBitcast : Pat<(SPV_BitcastOp (SPV_BitcastOp $operand)), def ConvertChainedBitcast : Pat<(SPV_BitcastOp (SPV_BitcastOp $operand)),
(SPV_BitcastOp $operand)>; (SPV_BitcastOp $operand)>;
Show All 19 Lines

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

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp.
//===- LLVMDialect.cpp - MLIR SPIR-V dialect ------------------------------===// //===- LLVMDialect.cpp - MLIR SPIR-V dialect ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM // Part of the LLVM Project, under the Apache License v2.0 with LLVM
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the SPIR-V dialect in MLIR. // This file defines the SPIR-V dialect in MLIR.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/ParserUtils.h" #include "mlir/Dialect/SPIRV/IR/ParserUtils.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/DialectImplementation.h" #include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/Parser.h" #include "mlir/Parser.h"
#include "mlir/Transforms/InliningUtils.h" #include "mlir/Transforms/InliningUtils.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
namespace mlir {
namespace spirv {
#include "mlir/Dialect/SPIRV/SPIRVOpUtils.inc"
} // namespace spirv
} // namespace mlir
using namespace mlir; using namespace mlir;
using namespace mlir::spirv; using namespace mlir::spirv;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// InlinerInterface // InlinerInterface
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Returns true if the given region contains spv.Return or spv.ReturnValue ops. /// Returns true if the given region contains spv.Return or spv.ReturnValue ops.
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Linesvoid SPIRVDialect::initialize() {
addTypes<ArrayType, CooperativeMatrixNVType, ImageType, MatrixType, addTypes<ArrayType, CooperativeMatrixNVType, ImageType, MatrixType,
PointerType, RuntimeArrayType, StructType>(); PointerType, RuntimeArrayType, StructType>();
addAttributes<InterfaceVarABIAttr, TargetEnvAttr, VerCapExtAttr>(); addAttributes<InterfaceVarABIAttr, TargetEnvAttr, VerCapExtAttr>();
// Add SPIR-V ops. // Add SPIR-V ops.
addOperations< addOperations<
#define GET_OP_LIST #define GET_OP_LIST
#include "mlir/Dialect/SPIRV/SPIRVOps.cpp.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
>(); >();
addInterfaces<SPIRVInlinerInterface>(); addInterfaces<SPIRVInlinerInterface>();
// Allow unknown operations because SPIR-V is extensible. // Allow unknown operations because SPIR-V is extensible.
allowUnknownOperations(); allowUnknownOperations();
} }
▲ Show 20 Lines • Show All 1,102 Lines • Show Last 20 Lines

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

  • This file was added.
//===- SPIRVEnums.cpp - MLIR SPIR-V Enums ---------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the C/C++ enums from SPIR-V spec.
//
//===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
using namespace mlir;
// Pull in all enum utility function definitions
#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.cpp.inc"
// Pull in all enum type availability query function definitions
#include "mlir/Dialect/SPIRV/IR/SPIRVEnumAvailability.cpp.inc"
//===----------------------------------------------------------------------===//
// Availability relationship
//===----------------------------------------------------------------------===//
ArrayRef<spirv::Extension> spirv::getImpliedExtensions(spirv::Version version) {
// Note: the following lists are from "Appendix A: Changes" of the spec.
#define V_1_3_IMPLIED_EXTS \
Extension::SPV_KHR_shader_draw_parameters, Extension::SPV_KHR_16bit_storage, \
Extension::SPV_KHR_device_group, Extension::SPV_KHR_multiview, \
Extension::SPV_KHR_storage_buffer_storage_class, \
Extension::SPV_KHR_variable_pointers
#define V_1_4_IMPLIED_EXTS \
Extension::SPV_KHR_no_integer_wrap_decoration, \
Extension::SPV_GOOGLE_decorate_string, \
Extension::SPV_GOOGLE_hlsl_functionality1, \
Extension::SPV_KHR_float_controls
#define V_1_5_IMPLIED_EXTS \
Extension::SPV_KHR_8bit_storage, Extension::SPV_EXT_descriptor_indexing, \
Extension::SPV_EXT_shader_viewport_index_layer, \
Extension::SPV_EXT_physical_storage_buffer, \
Extension::SPV_KHR_physical_storage_buffer, \
Extension::SPV_KHR_vulkan_memory_model
switch (version) {
default:
return {};
case Version::V_1_3: {
// The following manual ArrayRef constructor call is to satisfy GCC 5.
static const Extension exts[] = {V_1_3_IMPLIED_EXTS};
return ArrayRef<spirv::Extension>(exts, llvm::array_lengthof(exts));
}
case Version::V_1_4: {
static const Extension exts[] = {V_1_3_IMPLIED_EXTS, V_1_4_IMPLIED_EXTS};
return ArrayRef<spirv::Extension>(exts, llvm::array_lengthof(exts));
}
case Version::V_1_5: {
static const Extension exts[] = {V_1_3_IMPLIED_EXTS, V_1_4_IMPLIED_EXTS,
V_1_5_IMPLIED_EXTS};
return ArrayRef<spirv::Extension>(exts, llvm::array_lengthof(exts));
}
}
#undef V_1_5_IMPLIED_EXTS
#undef V_1_4_IMPLIED_EXTS
#undef V_1_3_IMPLIED_EXTS
}
// Pull in utility function definition for implied capabilities
#include "mlir/Dialect/SPIRV/IR/SPIRVCapabilityImplication.inc"
SmallVector<spirv::Capability, 0>
spirv::getRecursiveImpliedCapabilities(spirv::Capability cap) {
ArrayRef<spirv::Capability> directCaps = getDirectImpliedCapabilities(cap);
llvm::SetVector<spirv::Capability, SmallVector<spirv::Capability, 0>> allCaps(
directCaps.begin(), directCaps.end());
// TODO: This is insufficient; find a better way to handle this
// (e.g., using static lists) if this turns out to be a bottleneck.
for (unsigned i = 0; i < allCaps.size(); ++i)
for (Capability c : getDirectImpliedCapabilities(allCaps[i]))
allCaps.insert(c);
return allCaps.takeVector();
}

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

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVOps.cpp.
//===- SPIRVOps.cpp - MLIR SPIR-V operations ------------------------------===// //===- SPIRVOps.cpp - MLIR SPIR-V operations ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the operations in the SPIR-V dialect. // This file defines the operations in the SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/ParserUtils.h" #include "mlir/Dialect/SPIRV/IR/ParserUtils.h"
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/FunctionImplementation.h" #include "mlir/IR/FunctionImplementation.h"
#include "mlir/IR/OpImplementation.h" #include "mlir/IR/OpImplementation.h"
#include "mlir/Interfaces/CallInterfaces.h" #include "mlir/Interfaces/CallInterfaces.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/bit.h" #include "llvm/ADT/bit.h"
▲ Show 20 Lines • Show All 3,438 Lines • ▼ Show 20 Linesstatic LogicalResult verify(spirv::SpecConstantOperationOp constOp) {
return success(); return success();
} }
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
// TableGen'erated operation interfaces for querying versions, extensions, and // TableGen'erated operation interfaces for querying versions, extensions, and
// capabilities. // capabilities.
#include "mlir/Dialect/SPIRV/SPIRVAvailability.cpp.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc"
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir
// TablenGen'erated operation definitions. // TablenGen'erated operation definitions.
#define GET_OP_CLASSES #define GET_OP_CLASSES
#include "mlir/Dialect/SPIRV/SPIRVOps.cpp.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
// TableGen'erated operation availability interface implementations. // TableGen'erated operation availability interface implementations.
#include "mlir/Dialect/SPIRV/SPIRVOpAvailabilityImpl.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc"
} // namespace spirv } // namespace spirv
} // namespace mlir } // namespace mlir

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

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp.
//===- SPIRVTypes.cpp - MLIR SPIR-V Types ---------------------------------===// //===- SPIRVTypes.cpp - MLIR SPIR-V Types ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the types in the SPIR-V dialect. // This file defines the types in the SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/IR/Attributes.h" #include "mlir/IR/Attributes.h"
#include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Identifier.h" #include "mlir/IR/Identifier.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/TypeSwitch.h" #include "llvm/ADT/TypeSwitch.h"
using namespace mlir; using namespace mlir;
using namespace mlir::spirv; using namespace mlir::spirv;
// Pull in all enum utility function definitions
#include "mlir/Dialect/SPIRV/SPIRVEnums.cpp.inc"
// Pull in all enum type availability query function definitions
#include "mlir/Dialect/SPIRV/SPIRVEnumAvailability.cpp.inc"
//===----------------------------------------------------------------------===//
// Availability relationship
//===----------------------------------------------------------------------===//
ArrayRef<Extension> spirv::getImpliedExtensions(Version version) {
// Note: the following lists are from "Appendix A: Changes" of the spec.
#define V_1_3_IMPLIED_EXTS \
Extension::SPV_KHR_shader_draw_parameters, Extension::SPV_KHR_16bit_storage, \
Extension::SPV_KHR_device_group, Extension::SPV_KHR_multiview, \
Extension::SPV_KHR_storage_buffer_storage_class, \
Extension::SPV_KHR_variable_pointers
#define V_1_4_IMPLIED_EXTS \
Extension::SPV_KHR_no_integer_wrap_decoration, \
Extension::SPV_GOOGLE_decorate_string, \
Extension::SPV_GOOGLE_hlsl_functionality1, \
Extension::SPV_KHR_float_controls
#define V_1_5_IMPLIED_EXTS \
Extension::SPV_KHR_8bit_storage, Extension::SPV_EXT_descriptor_indexing, \
Extension::SPV_EXT_shader_viewport_index_layer, \
Extension::SPV_EXT_physical_storage_buffer, \
Extension::SPV_KHR_physical_storage_buffer, \
Extension::SPV_KHR_vulkan_memory_model
switch (version) {
default:
return {};
case Version::V_1_3: {
// The following manual ArrayRef constructor call is to satisfy GCC 5.
static const Extension exts[] = {V_1_3_IMPLIED_EXTS};
return ArrayRef<Extension>(exts, llvm::array_lengthof(exts));
}
case Version::V_1_4: {
static const Extension exts[] = {V_1_3_IMPLIED_EXTS, V_1_4_IMPLIED_EXTS};
return ArrayRef<Extension>(exts, llvm::array_lengthof(exts));
}
case Version::V_1_5: {
static const Extension exts[] = {V_1_3_IMPLIED_EXTS, V_1_4_IMPLIED_EXTS,
V_1_5_IMPLIED_EXTS};
return ArrayRef<Extension>(exts, llvm::array_lengthof(exts));
}
}
#undef V_1_5_IMPLIED_EXTS
#undef V_1_4_IMPLIED_EXTS
#undef V_1_3_IMPLIED_EXTS
}
// Pull in utility function definition for implied capabilities
#include "mlir/Dialect/SPIRV/SPIRVCapabilityImplication.inc"
SmallVector<Capability, 0>
spirv::getRecursiveImpliedCapabilities(Capability cap) {
ArrayRef<Capability> directCaps = getDirectImpliedCapabilities(cap);
llvm::SetVector<Capability, SmallVector<Capability, 0>> allCaps(
directCaps.begin(), directCaps.end());
// TODO: This is insufficient; find a better way to handle this
// (e.g., using static lists) if this turns out to be a bottleneck.
for (unsigned i = 0; i < allCaps.size(); ++i)
for (Capability c : getDirectImpliedCapabilities(allCaps[i]))
allCaps.insert(c);
return allCaps.takeVector();
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ArrayType // ArrayType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
struct spirv::detail::ArrayTypeStorage : public TypeStorage { struct spirv::detail::ArrayTypeStorage : public TypeStorage {
using KeyTy = std::tuple<Type, unsigned, unsigned>; using KeyTy = std::tuple<Type, unsigned, unsigned>;
static ArrayTypeStorage *construct(TypeStorageAllocator &allocator, static ArrayTypeStorage *construct(TypeStorageAllocator &allocator,
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Linesvoid CooperativeMatrixNVType::getCapabilities(
ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps)); ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
capabilities.push_back(ref); capabilities.push_back(ref);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ImageType // ImageType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <typename T> static constexpr unsigned getNumBits() { return 0; } template <typename T>
template <> constexpr unsigned getNumBits<Dim>() { static constexpr unsigned getNumBits() {
return 0;
}
template <>
constexpr unsigned getNumBits<Dim>() {
static_assert((1 << 3) > getMaxEnumValForDim(), static_assert((1 << 3) > getMaxEnumValForDim(),
"Not enough bits to encode Dim value"); "Not enough bits to encode Dim value");
return 3; return 3;
} }
template <> constexpr unsigned getNumBits<ImageDepthInfo>() { template <>
constexpr unsigned getNumBits<ImageDepthInfo>() {
static_assert((1 << 2) > getMaxEnumValForImageDepthInfo(), static_assert((1 << 2) > getMaxEnumValForImageDepthInfo(),
"Not enough bits to encode ImageDepthInfo value"); "Not enough bits to encode ImageDepthInfo value");
return 2; return 2;
} }
template <> constexpr unsigned getNumBits<ImageArrayedInfo>() { template <>
constexpr unsigned getNumBits<ImageArrayedInfo>() {
static_assert((1 << 1) > getMaxEnumValForImageArrayedInfo(), static_assert((1 << 1) > getMaxEnumValForImageArrayedInfo(),
"Not enough bits to encode ImageArrayedInfo value"); "Not enough bits to encode ImageArrayedInfo value");
return 1; return 1;
} }
template <> constexpr unsigned getNumBits<ImageSamplingInfo>() { template <>
constexpr unsigned getNumBits<ImageSamplingInfo>() {
static_assert((1 << 1) > getMaxEnumValForImageSamplingInfo(), static_assert((1 << 1) > getMaxEnumValForImageSamplingInfo(),
"Not enough bits to encode ImageSamplingInfo value"); "Not enough bits to encode ImageSamplingInfo value");
return 1; return 1;
} }
template <> constexpr unsigned getNumBits<ImageSamplerUseInfo>() { template <>
constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
static_assert((1 << 2) > getMaxEnumValForImageSamplerUseInfo(), static_assert((1 << 2) > getMaxEnumValForImageSamplerUseInfo(),
"Not enough bits to encode ImageSamplerUseInfo value"); "Not enough bits to encode ImageSamplerUseInfo value");
return 2; return 2;
} }
template <> constexpr unsigned getNumBits<ImageFormat>() { template <>
constexpr unsigned getNumBits<ImageFormat>() {
static_assert((1 << 6) > getMaxEnumValForImageFormat(), static_assert((1 << 6) > getMaxEnumValForImageFormat(),
"Not enough bits to encode ImageFormat value"); "Not enough bits to encode ImageFormat value");
return 6; return 6;
} }
struct spirv::detail::ImageTypeStorage : public TypeStorage { struct spirv::detail::ImageTypeStorage : public TypeStorage {
public: public:
using KeyTy = std::tuple<Type, Dim, ImageDepthInfo, ImageArrayedInfo, using KeyTy = std::tuple<Type, Dim, ImageDepthInfo, ImageArrayedInfo,
▲ Show 20 Lines • Show All 803 Lines • Show Last 20 Lines

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

  • This file was moved from mlir/lib/Dialect/SPIRV/TargetAndABI.cpp.
//===- TargetAndABI.cpp - SPIR-V target and ABI utilities -----------------===// //===- TargetAndABI.cpp - SPIR-V target and ABI utilities -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/FunctionSupport.h" #include "mlir/IR/FunctionSupport.h"
#include "mlir/IR/Operation.h" #include "mlir/IR/Operation.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/LayoutUtils.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/Utils/LayoutUtils.cpp.

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

//===- ModuleCombiner.cpp - MLIR SPIR-V Module Combiner ---------*- C++ -*-===// //===- ModuleCombiner.cpp - MLIR SPIR-V Module Combiner ---------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the the SPIR-V module combiner library. // This file implements the the SPIR-V module combiner library.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/ModuleCombiner.h" #include "mlir/Dialect/SPIRV/Linking/ModuleCombiner.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/SymbolTable.h" #include "mlir/IR/SymbolTable.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Hashing.h" #include "llvm/ADT/Hashing.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 254 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/SPIRVAttributes.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp.

mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp.

mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.td

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.td.

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp.

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp.

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp.

mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp.

mlir/lib/Dialect/SPIRV/TargetAndABI.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp.

mlir/lib/Dialect/SPIRV/Transforms/CMakeLists.txt

set(LLVM_OPTIONAL_SOURCES
DecorateCompositeTypeLayoutPass.cpp
LowerABIAttributesPass.cpp
RewriteInsertsPass.cpp
SPIRVConversion.cpp
UpdateVCEPass.cpp
)
add_mlir_dialect_library(MLIRSPIRVConversion
SPIRVConversion.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
LINK_LIBS PUBLIC
MLIRSPIRV
MLIRTransformUtils
)
add_mlir_dialect_library(MLIRSPIRVTransforms add_mlir_dialect_library(MLIRSPIRVTransforms
DecorateSPIRVCompositeTypeLayoutPass.cpp DecorateCompositeTypeLayoutPass.cpp
LowerABIAttributesPass.cpp LowerABIAttributesPass.cpp
RewriteInsertsPass.cpp RewriteInsertsPass.cpp
UpdateVCEPass.cpp UpdateVCEPass.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
DEPENDS DEPENDS
MLIRSPIRVPassIncGen MLIRSPIRVPassIncGen
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRPass MLIRPass
MLIRSPIRV MLIRSPIRVConversion
MLIRSPIRVUtils
) )

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp

  • This file was moved from mlir/lib/Dialect/SPIRV/Transforms/DecorateSPIRVCompositeTypeLayoutPass.cpp.
//===- DecorateSPIRVCompositeTypeLayoutPass.cpp - Decorate composite type -===// //===- DecorateCompositeTypeLayoutPass.cpp - Decorate composite type ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to decorate the composite types used by // This file implements a pass to decorate the composite types used by
// composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and // composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and
// PushConstant storage classes with layout information. See SPIR-V spec // PushConstant storage classes with layout information. See SPIR-V spec
// "2.16.2. Validation Rules for Shader Capabilities" for more details. // "2.16.2. Validation Rules for Shader Capabilities" for more details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/SPIRV/LayoutUtils.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
class SPIRVGlobalVariableOpLayoutInfoDecoration class SPIRVGlobalVariableOpLayoutInfoDecoration
: public OpRewritePattern<spirv::GlobalVariableOp> { : public OpRewritePattern<spirv::GlobalVariableOp> {
public: public:
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/DecorateSPIRVCompositeTypeLayoutPass.cpp

  • This file was moved to mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp.

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

//===- LowerABIAttributesPass.cpp - Decorate composite type ---------------===// //===- LowerABIAttributesPass.cpp - Decorate composite type ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to lower attributes that specify the shader ABI // This file implements a pass to lower attributes that specify the shader ABI
// for the functions in the generated SPIR-V module. // for the functions in the generated SPIR-V module.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/SPIRV/LayoutUtils.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Transforms/DialectConversion.h" #include "mlir/Transforms/DialectConversion.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
using namespace mlir; using namespace mlir;
/// Creates a global variable for an argument based on the ABI info. /// Creates a global variable for an argument based on the ABI info.
static spirv::GlobalVariableOp static spirv::GlobalVariableOp
createGlobalVarForEntryPointArgument(OpBuilder &builder, spirv::FuncOp funcOp, createGlobalVarForEntryPointArgument(OpBuilder &builder, spirv::FuncOp funcOp,
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/PassDetail.h

Show All 12 Lines
namespace mlir { namespace mlir {
namespace spirv { namespace spirv {
class ModuleOp; class ModuleOp;
} // end namespace spirv } // end namespace spirv
#define GEN_PASS_CLASSES #define GEN_PASS_CLASSES
#include "mlir/Dialect/SPIRV/Passes.h.inc" #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
} // end namespace mlir } // end namespace mlir
#endif // DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_ #endif // DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SPIRV/Transforms/RewriteInsertsPass.cpp

//===- RewriteInsertsPass.cpp - MLIR conversion pass ----------------------===// //===- RewriteInsertsPass.cpp - MLIR conversion pass ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to rewrite sequential chains of // This file implements a pass to rewrite sequential chains of
// `spirv::CompositeInsert` operations into `spirv::CompositeConstruct` // `spirv::CompositeInsert` operations into `spirv::CompositeConstruct`
// operations. // operations.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// Replaces sequential chains of `spirv::CompositeInsertOp` operation into /// Replaces sequential chains of `spirv::CompositeInsertOp` operation into
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

  • This file was moved from mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp.
//===- SPIRVLowering.cpp - SPIR-V lowering utilities ----------------------===// //===- SPIRVConversion.cpp - SPIR-V Conversion Utilities ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements utilities used to lower to SPIR-V dialect. // This file implements utilities used to lower to SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/Dialect/SPIRV/LayoutUtils.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include <functional> #include <functional>
#define DEBUG_TYPE "mlir-spirv-lowering" #define DEBUG_TYPE "mlir-spirv-conversion"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Utility functions // Utility functions
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Checks that `candidates` extension requirements are possible to be satisfied /// Checks that `candidates` extension requirements are possible to be satisfied
▲ Show 20 Lines • Show All 718 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp

//===- DeduceVersionExtensionCapabilityPass.cpp ---------------------------===// //===- DeduceVersionExtensionCapabilityPass.cpp ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass to deduce minimal version/extension/capability // This file implements a pass to deduce minimal version/extension/capability
// requirements for a spirv::ModuleOp. // requirements for a spirv::ModuleOp.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PassDetail.h" #include "PassDetail.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Visitors.h" #include "mlir/IR/Visitors.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallSet.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

mlir/lib/Dialect/SPIRV/Utils/CMakeLists.txt

  • This file was added.
add_mlir_dialect_library(MLIRSPIRVUtils
LayoutUtils.cpp
ADDITIONAL_HEADER_DIRS
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
LINK_LIBS PUBLIC
MLIRSPIRV
)

mlir/lib/Dialect/SPIRV/Utils/LayoutUtils.cpp

  • This file was moved from mlir/lib/Dialect/SPIRV/LayoutUtils.cpp.
//===-- LayoutUtils.cpp - Decorate composite type with layout information -===// //===-- LayoutUtils.cpp - Decorate composite type with layout information -===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements Utilities used to get alignment and layout information // This file implements Utilities used to get alignment and layout information
// for types in SPIR-V dialect. // for types in SPIR-V dialect.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/LayoutUtils.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
using namespace mlir; using namespace mlir;
spirv::StructType spirv::StructType
VulkanLayoutUtils::decorateType(spirv::StructType structType) { VulkanLayoutUtils::decorateType(spirv::StructType structType) {
Size size = 0; Size size = 0;
Size alignment = 1; Size alignment = 1;
return decorateType(structType, size, alignment); return decorateType(structType, size, alignment);
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

mlir/lib/Target/SPIRV/Deserialization.cpp

//===- Deserializer.cpp - MLIR SPIR-V Deserialization ---------------------===// //===- Deserializer.cpp - MLIR SPIR-V Deserialization ---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the SPIR-V binary to MLIR SPIR-V module deserialization. // This file defines the SPIR-V binary to MLIR SPIR-V module deserialization.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Target/SPIRV/Deserialization.h" #include "mlir/Target/SPIRV/Deserialization.h"
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Dialect/SPIRV/SPIRVModule.h" #include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/BlockAndValueMapping.h" #include "mlir/IR/BlockAndValueMapping.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Location.h" #include "mlir/IR/Location.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "mlir/Target/SPIRV/SPIRVBinaryUtils.h" #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
▲ Show 20 Lines • Show All 2,746 Lines • ▼ Show 20 LinesDeserializer::processOp<spirv::CopyMemoryOp>(ArrayRef<uint32_t> words) {
opBuilder.create<spirv::CopyMemoryOp>(loc, resultTypes, operands, attributes); opBuilder.create<spirv::CopyMemoryOp>(loc, resultTypes, operands, attributes);
return success(); return success();
} }
// Pull in auto-generated Deserializer::dispatchToAutogenDeserialization() and // Pull in auto-generated Deserializer::dispatchToAutogenDeserialization() and
// various Deserializer::processOp<...>() specializations. // various Deserializer::processOp<...>() specializations.
#define GET_DESERIALIZATION_FNS #define GET_DESERIALIZATION_FNS
#include "mlir/Dialect/SPIRV/SPIRVSerialization.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
} // namespace } // namespace
namespace mlir { namespace mlir {
spirv::OwningSPIRVModuleRef spirv::deserialize(ArrayRef<uint32_t> binary, spirv::OwningSPIRVModuleRef spirv::deserialize(ArrayRef<uint32_t> binary,
MLIRContext *context) { MLIRContext *context) {
Deserializer deserializer(binary, context); Deserializer deserializer(binary, context);
if (failed(deserializer.deserialize())) if (failed(deserializer.deserialize()))
return nullptr; return nullptr;
return deserializer.collect(); return deserializer.collect();
} }
} // namespace mlir } // namespace mlir

mlir/lib/Target/SPIRV/SPIRVBinaryUtils.cpp

//===- SPIRVBinaryUtils.cpp - MLIR SPIR-V Binary Module Utilities ---------===// //===- SPIRVBinaryUtils.cpp - MLIR SPIR-V Binary Module Utilities ---------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines common utilities for SPIR-V binary module. // This file defines common utilities for SPIR-V binary module.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Target/SPIRV/SPIRVBinaryUtils.h" #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
using namespace mlir; using namespace mlir;
void spirv::appendModuleHeader(SmallVectorImpl<uint32_t> &header, void spirv::appendModuleHeader(SmallVectorImpl<uint32_t> &header,
spirv::Version version, uint32_t idBound) { spirv::Version version, uint32_t idBound) {
uint32_t majorVersion = 1; uint32_t majorVersion = 1;
uint32_t minorVersion = 0; uint32_t minorVersion = 0;
switch (version) { switch (version) {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

mlir/lib/Target/SPIRV/Serialization.cpp

//===- Serializer.cpp - MLIR SPIR-V Serialization -------------------------===// //===- Serializer.cpp - MLIR SPIR-V Serialization -------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines the MLIR SPIR-V module to SPIR-V binary serialization. // This file defines the MLIR SPIR-V module to SPIR-V binary serialization.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Target/SPIRV/Serialization.h" #include "mlir/Target/SPIRV/Serialization.h"
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/RegionGraphTraits.h" #include "mlir/IR/RegionGraphTraits.h"
#include "mlir/Support/LogicalResult.h" #include "mlir/Support/LogicalResult.h"
#include "mlir/Target/SPIRV/SPIRVBinaryUtils.h" #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
#include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
▲ Show 20 Lines • Show All 2,075 Lines • ▼ Show 20 LinesSerializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory, operands); encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory, operands);
return success(); return success();
} }
// Pull in auto-generated Serializer::dispatchToAutogenSerialization() and // Pull in auto-generated Serializer::dispatchToAutogenSerialization() and
// various Serializer::processOp<...>() specializations. // various Serializer::processOp<...>() specializations.
#define GET_SERIALIZATION_FNS #define GET_SERIALIZATION_FNS
#include "mlir/Dialect/SPIRV/SPIRVSerialization.inc" #include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
} // namespace } // namespace
LogicalResult Serializer::emitDecoration(uint32_t target, LogicalResult Serializer::emitDecoration(uint32_t target,
spirv::Decoration decoration, spirv::Decoration decoration,
ArrayRef<uint32_t> params) { ArrayRef<uint32_t> params) {
uint32_t wordCount = 3 + params.size(); uint32_t wordCount = 3 + params.size();
decorations.push_back( decorations.push_back(
spirv::getPrefixedOpcode(wordCount, spirv::Opcode::OpDecorate)); spirv::getPrefixedOpcode(wordCount, spirv::Opcode::OpDecorate));
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

mlir/lib/Target/SPIRV/TranslateRegistration.cpp

//===- TranslateRegistration.cpp - hooks to mlir-translate ----------------===// //===- TranslateRegistration.cpp - hooks to mlir-translate ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a translation from SPIR-V binary module to MLIR SPIR-V // This file implements a translation from SPIR-V binary module to MLIR SPIR-V
// ModuleOp. // ModuleOp.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVModule.h" #include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Dialect.h" #include "mlir/IR/Dialect.h"
#include "mlir/Parser.h" #include "mlir/Parser.h"
#include "mlir/Support/FileUtilities.h" #include "mlir/Support/FileUtilities.h"
#include "mlir/Target/SPIRV/Deserialization.h" #include "mlir/Target/SPIRV/Deserialization.h"
#include "mlir/Target/SPIRV/Serialization.h" #include "mlir/Target/SPIRV/Serialization.h"
#include "mlir/Translation.h" #include "mlir/Translation.h"
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

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

  • This file was moved from mlir/test/Dialect/SPIRV/arithmetic-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.FAdd // spv.FAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fadd_scalar(%arg: f32) -> f32 { func @fadd_scalar(%arg: f32) -> f32 {
// CHECK: spv.FAdd // CHECK: spv.FAdd
%0 = spv.FAdd %arg, %arg : f32 %0 = spv.FAdd %arg, %arg : f32
return %0 : f32 return %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FDiv // spv.FDiv
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fdiv_scalar(%arg: f32) -> f32 { func @fdiv_scalar(%arg: f32) -> f32 {
// CHECK: spv.FDiv // CHECK: spv.FDiv
%0 = spv.FDiv %arg, %arg : f32 %0 = spv.FDiv %arg, %arg : f32
return %0 : f32 return %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FMod // spv.FMod
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fmod_scalar(%arg: f32) -> f32 { func @fmod_scalar(%arg: f32) -> f32 {
// CHECK: spv.FMod // CHECK: spv.FMod
%0 = spv.FMod %arg, %arg : f32 %0 = spv.FMod %arg, %arg : f32
return %0 : f32 return %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FMul // spv.FMul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fmul_scalar(%arg: f32) -> f32 { func @fmul_scalar(%arg: f32) -> f32 {
// CHECK: spv.FMul // CHECK: spv.FMul
%0 = spv.FMul %arg, %arg : f32 %0 = spv.FMul %arg, %arg : f32
return %0 : f32 return %0 : f32
} }
func @fmul_vector(%arg: vector<4xf32>) -> vector<4xf32> { func @fmul_vector(%arg: vector<4xf32>) -> vector<4xf32> {
// CHECK: spv.FMul // CHECK: spv.FMul
%0 = spv.FMul %arg, %arg : vector<4xf32> %0 = spv.FMul %arg, %arg : vector<4xf32>
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }
// ----- // -----
func @fmul_i32(%arg: i32) -> i32 { func @fmul_i32(%arg: i32) -> i32 {
// expected-error @+1 {{operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} // expected-error @+1 {{operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
%0 = spv.FMul %arg, %arg : i32 %0 = spv.FMul %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
func @fmul_bf16(%arg: bf16) -> bf16 { func @fmul_bf16(%arg: bf16) -> bf16 {
// expected-error @+1 {{operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} // expected-error @+1 {{operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
%0 = spv.FMul %arg, %arg : bf16 %0 = spv.FMul %arg, %arg : bf16
return %0 : bf16 return %0 : bf16
} }
// ----- // -----
func @fmul_tensor(%arg: tensor<4xf32>) -> tensor<4xf32> { func @fmul_tensor(%arg: tensor<4xf32>) -> tensor<4xf32> {
// expected-error @+1 {{operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} // expected-error @+1 {{operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
%0 = spv.FMul %arg, %arg : tensor<4xf32> %0 = spv.FMul %arg, %arg : tensor<4xf32>
return %0 : tensor<4xf32> return %0 : tensor<4xf32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FNegate // spv.FNegate
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fnegate_scalar(%arg: f32) -> f32 { func @fnegate_scalar(%arg: f32) -> f32 {
// CHECK: spv.FNegate // CHECK: spv.FNegate
%0 = spv.FNegate %arg : f32 %0 = spv.FNegate %arg : f32
return %0 : f32 return %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FRem // spv.FRem
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @frem_scalar(%arg: f32) -> f32 { func @frem_scalar(%arg: f32) -> f32 {
// CHECK: spv.FRem // CHECK: spv.FRem
%0 = spv.FRem %arg, %arg : f32 %0 = spv.FRem %arg, %arg : f32
return %0 : f32 return %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FSub // spv.FSub
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fsub_scalar(%arg: f32) -> f32 { func @fsub_scalar(%arg: f32) -> f32 {
// CHECK: spv.FSub // CHECK: spv.FSub
%0 = spv.FSub %arg, %arg : f32 %0 = spv.FSub %arg, %arg : f32
return %0 : f32 return %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IAdd // spv.IAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @iadd_scalar(%arg: i32) -> i32 { func @iadd_scalar(%arg: i32) -> i32 {
// CHECK: spv.IAdd // CHECK: spv.IAdd
%0 = spv.IAdd %arg, %arg : i32 %0 = spv.IAdd %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.IMul // spv.IMul
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @imul_scalar(%arg: i32) -> i32 { func @imul_scalar(%arg: i32) -> i32 {
// CHECK: spv.IMul // CHECK: spv.IMul
%0 = spv.IMul %arg, %arg : i32 %0 = spv.IMul %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ISub // spv.ISub
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @isub_scalar(%arg: i32) -> i32 { func @isub_scalar(%arg: i32) -> i32 {
// CHECK: spv.ISub // CHECK: spv.ISub
%0 = spv.ISub %arg, %arg : i32 %0 = spv.ISub %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SDiv // spv.SDiv
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sdiv_scalar(%arg: i32) -> i32 { func @sdiv_scalar(%arg: i32) -> i32 {
// CHECK: spv.SDiv // CHECK: spv.SDiv
%0 = spv.SDiv %arg, %arg : i32 %0 = spv.SDiv %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SMod // spv.SMod
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @smod_scalar(%arg: i32) -> i32 { func @smod_scalar(%arg: i32) -> i32 {
// CHECK: spv.SMod // CHECK: spv.SMod
%0 = spv.SMod %arg, %arg : i32 %0 = spv.SMod %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SNegate // spv.SNegate
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @snegate_scalar(%arg: i32) -> i32 { func @snegate_scalar(%arg: i32) -> i32 {
// CHECK: spv.SNegate // CHECK: spv.SNegate
%0 = spv.SNegate %arg : i32 %0 = spv.SNegate %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SRem // spv.SRem
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @srem_scalar(%arg: i32) -> i32 { func @srem_scalar(%arg: i32) -> i32 {
// CHECK: spv.SRem // CHECK: spv.SRem
%0 = spv.SRem %arg, %arg : i32 %0 = spv.SRem %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UDiv // spv.UDiv
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @udiv_scalar(%arg: i32) -> i32 { func @udiv_scalar(%arg: i32) -> i32 {
// CHECK: spv.UDiv // CHECK: spv.UDiv
%0 = spv.UDiv %arg, %arg : i32 %0 = spv.UDiv %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UMod // spv.UMod
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @umod_scalar(%arg: i32) -> i32 { func @umod_scalar(%arg: i32) -> i32 {
// CHECK: spv.UMod // CHECK: spv.UMod
%0 = spv.UMod %arg, %arg : i32 %0 = spv.UMod %arg, %arg : i32
return %0 : i32 return %0 : i32
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/atomic-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.AtomicAnd // spv.AtomicAnd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_and(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_and(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicAnd "Device" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicAnd "Device" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicAnd "Device" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicAnd "Device" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
// ----- // -----
func @atomic_and(%ptr : !spv.ptr<f32, StorageBuffer>, %value : i32) -> i32 { func @atomic_and(%ptr : !spv.ptr<f32, StorageBuffer>, %value : i32) -> i32 {
// expected-error @+1 {{pointer operand must point to an integer value, found 'f32'}} // expected-error @+1 {{pointer operand must point to an integer value, found 'f32'}}
%0 = "spv.AtomicAnd"(%ptr, %value) {memory_scope = 4: i32, semantics = 0x4 : i32} : (!spv.ptr<f32, StorageBuffer>, i32) -> (i32) %0 = "spv.AtomicAnd"(%ptr, %value) {memory_scope = 4: i32, semantics = 0x4 : i32} : (!spv.ptr<f32, StorageBuffer>, i32) -> (i32)
return %0 : i32 return %0 : i32
} }
// ----- // -----
func @atomic_and(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i64) -> i64 { func @atomic_and(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i64) -> i64 {
// expected-error @+1 {{expected value to have the same type as the pointer operand's pointee type 'i32', but found 'i64'}} // expected-error @+1 {{expected value to have the same type as the pointer operand's pointee type 'i32', but found 'i64'}}
%0 = "spv.AtomicAnd"(%ptr, %value) {memory_scope = 2: i32, semantics = 0x8 : i32} : (!spv.ptr<i32, StorageBuffer>, i64) -> (i64) %0 = "spv.AtomicAnd"(%ptr, %value) {memory_scope = 2: i32, semantics = 0x8 : i32} : (!spv.ptr<i32, StorageBuffer>, i64) -> (i64)
return %0 : i64 return %0 : i64
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicCompareExchangeWeak // spv.AtomicCompareExchangeWeak
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 { func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 {
// CHECK: spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %{{.*}}, %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %{{.*}}, %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup> %0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup>
return %0: i32 return %0: i32
} }
// ----- // -----
func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i64, %comparator: i32) -> i32 { func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i64, %comparator: i32) -> i32 {
// expected-error @+1 {{value operand must have the same type as the op result, but found 'i64' vs 'i32'}} // expected-error @+1 {{value operand must have the same type as the op result, but found 'i64' vs 'i32'}}
%0 = "spv.AtomicCompareExchangeWeak"(%ptr, %value, %comparator) {memory_scope = 4: i32, equal_semantics = 0x4: i32, unequal_semantics = 0x2:i32} : (!spv.ptr<i32, Workgroup>, i64, i32) -> (i32) %0 = "spv.AtomicCompareExchangeWeak"(%ptr, %value, %comparator) {memory_scope = 4: i32, equal_semantics = 0x4: i32, unequal_semantics = 0x2:i32} : (!spv.ptr<i32, Workgroup>, i64, i32) -> (i32)
return %0: i32 return %0: i32
} }
// ----- // -----
func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i16) -> i32 { func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i16) -> i32 {
// expected-error @+1 {{comparator operand must have the same type as the op result, but found 'i16' vs 'i32'}} // expected-error @+1 {{comparator operand must have the same type as the op result, but found 'i16' vs 'i32'}}
%0 = "spv.AtomicCompareExchangeWeak"(%ptr, %value, %comparator) {memory_scope = 4: i32, equal_semantics = 0x4: i32, unequal_semantics = 0x2:i32} : (!spv.ptr<i32, Workgroup>, i32, i16) -> (i32) %0 = "spv.AtomicCompareExchangeWeak"(%ptr, %value, %comparator) {memory_scope = 4: i32, equal_semantics = 0x4: i32, unequal_semantics = 0x2:i32} : (!spv.ptr<i32, Workgroup>, i32, i16) -> (i32)
return %0: i32 return %0: i32
} }
// ----- // -----
func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i64, Workgroup>, %value: i32, %comparator: i32) -> i32 { func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i64, Workgroup>, %value: i32, %comparator: i32) -> i32 {
// expected-error @+1 {{pointer operand's pointee type must have the same as the op result type, but found 'i64' vs 'i32'}} // expected-error @+1 {{pointer operand's pointee type must have the same as the op result type, but found 'i64' vs 'i32'}}
%0 = "spv.AtomicCompareExchangeWeak"(%ptr, %value, %comparator) {memory_scope = 4: i32, equal_semantics = 0x4: i32, unequal_semantics = 0x2:i32} : (!spv.ptr<i64, Workgroup>, i32, i32) -> (i32) %0 = "spv.AtomicCompareExchangeWeak"(%ptr, %value, %comparator) {memory_scope = 4: i32, equal_semantics = 0x4: i32, unequal_semantics = 0x2:i32} : (!spv.ptr<i64, Workgroup>, i32, i32) -> (i32)
return %0: i32 return %0: i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicIAdd // spv.AtomicIAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_iadd(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_iadd(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicIAdd "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicIAdd "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicIAdd "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicIAdd "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicIDecrement // spv.AtomicIDecrement
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_idecrement(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 { func @atomic_idecrement(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 {
// CHECK: spv.AtomicIDecrement "Workgroup" "None" %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicIDecrement "Workgroup" "None" %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicIDecrement "Workgroup" "None" %ptr : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicIDecrement "Workgroup" "None" %ptr : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicIIncrement // spv.AtomicIIncrement
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_iincrement(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 { func @atomic_iincrement(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 {
// CHECK: spv.AtomicIIncrement "Workgroup" "None" %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicIIncrement "Workgroup" "None" %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicIIncrement "Workgroup" "None" %ptr : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicIIncrement "Workgroup" "None" %ptr : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicISub // spv.AtomicISub
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_isub(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_isub(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicISub "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicISub "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicISub "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicISub "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicOr // spv.AtomicOr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_or(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_or(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicOr "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicOr "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicOr "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicOr "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicSMax // spv.AtomicSMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_smax(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_smax(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicSMax "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicSMax "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicSMax "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicSMax "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicSMin // spv.AtomicSMin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_smin(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_smin(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicSMin "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicSMin "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicSMin "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicSMin "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicUMax // spv.AtomicUMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_umax(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_umax(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicUMax "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicUMax "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicUMax "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicUMax "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicUMin // spv.AtomicUMin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_umin(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_umin(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicUMin "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicUMin "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicUMin "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicUMin "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.AtomicXor // spv.AtomicXor
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atomic_xor(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 { func @atomic_xor(%ptr : !spv.ptr<i32, StorageBuffer>, %value : i32) -> i32 {
// CHECK: spv.AtomicXor "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer> // CHECK: spv.AtomicXor "Workgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, StorageBuffer>
%0 = spv.AtomicXor "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer> %0 = spv.AtomicXor "Workgroup" "None" %ptr, %value : !spv.ptr<i32, StorageBuffer>
return %0 : i32 return %0 : i32
} }

mlir/test/Dialect/SPIRV/IR/availability.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/availability.mlir.
// RUN: mlir-opt -mlir-disable-threading -test-spirv-op-availability %s | FileCheck %s // RUN: mlir-opt -mlir-disable-threading -test-spirv-op-availability %s | FileCheck %s
// CHECK-LABEL: iadd // CHECK-LABEL: iadd
func @iadd(%arg: i32) -> i32 { func @iadd(%arg: i32) -> i32 {
// CHECK: min version: v1.0 // CHECK: min version: v1.0
// CHECK: max version: v1.5 // CHECK: max version: v1.5
// CHECK: extensions: [ ] // CHECK: extensions: [ ]
// CHECK: capabilities: [ ] // CHECK: capabilities: [ ]
%0 = spv.IAdd %arg, %arg: i32 %0 = spv.IAdd %arg, %arg: i32
return %0: i32 return %0: i32
} }
// CHECK: atomic_compare_exchange_weak // CHECK: atomic_compare_exchange_weak
func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 { func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 {
// CHECK: min version: v1.0 // CHECK: min version: v1.0
// CHECK: max version: v1.3 // CHECK: max version: v1.3
// CHECK: extensions: [ ] // CHECK: extensions: [ ]
// CHECK: capabilities: [ [Kernel] ] // CHECK: capabilities: [ [Kernel] ]
%0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup> %0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup>
return %0: i32 return %0: i32
} }
// CHECK-LABEL: subgroup_ballot // CHECK-LABEL: subgroup_ballot
func @subgroup_ballot(%predicate: i1) -> vector<4xi32> { func @subgroup_ballot(%predicate: i1) -> vector<4xi32> {
// CHECK: min version: v1.3 // CHECK: min version: v1.3
// CHECK: max version: v1.5 // CHECK: max version: v1.5
// CHECK: extensions: [ ] // CHECK: extensions: [ ]
// CHECK: capabilities: [ [GroupNonUniformBallot] ] // CHECK: capabilities: [ [GroupNonUniformBallot] ]
%0 = spv.GroupNonUniformBallot "Workgroup" %predicate : vector<4xi32> %0 = spv.GroupNonUniformBallot "Workgroup" %predicate : vector<4xi32>
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// CHECK-LABEL: module_logical_glsl450 // CHECK-LABEL: module_logical_glsl450
func @module_logical_glsl450() { func @module_logical_glsl450() {
// CHECK: spv.module min version: v1.0 // CHECK: spv.module min version: v1.0
// CHECK: spv.module max version: v1.5 // CHECK: spv.module max version: v1.5
// CHECK: spv.module extensions: [ ] // CHECK: spv.module extensions: [ ]
// CHECK: spv.module capabilities: [ [Shader] ] // CHECK: spv.module capabilities: [ [Shader] ]
spv.module Logical GLSL450 { } spv.module Logical GLSL450 { }
return return
} }
// CHECK-LABEL: module_physical_storage_buffer64_vulkan // CHECK-LABEL: module_physical_storage_buffer64_vulkan
func @module_physical_storage_buffer64_vulkan() { func @module_physical_storage_buffer64_vulkan() {
// CHECK: spv.module min version: v1.0 // CHECK: spv.module min version: v1.0
// CHECK: spv.module max version: v1.5 // CHECK: spv.module max version: v1.5
// CHECK: spv.module extensions: [ [SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer] [SPV_KHR_vulkan_memory_model] ] // CHECK: spv.module extensions: [ [SPV_EXT_physical_storage_buffer, SPV_KHR_physical_storage_buffer] [SPV_KHR_vulkan_memory_model] ]
// CHECK: spv.module capabilities: [ [PhysicalStorageBufferAddresses] [VulkanMemoryModel] ] // CHECK: spv.module capabilities: [ [PhysicalStorageBufferAddresses] [VulkanMemoryModel] ]
spv.module PhysicalStorageBuffer64 Vulkan { } spv.module PhysicalStorageBuffer64 Vulkan { }
return return
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/bit-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.BitwiseOr // spv.BitwiseOr
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bitwise_or_scalar(%arg: i32) -> i32 { func @bitwise_or_scalar(%arg: i32) -> i32 {
// CHECK: spv.BitwiseOr // CHECK: spv.BitwiseOr
%0 = spv.BitwiseOr %arg, %arg : i32 %0 = spv.BitwiseOr %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
func @bitwise_or_vector(%arg: vector<4xi32>) -> vector<4xi32> { func @bitwise_or_vector(%arg: vector<4xi32>) -> vector<4xi32> {
// CHECK: spv.BitwiseOr // CHECK: spv.BitwiseOr
%0 = spv.BitwiseOr %arg, %arg : vector<4xi32> %0 = spv.BitwiseOr %arg, %arg : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// ----- // -----
func @bitwise_or_float(%arg0: f16, %arg1: f16) -> f16 { func @bitwise_or_float(%arg0: f16, %arg1: f16) -> f16 {
// expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}} // expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}}
%0 = spv.BitwiseOr %arg0, %arg1 : f16 %0 = spv.BitwiseOr %arg0, %arg1 : f16
return %0 : f16 return %0 : f16
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitwiseXor // spv.BitwiseXor
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bitwise_xor_scalar(%arg: i32) -> i32 { func @bitwise_xor_scalar(%arg: i32) -> i32 {
// CHECK: spv.BitwiseXor // CHECK: spv.BitwiseXor
%0 = spv.BitwiseXor %arg, %arg : i32 %0 = spv.BitwiseXor %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
func @bitwise_xor_vector(%arg: vector<4xi32>) -> vector<4xi32> { func @bitwise_xor_vector(%arg: vector<4xi32>) -> vector<4xi32> {
// CHECK: spv.BitwiseXor // CHECK: spv.BitwiseXor
%0 = spv.BitwiseXor %arg, %arg : vector<4xi32> %0 = spv.BitwiseXor %arg, %arg : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// ----- // -----
func @bitwise_xor_float(%arg0: f16, %arg1: f16) -> f16 { func @bitwise_xor_float(%arg0: f16, %arg1: f16) -> f16 {
// expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}} // expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}}
%0 = spv.BitwiseXor %arg0, %arg1 : f16 %0 = spv.BitwiseXor %arg0, %arg1 : f16
return %0 : f16 return %0 : f16
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitwiseAnd // spv.BitwiseAnd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bitwise_and_scalar(%arg: i32) -> i32 { func @bitwise_and_scalar(%arg: i32) -> i32 {
// CHECK: spv.BitwiseAnd // CHECK: spv.BitwiseAnd
%0 = spv.BitwiseAnd %arg, %arg : i32 %0 = spv.BitwiseAnd %arg, %arg : i32
return %0 : i32 return %0 : i32
} }
func @bitwise_and_vector(%arg: vector<4xi32>) -> vector<4xi32> { func @bitwise_and_vector(%arg: vector<4xi32>) -> vector<4xi32> {
// CHECK: spv.BitwiseAnd // CHECK: spv.BitwiseAnd
%0 = spv.BitwiseAnd %arg, %arg : vector<4xi32> %0 = spv.BitwiseAnd %arg, %arg : vector<4xi32>
return %0 : vector<4xi32> return %0 : vector<4xi32>
} }
// ----- // -----
func @bitwise_and_float(%arg0: f16, %arg1: f16) -> f16 { func @bitwise_and_float(%arg0: f16, %arg1: f16) -> f16 {
// expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}} // expected-error @+1 {{operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}}
%0 = spv.BitwiseAnd %arg0, %arg1 : f16 %0 = spv.BitwiseAnd %arg0, %arg1 : f16
return %0 : f16 return %0 : f16
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/composite-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.CompositeConstruct // spv.CompositeConstruct
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @composite_construct_vector(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xf32> { func @composite_construct_vector(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xf32> {
// CHECK: spv.CompositeConstruct {{%.*}}, {{%.*}}, {{%.*}} : vector<3xf32> // CHECK: spv.CompositeConstruct {{%.*}}, {{%.*}}, {{%.*}} : vector<3xf32>
%0 = spv.CompositeConstruct %arg0, %arg1, %arg2 : vector<3xf32> %0 = spv.CompositeConstruct %arg0, %arg1, %arg2 : vector<3xf32>
return %0: vector<3xf32> return %0: vector<3xf32>
} }
// ----- // -----
func @composite_construct_struct(%arg0: vector<3xf32>, %arg1: !spv.array<4xf32>, %arg2 : !spv.struct<(f32)>) -> !spv.struct<(vector<3xf32>, !spv.array<4xf32>, !spv.struct<(f32)>)> { func @composite_construct_struct(%arg0: vector<3xf32>, %arg1: !spv.array<4xf32>, %arg2 : !spv.struct<(f32)>) -> !spv.struct<(vector<3xf32>, !spv.array<4xf32>, !spv.struct<(f32)>)> {
// CHECK: spv.CompositeConstruct %arg0, %arg1, %arg2 : !spv.struct<(vector<3xf32>, !spv.array<4 x f32>, !spv.struct<(f32)>)> // CHECK: spv.CompositeConstruct %arg0, %arg1, %arg2 : !spv.struct<(vector<3xf32>, !spv.array<4 x f32>, !spv.struct<(f32)>)>
%0 = spv.CompositeConstruct %arg0, %arg1, %arg2 : !spv.struct<(vector<3xf32>, !spv.array<4xf32>, !spv.struct<(f32)>)> %0 = spv.CompositeConstruct %arg0, %arg1, %arg2 : !spv.struct<(vector<3xf32>, !spv.array<4xf32>, !spv.struct<(f32)>)>
return %0: !spv.struct<(vector<3xf32>, !spv.array<4xf32>, !spv.struct<(f32)>)> return %0: !spv.struct<(vector<3xf32>, !spv.array<4xf32>, !spv.struct<(f32)>)>
} }
// ----- // -----
func @composite_construct_coopmatrix(%arg0 : f32) -> !spv.coopmatrix<8x16xf32, Subgroup> { func @composite_construct_coopmatrix(%arg0 : f32) -> !spv.coopmatrix<8x16xf32, Subgroup> {
// CHECK: spv.CompositeConstruct {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: spv.CompositeConstruct {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup>
%0 = spv.CompositeConstruct %arg0 : !spv.coopmatrix<8x16xf32, Subgroup> %0 = spv.CompositeConstruct %arg0 : !spv.coopmatrix<8x16xf32, Subgroup>
return %0: !spv.coopmatrix<8x16xf32, Subgroup> return %0: !spv.coopmatrix<8x16xf32, Subgroup>
} }
// ----- // -----
func @composite_construct_empty_struct() -> !spv.struct<()> { func @composite_construct_empty_struct() -> !spv.struct<()> {
// CHECK: spv.CompositeConstruct : !spv.struct<()> // CHECK: spv.CompositeConstruct : !spv.struct<()>
%0 = spv.CompositeConstruct : !spv.struct<()> %0 = spv.CompositeConstruct : !spv.struct<()>
return %0: !spv.struct<()> return %0: !spv.struct<()>
} }
// ----- // -----
func @composite_construct_invalid_num_of_elements(%arg0: f32) -> f32 { func @composite_construct_invalid_num_of_elements(%arg0: f32) -> f32 {
// expected-error @+1 {{result type must be a composite type, but provided 'f32'}} // expected-error @+1 {{result type must be a composite type, but provided 'f32'}}
%0 = spv.CompositeConstruct %arg0 : f32 %0 = spv.CompositeConstruct %arg0 : f32
return %0: f32 return %0: f32
} }
// ----- // -----
func @composite_construct_invalid_result_type(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xf32> { func @composite_construct_invalid_result_type(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xf32> {
// expected-error @+1 {{has incorrect number of operands: expected 3, but provided 2}} // expected-error @+1 {{has incorrect number of operands: expected 3, but provided 2}}
%0 = spv.CompositeConstruct %arg0, %arg2 : vector<3xf32> %0 = spv.CompositeConstruct %arg0, %arg2 : vector<3xf32>
return %0: vector<3xf32> return %0: vector<3xf32>
} }
// ----- // -----
func @composite_construct_invalid_operand_type(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xi32> { func @composite_construct_invalid_operand_type(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xi32> {
// expected-error @+1 {{operand type mismatch: expected operand type 'i32', but provided 'f32'}} // expected-error @+1 {{operand type mismatch: expected operand type 'i32', but provided 'f32'}}
%0 = "spv.CompositeConstruct" (%arg0, %arg1, %arg2) : (f32, f32, f32) -> vector<3xi32> %0 = "spv.CompositeConstruct" (%arg0, %arg1, %arg2) : (f32, f32, f32) -> vector<3xi32>
return %0: vector<3xi32> return %0: vector<3xi32>
} }
// ----- // -----
func @composite_construct_coopmatrix(%arg0 : f32, %arg1 : f32) -> !spv.coopmatrix<8x16xf32, Subgroup> { func @composite_construct_coopmatrix(%arg0 : f32, %arg1 : f32) -> !spv.coopmatrix<8x16xf32, Subgroup> {
// expected-error @+1 {{has incorrect number of operands: expected 1, but provided 2}} // expected-error @+1 {{has incorrect number of operands: expected 1, but provided 2}}
%0 = spv.CompositeConstruct %arg0, %arg1 : !spv.coopmatrix<8x16xf32, Subgroup> %0 = spv.CompositeConstruct %arg0, %arg1 : !spv.coopmatrix<8x16xf32, Subgroup>
return %0: !spv.coopmatrix<8x16xf32, Subgroup> return %0: !spv.coopmatrix<8x16xf32, Subgroup>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeExtractOp // spv.CompositeExtractOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @composite_extract_array(%arg0: !spv.array<4xf32>) -> f32 { func @composite_extract_array(%arg0: !spv.array<4xf32>) -> f32 {
// CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[1 : i32] : !spv.array<4 x f32> // CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[1 : i32] : !spv.array<4 x f32>
%0 = spv.CompositeExtract %arg0[1 : i32] : !spv.array<4xf32> %0 = spv.CompositeExtract %arg0[1 : i32] : !spv.array<4xf32>
return %0: f32 return %0: f32
} }
// ----- // -----
func @composite_extract_struct(%arg0 : !spv.struct<(f32, !spv.array<4xf32>)>) -> f32 { func @composite_extract_struct(%arg0 : !spv.struct<(f32, !spv.array<4xf32>)>) -> f32 {
// CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[1 : i32, 2 : i32] : !spv.struct<(f32, !spv.array<4 x f32>)> // CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[1 : i32, 2 : i32] : !spv.struct<(f32, !spv.array<4 x f32>)>
%0 = spv.CompositeExtract %arg0[1 : i32, 2 : i32] : !spv.struct<(f32, !spv.array<4xf32>)> %0 = spv.CompositeExtract %arg0[1 : i32, 2 : i32] : !spv.struct<(f32, !spv.array<4xf32>)>
return %0 : f32 return %0 : f32
} }
// ----- // -----
func @composite_extract_vector(%arg0 : vector<4xf32>) -> f32 { func @composite_extract_vector(%arg0 : vector<4xf32>) -> f32 {
// CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[1 : i32] : vector<4xf32> // CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[1 : i32] : vector<4xf32>
%0 = spv.CompositeExtract %arg0[1 : i32] : vector<4xf32> %0 = spv.CompositeExtract %arg0[1 : i32] : vector<4xf32>
return %0 : f32 return %0 : f32
} }
// ----- // -----
func @composite_extract_coopmatrix(%arg0 : !spv.coopmatrix<8x16xf32, Subgroup>) -> f32 { func @composite_extract_coopmatrix(%arg0 : !spv.coopmatrix<8x16xf32, Subgroup>) -> f32 {
// CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[2 : i32] : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: {{%.*}} = spv.CompositeExtract {{%.*}}[2 : i32] : !spv.coopmatrix<8x16xf32, Subgroup>
%0 = spv.CompositeExtract %arg0[2 : i32] : !spv.coopmatrix<8x16xf32, Subgroup> %0 = spv.CompositeExtract %arg0[2 : i32] : !spv.coopmatrix<8x16xf32, Subgroup>
return %0 : f32 return %0 : f32
} }
// ----- // -----
func @composite_extract_no_ssa_operand() -> () { func @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
} }
// ----- // -----
func @composite_extract_invalid_index_type_2(%arg0 : !spv.array<4x!spv.array<4xf32>>) -> () { func @composite_extract_invalid_index_type_2(%arg0 : !spv.array<4x!spv.array<4xf32>>) -> () {
// expected-error @+1 {{attribute 'indices' failed to satisfy constraint: 32-bit integer array attribute}} // expected-error @+1 {{attribute 'indices' failed to satisfy constraint: 32-bit integer array attribute}}
%0 = spv.CompositeExtract %arg0[1] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg0[1] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_invalid_index_identifier(%arg0 : !spv.array<4x!spv.array<4xf32>>) -> () { func @composite_extract_invalid_index_identifier(%arg0 : !spv.array<4x!spv.array<4xf32>>) -> () {
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
%0 = spv.CompositeExtract %arg0 ]1 : i32) : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg0 ]1 : i32) : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_2D_array_out_of_bounds_access_1(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () { func @composite_extract_2D_array_out_of_bounds_access_1(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () {
// expected-error @+1 {{index 4 out of bounds for '!spv.array<4 x !spv.array<4 x f32>>'}} // expected-error @+1 {{index 4 out of bounds for '!spv.array<4 x !spv.array<4 x f32>>'}}
%0 = spv.CompositeExtract %arg0[4 : i32, 1 : i32] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg0[4 : i32, 1 : i32] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_2D_array_out_of_bounds_access_2(%arg0: !spv.array<4x!spv.array<4xf32>> func @composite_extract_2D_array_out_of_bounds_access_2(%arg0: !spv.array<4x!spv.array<4xf32>>
) -> () { ) -> () {
// expected-error @+1 {{index 4 out of bounds for '!spv.array<4 x f32>'}} // expected-error @+1 {{index 4 out of bounds for '!spv.array<4 x f32>'}}
%0 = spv.CompositeExtract %arg0[1 : i32, 4 : i32] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg0[1 : i32, 4 : i32] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_struct_element_out_of_bounds_access(%arg0 : !spv.struct<(f32, !spv.array<4xf32>)>) -> () { func @composite_extract_struct_element_out_of_bounds_access(%arg0 : !spv.struct<(f32, !spv.array<4xf32>)>) -> () {
// expected-error @+1 {{index 2 out of bounds for '!spv.struct<(f32, !spv.array<4 x f32>)>'}} // expected-error @+1 {{index 2 out of bounds for '!spv.struct<(f32, !spv.array<4 x f32>)>'}}
%0 = spv.CompositeExtract %arg0[2 : i32, 0 : i32] : !spv.struct<(f32, !spv.array<4xf32>)> %0 = spv.CompositeExtract %arg0[2 : i32, 0 : i32] : !spv.struct<(f32, !spv.array<4xf32>)>
return return
} }
// ----- // -----
func @composite_extract_vector_out_of_bounds_access(%arg0: vector<4xf32>) -> () { func @composite_extract_vector_out_of_bounds_access(%arg0: vector<4xf32>) -> () {
// expected-error @+1 {{index 4 out of bounds for 'vector<4xf32>'}} // expected-error @+1 {{index 4 out of bounds for 'vector<4xf32>'}}
%0 = spv.CompositeExtract %arg0[4 : i32] : vector<4xf32> %0 = spv.CompositeExtract %arg0[4 : i32] : vector<4xf32>
return return
} }
// ----- // -----
func @composite_extract_invalid_types_1(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () { func @composite_extract_invalid_types_1(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () {
// expected-error @+1 {{cannot extract from non-composite type 'f32' with index 3}} // expected-error @+1 {{cannot extract from non-composite type 'f32' with index 3}}
%0 = spv.CompositeExtract %arg0[1 : i32, 2 : i32, 3 : i32] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg0[1 : i32, 2 : i32, 3 : i32] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_invalid_types_2(%arg0: f32) -> () { func @composite_extract_invalid_types_2(%arg0: f32) -> () {
// expected-error @+1 {{cannot extract from non-composite type 'f32' with index 1}} // expected-error @+1 {{cannot extract from non-composite type 'f32' with index 1}}
%0 = spv.CompositeExtract %arg0[1 : i32] : f32 %0 = spv.CompositeExtract %arg0[1 : i32] : f32
return return
} }
// ----- // -----
func @composite_extract_invalid_extracted_type(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () { func @composite_extract_invalid_extracted_type(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () {
// expected-error @+1 {{expected at least one index for spv.CompositeExtract}} // expected-error @+1 {{expected at least one index for spv.CompositeExtract}}
%0 = spv.CompositeExtract %arg0[] : !spv.array<4x!spv.array<4xf32>> %0 = spv.CompositeExtract %arg0[] : !spv.array<4x!spv.array<4xf32>>
return return
} }
// ----- // -----
func @composite_extract_result_type_mismatch(%arg0: !spv.array<4xf32>) -> i32 { func @composite_extract_result_type_mismatch(%arg0: !spv.array<4xf32>) -> i32 {
// expected-error @+1 {{invalid result type: expected 'f32' but provided 'i32'}} // expected-error @+1 {{invalid result type: expected 'f32' but provided 'i32'}}
%0 = "spv.CompositeExtract"(%arg0) {indices = [2: i32]} : (!spv.array<4xf32>) -> (i32) %0 = "spv.CompositeExtract"(%arg0) {indices = [2: i32]} : (!spv.array<4xf32>) -> (i32)
return %0: i32 return %0: i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.CompositeInsert // spv.CompositeInsert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @composite_insert_array(%arg0: !spv.array<4xf32>, %arg1: f32) -> !spv.array<4xf32> { func @composite_insert_array(%arg0: !spv.array<4xf32>, %arg1: f32) -> !spv.array<4xf32> {
// CHECK: {{%.*}} = spv.CompositeInsert {{%.*}}, {{%.*}}[1 : i32] : f32 into !spv.array<4 x f32> // CHECK: {{%.*}} = spv.CompositeInsert {{%.*}}, {{%.*}}[1 : i32] : f32 into !spv.array<4 x f32>
%0 = spv.CompositeInsert %arg1, %arg0[1 : i32] : f32 into !spv.array<4xf32> %0 = spv.CompositeInsert %arg1, %arg0[1 : i32] : f32 into !spv.array<4xf32>
return %0: !spv.array<4xf32> return %0: !spv.array<4xf32>
} }
// ----- // -----
func @composite_insert_struct(%arg0: !spv.struct<(!spv.array<4xf32>, f32)>, %arg1: !spv.array<4xf32>) -> !spv.struct<(!spv.array<4xf32>, f32)> { func @composite_insert_struct(%arg0: !spv.struct<(!spv.array<4xf32>, f32)>, %arg1: !spv.array<4xf32>) -> !spv.struct<(!spv.array<4xf32>, f32)> {
// CHECK: {{%.*}} = spv.CompositeInsert {{%.*}}, {{%.*}}[0 : i32] : !spv.array<4 x f32> into !spv.struct<(!spv.array<4 x f32>, f32)> // CHECK: {{%.*}} = spv.CompositeInsert {{%.*}}, {{%.*}}[0 : i32] : !spv.array<4 x f32> into !spv.struct<(!spv.array<4 x f32>, f32)>
%0 = spv.CompositeInsert %arg1, %arg0[0 : i32] : !spv.array<4xf32> into !spv.struct<(!spv.array<4xf32>, f32)> %0 = spv.CompositeInsert %arg1, %arg0[0 : i32] : !spv.array<4xf32> into !spv.struct<(!spv.array<4xf32>, f32)>
return %0: !spv.struct<(!spv.array<4xf32>, f32)> return %0: !spv.struct<(!spv.array<4xf32>, f32)>
} }
// ----- // -----
func @composite_insert_coopmatrix(%arg0: !spv.coopmatrix<8x16xi32, Subgroup>, %arg1: i32) -> !spv.coopmatrix<8x16xi32, Subgroup> { func @composite_insert_coopmatrix(%arg0: !spv.coopmatrix<8x16xi32, Subgroup>, %arg1: i32) -> !spv.coopmatrix<8x16xi32, Subgroup> {
// CHECK: {{%.*}} = spv.CompositeInsert {{%.*}}, {{%.*}}[5 : i32] : i32 into !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.CompositeInsert {{%.*}}, {{%.*}}[5 : i32] : i32 into !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.CompositeInsert %arg1, %arg0[5 : i32] : i32 into !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CompositeInsert %arg1, %arg0[5 : i32] : i32 into !spv.coopmatrix<8x16xi32, Subgroup>
return %0: !spv.coopmatrix<8x16xi32, Subgroup> return %0: !spv.coopmatrix<8x16xi32, Subgroup>
} }
// ----- // -----
func @composite_insert_no_indices(%arg0: !spv.array<4xf32>, %arg1: f32) -> !spv.array<4xf32> { func @composite_insert_no_indices(%arg0: !spv.array<4xf32>, %arg1: f32) -> !spv.array<4xf32> {
// expected-error @+1 {{expected at least one index}} // expected-error @+1 {{expected at least one index}}
%0 = spv.CompositeInsert %arg1, %arg0[] : f32 into !spv.array<4xf32> %0 = spv.CompositeInsert %arg1, %arg0[] : f32 into !spv.array<4xf32>
return %0: !spv.array<4xf32> return %0: !spv.array<4xf32>
} }
// ----- // -----
func @composite_insert_out_of_bounds(%arg0: !spv.array<4xf32>, %arg1: f32) -> !spv.array<4xf32> { func @composite_insert_out_of_bounds(%arg0: !spv.array<4xf32>, %arg1: f32) -> !spv.array<4xf32> {
// expected-error @+1 {{index 4 out of bounds}} // expected-error @+1 {{index 4 out of bounds}}
%0 = spv.CompositeInsert %arg1, %arg0[4 : i32] : f32 into !spv.array<4xf32> %0 = spv.CompositeInsert %arg1, %arg0[4 : i32] : f32 into !spv.array<4xf32>
return %0: !spv.array<4xf32> return %0: !spv.array<4xf32>
} }
// ----- // -----
func @composite_insert_invalid_object_type(%arg0: !spv.array<4xf32>, %arg1: f64) -> !spv.array<4xf32> { func @composite_insert_invalid_object_type(%arg0: !spv.array<4xf32>, %arg1: f64) -> !spv.array<4xf32> {
// expected-error @+1 {{object operand type should be 'f32', but found 'f64'}} // expected-error @+1 {{object operand type should be 'f32', but found 'f64'}}
%0 = spv.CompositeInsert %arg1, %arg0[3 : i32] : f64 into !spv.array<4xf32> %0 = spv.CompositeInsert %arg1, %arg0[3 : i32] : f64 into !spv.array<4xf32>
return %0: !spv.array<4xf32> return %0: !spv.array<4xf32>
} }
// ----- // -----
func @composite_insert_invalid_result_type(%arg0: !spv.array<4xf32>, %arg1 : f32) -> !spv.array<4xf64> { func @composite_insert_invalid_result_type(%arg0: !spv.array<4xf32>, %arg1 : f32) -> !spv.array<4xf64> {
// expected-error @+1 {{result type should be the same as the composite type, but found '!spv.array<4 x f32>' vs '!spv.array<4 x f64>'}} // expected-error @+1 {{result type should be the same as the composite type, but found '!spv.array<4 x f32>' vs '!spv.array<4 x f64>'}}
%0 = "spv.CompositeInsert"(%arg1, %arg0) {indices = [0: i32]} : (f32, !spv.array<4xf32>) -> !spv.array<4xf64> %0 = "spv.CompositeInsert"(%arg1, %arg0) {indices = [0: i32]} : (f32, !spv.array<4xf32>) -> !spv.array<4xf64>
return %0: !spv.array<4xf64> return %0: !spv.array<4xf64>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.VectorExtractDynamic // spv.VectorExtractDynamic
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @vector_dynamic_extract(%vec: vector<4xf32>, %id : i32) -> f32 { func @vector_dynamic_extract(%vec: vector<4xf32>, %id : i32) -> f32 {
// CHECK: spv.VectorExtractDynamic %{{.*}}[%{{.*}}] : vector<4xf32>, i32 // CHECK: spv.VectorExtractDynamic %{{.*}}[%{{.*}}] : vector<4xf32>, i32
%0 = spv.VectorExtractDynamic %vec[%id] : vector<4xf32>, i32 %0 = spv.VectorExtractDynamic %vec[%id] : vector<4xf32>, i32
return %0 : f32 return %0 : f32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.VectorInsertDynamic // spv.VectorInsertDynamic
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @vector_dynamic_insert(%val: f32, %vec: vector<4xf32>, %id : i32) -> vector<4xf32> { func @vector_dynamic_insert(%val: f32, %vec: vector<4xf32>, %id : i32) -> vector<4xf32> {
// CHECK: spv.VectorInsertDynamic %{{.*}}, %{{.*}}[%{{.*}}] : vector<4xf32>, i32 // CHECK: spv.VectorInsertDynamic %{{.*}}, %{{.*}}[%{{.*}}] : vector<4xf32>, i32
%0 = spv.VectorInsertDynamic %val, %vec[%id] : vector<4xf32>, i32 %0 = spv.VectorInsertDynamic %val, %vec[%id] : vector<4xf32>, i32
return %0 : vector<4xf32> return %0 : vector<4xf32>
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/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
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FunctionCall // spv.FunctionCall
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @fmain(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>, %arg2 : i32) -> i32 "None" { spv.func @fmain(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>, %arg2 : i32) -> i32 "None" {
// CHECK: {{%.*}} = spv.FunctionCall @f_0({{%.*}}, {{%.*}}) : (vector<4xf32>, vector<4xf32>) -> vector<4xf32> // CHECK: {{%.*}} = spv.FunctionCall @f_0({{%.*}}, {{%.*}}) : (vector<4xf32>, vector<4xf32>) -> vector<4xf32>
%0 = spv.FunctionCall @f_0(%arg0, %arg1) : (vector<4xf32>, vector<4xf32>) -> vector<4xf32> %0 = spv.FunctionCall @f_0(%arg0, %arg1) : (vector<4xf32>, vector<4xf32>) -> vector<4xf32>
// CHECK: spv.FunctionCall @f_1({{%.*}}, {{%.*}}) : (vector<4xf32>, vector<4xf32>) -> () // CHECK: spv.FunctionCall @f_1({{%.*}}, {{%.*}}) : (vector<4xf32>, vector<4xf32>) -> ()
spv.FunctionCall @f_1(%0, %arg1) : (vector<4xf32>, vector<4xf32>) -> () spv.FunctionCall @f_1(%0, %arg1) : (vector<4xf32>, vector<4xf32>) -> ()
// CHECK: spv.FunctionCall @f_2() : () -> () // CHECK: spv.FunctionCall @f_2() : () -> ()
spv.FunctionCall @f_2() : () -> () spv.FunctionCall @f_2() : () -> ()
// CHECK: {{%.*}} = spv.FunctionCall @f_3({{%.*}}) : (i32) -> i32 // CHECK: {{%.*}} = spv.FunctionCall @f_3({{%.*}}) : (i32) -> i32
%1 = spv.FunctionCall @f_3(%arg2) : (i32) -> i32 %1 = spv.FunctionCall @f_3(%arg2) : (i32) -> i32
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
spv.func @f_0(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> (vector<4xf32>) "None" { spv.func @f_0(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> (vector<4xf32>) "None" {
spv.ReturnValue %arg0 : vector<4xf32> spv.ReturnValue %arg0 : vector<4xf32>
} }
spv.func @f_1(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> () "None" { spv.func @f_1(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) -> () "None" {
spv.Return spv.Return
} }
spv.func @f_2() -> () "None" { spv.func @f_2() -> () "None" {
spv.Return spv.Return
} }
spv.func @f_3(%arg0 : i32) -> (i32) "None" { spv.func @f_3(%arg0 : i32) -> (i32) "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
// ----- // -----
// Allow calling functions in other module-like ops // Allow calling functions in other module-like ops
spv.func @callee() "None" { spv.func @callee() "None" {
spv.Return spv.Return
} }
func @caller() { func @caller() {
// CHECK: spv.FunctionCall // CHECK: spv.FunctionCall
spv.FunctionCall @callee() : () -> () spv.FunctionCall @callee() : () -> ()
spv.Return spv.Return
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @f_invalid_result_type(%arg0 : i32, %arg1 : i32) -> () "None" { spv.func @f_invalid_result_type(%arg0 : i32, %arg1 : i32) -> () "None" {
// expected-error @+1 {{result group starting at #0 requires 0 or 1 element, but found 2}} // expected-error @+1 {{result group starting at #0 requires 0 or 1 element, but found 2}}
%0:2 = spv.FunctionCall @f_invalid_result_type(%arg0, %arg1) : (i32, i32) -> (i32, i32) %0:2 = spv.FunctionCall @f_invalid_result_type(%arg0, %arg1) : (i32, i32) -> (i32, i32)
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @f_result_type_mismatch(%arg0 : i32, %arg1 : i32) -> () "None" { spv.func @f_result_type_mismatch(%arg0 : i32, %arg1 : i32) -> () "None" {
// expected-error @+1 {{has incorrect number of results has for callee: expected 0, but provided 1}} // expected-error @+1 {{has incorrect number of results has for callee: expected 0, but provided 1}}
%1 = spv.FunctionCall @f_result_type_mismatch(%arg0, %arg0) : (i32, i32) -> (i32) %1 = spv.FunctionCall @f_result_type_mismatch(%arg0, %arg0) : (i32, i32) -> (i32)
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" {
// expected-error @+1 {{has incorrect number of operands for callee: expected 2, but provided 1}} // expected-error @+1 {{has incorrect number of operands for callee: expected 2, but provided 1}}
spv.FunctionCall @f_type_mismatch(%arg0) : (i32) -> () spv.FunctionCall @f_type_mismatch(%arg0) : (i32) -> ()
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:
^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
// CHECK: spv.BranchConditional %{{.*}}, ^bb2, ^bb4 // CHECK: spv.BranchConditional %{{.*}}, ^bb2, ^bb4
spv.BranchConditional %cmp, ^body, ^merge spv.BranchConditional %cmp, ^body, ^merge
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^body: ^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:
%val1 = spv.Load "Function" %var : i32 %val1 = spv.Load "Function" %var : i32
%add = spv.IAdd %val1, %one : i32 %add = spv.IAdd %val1, %one : i32
spv.Store "Function" %var, %add : i32 spv.Store "Function" %var, %add : i32
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
spv.Branch ^header spv.Branch ^header
// CHECK-NEXT: ^bb4: // CHECK-NEXT: ^bb4:
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
// CHECK-LABEL: @empty_region // CHECK-LABEL: @empty_region
func @empty_region() -> () { func @empty_region() -> () {
// CHECK: spv.loop // CHECK: spv.loop
spv.loop { spv.loop {
} }
return return
} }
// ----- // -----
// CHECK-LABEL: @loop_with_control // CHECK-LABEL: @loop_with_control
func @loop_with_control() -> () { func @loop_with_control() -> () {
// CHECK: spv.loop control(Unroll) // CHECK: spv.loop control(Unroll)
spv.loop control(Unroll) { spv.loop control(Unroll) {
} }
return return
} }
// ----- // -----
func @wrong_merge_block() -> () { func @wrong_merge_block() -> () {
// expected-error @+1 {{last block must be the merge block with only one 'spv.mlir.merge' op}} // expected-error @+1 {{last block must be the merge block with only one 'spv.mlir.merge' op}}
spv.loop { spv.loop {
spv.Return spv.Return
} }
return return
} }
// ----- // -----
func @missing_entry_block() -> () { func @missing_entry_block() -> () {
// expected-error @+1 {{must have an entry block branching to the loop header block}} // expected-error @+1 {{must have an entry block branching to the loop header block}}
spv.loop { spv.loop {
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
func @missing_header_block() -> () { func @missing_header_block() -> () {
// expected-error @+1 {{must have a loop header block branched from the entry block}} // expected-error @+1 {{must have a loop header block branched from the entry block}}
spv.loop { spv.loop {
^entry: ^entry:
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
func @entry_should_branch_to_header() -> () { func @entry_should_branch_to_header() -> () {
// expected-error @+1 {{entry block must only have one 'spv.Branch' op to the second block}} // expected-error @+1 {{entry block must only have one 'spv.Branch' op to the second block}}
spv.loop { spv.loop {
^entry: ^entry:
spv.Branch ^merge spv.Branch ^merge
^header: ^header:
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
func @missing_continue_block() -> () { func @missing_continue_block() -> () {
// expected-error @+1 {{requires a loop continue block branching to the loop header block}} // expected-error @+1 {{requires a loop continue block branching to the loop header block}}
spv.loop { spv.loop {
^entry: ^entry:
spv.Branch ^header spv.Branch ^header
^header: ^header:
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
func @continue_should_branch_to_header() -> () { func @continue_should_branch_to_header() -> () {
// expected-error @+1 {{second to last block must be the loop continue block that branches to the loop header block}} // expected-error @+1 {{second to last block must be the loop continue block that branches to the loop header block}}
spv.loop { spv.loop {
^entry: ^entry:
spv.Branch ^header spv.Branch ^header
^header: ^header:
spv.Branch ^continue spv.Branch ^continue
^continue: ^continue:
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
func @only_entry_and_continue_branch_to_header() -> () { func @only_entry_and_continue_branch_to_header() -> () {
// expected-error @+1 {{can only have the entry and loop continue block branching to the loop header block}} // expected-error @+1 {{can only have the entry and loop continue block branching to the loop header block}}
spv.loop { spv.loop {
^entry: ^entry:
spv.Branch ^header spv.Branch ^header
^header: ^header:
spv.Branch ^cont1 spv.Branch ^cont1
^cont1: ^cont1:
spv.Branch ^header spv.Branch ^header
^cont2: ^cont2:
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.mlir.merge // spv.mlir.merge
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
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:
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Return // spv.Return
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: func @in_selection // CHECK-LABEL: func @in_selection
func @in_selection(%cond : i1) -> () { func @in_selection(%cond : i1) -> () {
spv.selection { spv.selection {
spv.BranchConditional %cond, ^then, ^merge spv.BranchConditional %cond, ^then, ^merge
^then: ^then:
// CHECK: spv.Return // CHECK: spv.Return
spv.Return spv.Return
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// CHECK-LABEL: func @in_loop // CHECK-LABEL: func @in_loop
func @in_loop(%cond : i1) -> () { func @in_loop(%cond : i1) -> () {
spv.loop { spv.loop {
spv.Branch ^header spv.Branch ^header
^header: ^header:
spv.BranchConditional %cond, ^body, ^merge spv.BranchConditional %cond, ^body, ^merge
^body: ^body:
// CHECK: spv.Return // CHECK: spv.Return
spv.Return spv.Return
^continue: ^continue:
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// CHECK-LABEL: in_other_func_like_op // CHECK-LABEL: in_other_func_like_op
func @in_other_func_like_op() { func @in_other_func_like_op() {
// CHECK: spv.Return // CHECK: spv.Return
spv.Return spv.Return
} }
// ----- // -----
"foo.function"() ({ "foo.function"() ({
// 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.Return spv.Return
}) : () -> () }) : () -> ()
// ----- // -----
// Return mismatches function signature // Return mismatches function signature
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @work() -> (i32) "None" { spv.func @work() -> (i32) "None" {
// expected-error @+1 {{cannot be used in functions returning value}} // expected-error @+1 {{cannot be used in functions returning value}}
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @in_nested_region(%cond: i1) -> (i32) "None" { spv.func @in_nested_region(%cond: i1) -> (i32) "None" {
spv.selection { 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
^then: ^then:
spv.Store "Function" %var, %one : i32 spv.Store "Function" %var, %one : i32
// CHECK: spv.Branch ^bb2 // CHECK: spv.Branch ^bb2
spv.Branch ^merge spv.Branch ^merge
// CHECK: ^bb2 // CHECK: ^bb2
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
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
^then: ^then:
spv.Store "Function" %var, %one : i32 spv.Store "Function" %var, %one : i32
// CHECK: spv.Branch ^bb3 // CHECK: spv.Branch ^bb3
spv.Branch ^merge spv.Branch ^merge
// CHECK: ^bb2 // CHECK: ^bb2
^else: ^else:
spv.Store "Function" %var, %two : i32 spv.Store "Function" %var, %two : i32
// CHECK: spv.Branch ^bb3 // CHECK: spv.Branch ^bb3
spv.Branch ^merge spv.Branch ^merge
// CHECK: ^bb3 // CHECK: ^bb3
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: @empty_region // CHECK-LABEL: @empty_region
func @empty_region() -> () { func @empty_region() -> () {
// CHECK: spv.selection // CHECK: spv.selection
spv.selection { spv.selection {
} }
return return
} }
// ----- // -----
// CHECK-LABEL: @selection_with_control // CHECK-LABEL: @selection_with_control
func @selection_with_control() -> () { func @selection_with_control() -> () {
// CHECK: spv.selection control(Flatten) // CHECK: spv.selection control(Flatten)
spv.selection control(Flatten) { spv.selection control(Flatten) {
} }
return return
} }
// ----- // -----
func @wrong_merge_block() -> () { func @wrong_merge_block() -> () {
// expected-error @+1 {{last block must be the merge block with only one 'spv.mlir.merge' op}} // expected-error @+1 {{last block must be the merge block with only one 'spv.mlir.merge' op}}
spv.selection { spv.selection {
spv.Return spv.Return
} }
return return
} }
// ----- // -----
func @missing_entry_block() -> () { func @missing_entry_block() -> () {
// expected-error @+1 {{must have a selection header block}} // expected-error @+1 {{must have a selection header block}}
spv.selection { spv.selection {
spv.mlir.merge spv.mlir.merge
} }
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Unreachable // spv.Unreachable
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: func @unreachable_no_pred // CHECK-LABEL: func @unreachable_no_pred
func @unreachable_no_pred() { func @unreachable_no_pred() {
spv.Return spv.Return
^next: ^next:
// CHECK: spv.Unreachable // CHECK: spv.Unreachable
spv.Unreachable spv.Unreachable
} }
// CHECK-LABEL: func @unreachable_with_pred // CHECK-LABEL: func @unreachable_with_pred
func @unreachable_with_pred() { func @unreachable_with_pred() {
spv.Return spv.Return
^parent: ^parent:
spv.Branch ^unreachable spv.Branch ^unreachable
^unreachable: ^unreachable:
// CHECK: spv.Unreachable // CHECK: spv.Unreachable
spv.Unreachable spv.Unreachable
} }
// ----- // -----
func @unreachable() { func @unreachable() {
// expected-error @+1 {{cannot be used in reachable block}} // expected-error @+1 {{cannot be used in reachable block}}
spv.Unreachable spv.Unreachable
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/cooperative-matrix.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
// CHECK-LABEL: @cooperative_matrix_load // CHECK-LABEL: @cooperative_matrix_load
spv.func @cooperative_matrix_load(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
spv.Return spv.Return
} }
// ----- // -----
// CHECK-LABEL: @cooperative_matrix_load_memaccess // CHECK-LABEL: @cooperative_matrix_load_memaccess
spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_load_diff_ptr_type // CHECK-LABEL: @cooperative_matrix_load_diff_ptr_type
spv.func @cooperative_matrix_load_diff_ptr_type(%ptr : !spv.ptr<vector<4xi32>, StorageBuffer>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load_diff_ptr_type(%ptr : !spv.ptr<vector<4xi32>, StorageBuffer>, %stride : i32, %b : i1) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<vector<4xi32>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_store // CHECK-LABEL: @cooperative_matrix_store
spv.func @cooperative_matrix_store(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %m : !spv.coopmatrix<8x16xi32, Workgroup>, %b : i1) "None" { spv.func @cooperative_matrix_store(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %m : !spv.coopmatrix<8x16xi32, Workgroup>, %b : i1) "None" {
// CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup> // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup>
spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup> spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Workgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_store_memaccess // CHECK-LABEL: @cooperative_matrix_store_memaccess
spv.func @cooperative_matrix_store_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %m : !spv.coopmatrix<8x16xi32, Subgroup>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_store_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %m : !spv.coopmatrix<8x16xi32, Subgroup>, %stride : i32, %b : i1) "None" {
// CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup> spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_length // CHECK-LABEL: @cooperative_matrix_length
spv.func @cooperative_matrix_length() -> i32 "None" { spv.func @cooperative_matrix_length() -> i32 "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// CHECK-LABEL: @cooperative_matrix_muladd // CHECK-LABEL: @cooperative_matrix_muladd
spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x32xi8, Subgroup>, %b : !spv.coopmatrix<32x8xi8, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" { spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x32xi8, Subgroup>, %b : !spv.coopmatrix<32x8xi8, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixMulAddNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixMulAddNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
%r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x32xi8, Subgroup>, !spv.coopmatrix<32x8xi8, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_add // CHECK-LABEL: @cooperative_matrix_add
spv.func @cooperative_matrix_add(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_add(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.IAdd %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.IAdd %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_sub // CHECK-LABEL: @cooperative_matrix_sub
spv.func @cooperative_matrix_sub(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_sub(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.ISub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.ISub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.ISub %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.ISub %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_sdiv // CHECK-LABEL: @cooperative_matrix_sdiv
spv.func @cooperative_matrix_sdiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_sdiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.SDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.SDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.SDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.SDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_udiv // CHECK-LABEL: @cooperative_matrix_udiv
spv.func @cooperative_matrix_udiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_udiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.UDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.UDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.UDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.UDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_fadd // CHECK-LABEL: @cooperative_matrix_fadd
spv.func @cooperative_matrix_fadd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" { spv.func @cooperative_matrix_fadd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.FAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: {{%.*}} = spv.FAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup>
%r = spv.FAdd %a, %b : !spv.coopmatrix<8x16xf32, Subgroup> %r = spv.FAdd %a, %b : !spv.coopmatrix<8x16xf32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_fsub // CHECK-LABEL: @cooperative_matrix_fsub
spv.func @cooperative_matrix_fsub(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" { spv.func @cooperative_matrix_fsub(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.FSub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: {{%.*}} = spv.FSub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup>
%r = spv.FSub %a, %b : !spv.coopmatrix<8x16xf32, Subgroup> %r = spv.FSub %a, %b : !spv.coopmatrix<8x16xf32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_fdiv // CHECK-LABEL: @cooperative_matrix_fdiv
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>
} }
// ----- // -----
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" {
// expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix size must match}} // expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix size must match}}
%r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<16x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<16x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" { spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
// expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix size must match}} // expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix size must match}}
%r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Workgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" { spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Workgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
// expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix scope must match}} // expected-error @+1 {{'spv.CooperativeMatrixMulAddNV' op matrix scope must match}}
%r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Workgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Workgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" { spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
// expected-error @+1 {{matrix element type must match}} // expected-error @+1 {{matrix element type must match}}
%r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xf32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xf32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer>, %stride : i32, %b : i1) "None" {
// expected-error @+1 {{Pointer must point to a scalar or vector type}} // expected-error @+1 {{Pointer must point to a scalar or vector type}}
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<!spv.struct<(f32 [0])>, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, Function>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, Function>, %stride : i32, %b : i1) "None" {
// expected-error @+1 {{Pointer storage class must be Workgroup, StorageBuffer or PhysicalStorageBufferEXT}} // expected-error @+1 {{Pointer storage class must be Workgroup, StorageBuffer or PhysicalStorageBufferEXT}}
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, Function> as !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, Function> as !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/glslops.mlir.
// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Exp // spv.GLSL.Exp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @exp(%arg0 : f32) -> () { func @exp(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Exp {{%.*}} : f32 // CHECK: spv.GLSL.Exp {{%.*}} : f32
%2 = spv.GLSL.Exp %arg0 : f32 %2 = spv.GLSL.Exp %arg0 : f32
return return
} }
func @expvec(%arg0 : vector<3xf16>) -> () { func @expvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Exp {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Exp {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Exp %arg0 : vector<3xf16> %2 = spv.GLSL.Exp %arg0 : vector<3xf16>
return return
} }
// ----- // -----
func @exp(%arg0 : i32) -> () { func @exp(%arg0 : i32) -> () {
// expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values}} // expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values}}
%2 = spv.GLSL.Exp %arg0 : i32 %2 = spv.GLSL.Exp %arg0 : i32
return return
} }
// ----- // -----
func @exp(%arg0 : vector<5xf32>) -> () { func @exp(%arg0 : vector<5xf32>) -> () {
// expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4}} // expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4}}
%2 = spv.GLSL.Exp %arg0 : vector<5xf32> %2 = spv.GLSL.Exp %arg0 : vector<5xf32>
return return
} }
// ----- // -----
func @exp(%arg0 : f32, %arg1 : f32) -> () { func @exp(%arg0 : f32, %arg1 : f32) -> () {
// expected-error @+1 {{expected ':'}} // expected-error @+1 {{expected ':'}}
%2 = spv.GLSL.Exp %arg0, %arg1 : i32 %2 = spv.GLSL.Exp %arg0, %arg1 : i32
return return
} }
// ----- // -----
func @exp(%arg0 : i32) -> () { func @exp(%arg0 : i32) -> () {
// expected-error @+2 {{expected non-function type}} // expected-error @+2 {{expected non-function type}}
%2 = spv.GLSL.Exp %arg0 : %2 = spv.GLSL.Exp %arg0 :
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.FMax // spv.GLSL.FMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fmax(%arg0 : f32, %arg1 : f32) -> () { func @fmax(%arg0 : f32, %arg1 : f32) -> () {
// CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : f32 // CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : f32
%2 = spv.GLSL.FMax %arg0, %arg1 : f32 %2 = spv.GLSL.FMax %arg0, %arg1 : f32
return return
} }
func @fmaxvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () { func @fmaxvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : vector<3xf16>
%2 = spv.GLSL.FMax %arg0, %arg1 : vector<3xf16> %2 = spv.GLSL.FMax %arg0, %arg1 : vector<3xf16>
return return
} }
func @fmaxf64(%arg0 : f64, %arg1 : f64) -> () { func @fmaxf64(%arg0 : f64, %arg1 : f64) -> () {
// CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : f64 // CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : f64
%2 = spv.GLSL.FMax %arg0, %arg1 : f64 %2 = spv.GLSL.FMax %arg0, %arg1 : f64
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.InverseSqrt // spv.GLSL.InverseSqrt
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @inversesqrt(%arg0 : f32) -> () { func @inversesqrt(%arg0 : f32) -> () {
// CHECK: spv.GLSL.InverseSqrt {{%.*}} : f32 // CHECK: spv.GLSL.InverseSqrt {{%.*}} : f32
%2 = spv.GLSL.InverseSqrt %arg0 : f32 %2 = spv.GLSL.InverseSqrt %arg0 : f32
return return
} }
func @inversesqrtvec(%arg0 : vector<3xf16>) -> () { func @inversesqrtvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.InverseSqrt {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.InverseSqrt {{%.*}} : vector<3xf16>
%2 = spv.GLSL.InverseSqrt %arg0 : vector<3xf16> %2 = spv.GLSL.InverseSqrt %arg0 : vector<3xf16>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Sqrt // spv.GLSL.Sqrt
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sqrt(%arg0 : f32) -> () { func @sqrt(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Sqrt {{%.*}} : f32 // CHECK: spv.GLSL.Sqrt {{%.*}} : f32
%2 = spv.GLSL.Sqrt %arg0 : f32 %2 = spv.GLSL.Sqrt %arg0 : f32
return return
} }
func @sqrtvec(%arg0 : vector<3xf16>) -> () { func @sqrtvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Sqrt {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Sqrt {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Sqrt %arg0 : vector<3xf16> %2 = spv.GLSL.Sqrt %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Cos // spv.GLSL.Cos
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @cos(%arg0 : f32) -> () { func @cos(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Cos {{%.*}} : f32 // CHECK: spv.GLSL.Cos {{%.*}} : f32
%2 = spv.GLSL.Cos %arg0 : f32 %2 = spv.GLSL.Cos %arg0 : f32
return return
} }
func @cosvec(%arg0 : vector<3xf16>) -> () { func @cosvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Cos {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Cos {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Cos %arg0 : vector<3xf16> %2 = spv.GLSL.Cos %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Sin // spv.GLSL.Sin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sin(%arg0 : f32) -> () { func @sin(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Sin {{%.*}} : f32 // CHECK: spv.GLSL.Sin {{%.*}} : f32
%2 = spv.GLSL.Sin %arg0 : f32 %2 = spv.GLSL.Sin %arg0 : f32
return return
} }
func @sinvec(%arg0 : vector<3xf16>) -> () { func @sinvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Sin {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Sin {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Sin %arg0 : vector<3xf16> %2 = spv.GLSL.Sin %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Tan // spv.GLSL.Tan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @tan(%arg0 : f32) -> () { func @tan(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Tan {{%.*}} : f32 // CHECK: spv.GLSL.Tan {{%.*}} : f32
%2 = spv.GLSL.Tan %arg0 : f32 %2 = spv.GLSL.Tan %arg0 : f32
return return
} }
func @tanvec(%arg0 : vector<3xf16>) -> () { func @tanvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Tan {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Tan {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Tan %arg0 : vector<3xf16> %2 = spv.GLSL.Tan %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Acos // spv.GLSL.Acos
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @acos(%arg0 : f32) -> () { func @acos(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Acos {{%.*}} : f32 // CHECK: spv.GLSL.Acos {{%.*}} : f32
%2 = spv.GLSL.Acos %arg0 : f32 %2 = spv.GLSL.Acos %arg0 : f32
return return
} }
func @acosvec(%arg0 : vector<3xf16>) -> () { func @acosvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Acos {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Acos {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Acos %arg0 : vector<3xf16> %2 = spv.GLSL.Acos %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Asin // spv.GLSL.Asin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @asin(%arg0 : f32) -> () { func @asin(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Asin {{%.*}} : f32 // CHECK: spv.GLSL.Asin {{%.*}} : f32
%2 = spv.GLSL.Asin %arg0 : f32 %2 = spv.GLSL.Asin %arg0 : f32
return return
} }
func @asinvec(%arg0 : vector<3xf16>) -> () { func @asinvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Asin {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Asin {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Asin %arg0 : vector<3xf16> %2 = spv.GLSL.Asin %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Atan // spv.GLSL.Atan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @atan(%arg0 : f32) -> () { func @atan(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Atan {{%.*}} : f32 // CHECK: spv.GLSL.Atan {{%.*}} : f32
%2 = spv.GLSL.Atan %arg0 : f32 %2 = spv.GLSL.Atan %arg0 : f32
return return
} }
func @atanvec(%arg0 : vector<3xf16>) -> () { func @atanvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Atan {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Atan {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Atan %arg0 : vector<3xf16> %2 = spv.GLSL.Atan %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Sinh // spv.GLSL.Sinh
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sinh(%arg0 : f32) -> () { func @sinh(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Sinh {{%.*}} : f32 // CHECK: spv.GLSL.Sinh {{%.*}} : f32
%2 = spv.GLSL.Sinh %arg0 : f32 %2 = spv.GLSL.Sinh %arg0 : f32
return return
} }
func @sinhvec(%arg0 : vector<3xf16>) -> () { func @sinhvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Sinh {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Sinh {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Sinh %arg0 : vector<3xf16> %2 = spv.GLSL.Sinh %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Cosh // spv.GLSL.Cosh
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @cosh(%arg0 : f32) -> () { func @cosh(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Cosh {{%.*}} : f32 // CHECK: spv.GLSL.Cosh {{%.*}} : f32
%2 = spv.GLSL.Cosh %arg0 : f32 %2 = spv.GLSL.Cosh %arg0 : f32
return return
} }
func @coshvec(%arg0 : vector<3xf16>) -> () { func @coshvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Cosh {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Cosh {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Cosh %arg0 : vector<3xf16> %2 = spv.GLSL.Cosh %arg0 : vector<3xf16>
return return
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Pow // spv.GLSL.Pow
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @pow(%arg0 : f32, %arg1 : f32) -> () { func @pow(%arg0 : f32, %arg1 : f32) -> () {
// CHECK: spv.GLSL.Pow {{%.*}}, {{%.*}} : f32 // CHECK: spv.GLSL.Pow {{%.*}}, {{%.*}} : f32
%2 = spv.GLSL.Pow %arg0, %arg1 : f32 %2 = spv.GLSL.Pow %arg0, %arg1 : f32
return return
} }
func @powvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () { func @powvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Pow {{%.*}}, {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Pow {{%.*}}, {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Pow %arg0, %arg1 : vector<3xf16> %2 = spv.GLSL.Pow %arg0, %arg1 : vector<3xf16>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.Round // spv.GLSL.Round
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @round(%arg0 : f32) -> () { func @round(%arg0 : f32) -> () {
// CHECK: spv.GLSL.Round {{%.*}} : f32 // CHECK: spv.GLSL.Round {{%.*}} : f32
%2 = spv.GLSL.Round %arg0 : f32 %2 = spv.GLSL.Round %arg0 : f32
return return
} }
func @roundvec(%arg0 : vector<3xf16>) -> () { func @roundvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.GLSL.Round {{%.*}} : vector<3xf16> // CHECK: spv.GLSL.Round {{%.*}} : vector<3xf16>
%2 = spv.GLSL.Round %arg0 : vector<3xf16> %2 = spv.GLSL.Round %arg0 : vector<3xf16>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.FClamp // spv.GLSL.FClamp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fclamp(%arg0 : f32, %min : f32, %max : f32) -> () { func @fclamp(%arg0 : f32, %min : f32, %max : f32) -> () {
// CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32 // CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
%2 = spv.GLSL.FClamp %arg0, %min, %max : f32 %2 = spv.GLSL.FClamp %arg0, %min, %max : f32
return return
} }
// ----- // -----
func @fclamp(%arg0 : vector<3xf32>, %min : vector<3xf32>, %max : vector<3xf32>) -> () { func @fclamp(%arg0 : vector<3xf32>, %min : vector<3xf32>, %max : vector<3xf32>) -> () {
// CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32> // CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
%2 = spv.GLSL.FClamp %arg0, %min, %max : vector<3xf32> %2 = spv.GLSL.FClamp %arg0, %min, %max : vector<3xf32>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.UClamp // spv.GLSL.UClamp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fclamp(%arg0 : ui32, %min : ui32, %max : ui32) -> () { func @fclamp(%arg0 : ui32, %min : ui32, %max : ui32) -> () {
// CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : ui32 // CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : ui32
%2 = spv.GLSL.UClamp %arg0, %min, %max : ui32 %2 = spv.GLSL.UClamp %arg0, %min, %max : ui32
return return
} }
// ----- // -----
func @fclamp(%arg0 : vector<4xi32>, %min : vector<4xi32>, %max : vector<4xi32>) -> () { func @fclamp(%arg0 : vector<4xi32>, %min : vector<4xi32>, %max : vector<4xi32>) -> () {
// CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xi32> // CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xi32>
%2 = spv.GLSL.UClamp %arg0, %min, %max : vector<4xi32> %2 = spv.GLSL.UClamp %arg0, %min, %max : vector<4xi32>
return return
} }
// ----- // -----
func @fclamp(%arg0 : si32, %min : si32, %max : si32) -> () { func @fclamp(%arg0 : si32, %min : si32, %max : si32) -> () {
// expected-error @+1 {{must be 8/16/32/64-bit signless/unsigned integer or vector}} // expected-error @+1 {{must be 8/16/32/64-bit signless/unsigned integer or vector}}
%2 = spv.GLSL.UClamp %arg0, %min, %max : si32 %2 = spv.GLSL.UClamp %arg0, %min, %max : si32
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GLSL.SClamp // spv.GLSL.SClamp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fclamp(%arg0 : si32, %min : si32, %max : si32) -> () { func @fclamp(%arg0 : si32, %min : si32, %max : si32) -> () {
// CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32 // CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
%2 = spv.GLSL.SClamp %arg0, %min, %max : si32 %2 = spv.GLSL.SClamp %arg0, %min, %max : si32
return return
} }
// ----- // -----
func @fclamp(%arg0 : vector<4xsi32>, %min : vector<4xsi32>, %max : vector<4xsi32>) -> () { func @fclamp(%arg0 : vector<4xsi32>, %min : vector<4xsi32>, %max : vector<4xsi32>) -> () {
// CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xsi32> // CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xsi32>
%2 = spv.GLSL.SClamp %arg0, %min, %max : vector<4xsi32> %2 = spv.GLSL.SClamp %arg0, %min, %max : vector<4xsi32>
return return
} }
// ----- // -----
func @fclamp(%arg0 : i32, %min : i32, %max : i32) -> () { func @fclamp(%arg0 : i32, %min : i32, %max : i32) -> () {
// expected-error @+1 {{must be 8/16/32/64-bit signed integer or vector}} // expected-error @+1 {{must be 8/16/32/64-bit signed integer or vector}}
%2 = spv.GLSL.SClamp %arg0, %min, %max : i32 %2 = spv.GLSL.SClamp %arg0, %min, %max : i32
return return
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/group-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.SubgroupBallotKHR // spv.SubgroupBallotKHR
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @subgroup_ballot(%predicate: i1) -> vector<4xi32> { func @subgroup_ballot(%predicate: i1) -> vector<4xi32> {
// CHECK: %{{.*}} = spv.SubgroupBallotKHR %{{.*}} : vector<4xi32> // CHECK: %{{.*}} = spv.SubgroupBallotKHR %{{.*}} : vector<4xi32>
%0 = spv.SubgroupBallotKHR %predicate: vector<4xi32> %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupBroadcast // spv.GroupBroadcast
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @group_broadcast_scalar(%value: f32, %localid: i32 ) -> f32 { func @group_broadcast_scalar(%value: f32, %localid: i32 ) -> f32 {
// CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, i32 // CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, i32
%0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, i32 %0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, i32
return %0: f32 return %0: f32
} }
// ----- // -----
func @group_broadcast_scalar_vector(%value: f32, %localid: vector<3xi32> ) -> f32 { func @group_broadcast_scalar_vector(%value: f32, %localid: vector<3xi32> ) -> f32 {
// CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, vector<3xi32> // CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, vector<3xi32>
%0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, vector<3xi32> %0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, vector<3xi32>
return %0: f32 return %0: f32
} }
// ----- // -----
func @group_broadcast_vector(%value: vector<4xf32>, %localid: vector<3xi32> ) -> vector<4xf32> { func @group_broadcast_vector(%value: vector<4xf32>, %localid: vector<3xi32> ) -> vector<4xf32> {
// CHECK: spv.GroupBroadcast "Subgroup" %{{.*}}, %{{.*}} : vector<4xf32>, vector<3xi32> // CHECK: spv.GroupBroadcast "Subgroup" %{{.*}}, %{{.*}} : vector<4xf32>, vector<3xi32>
%0 = spv.GroupBroadcast "Subgroup" %value, %localid : vector<4xf32>, vector<3xi32> %0 = spv.GroupBroadcast "Subgroup" %value, %localid : vector<4xf32>, vector<3xi32>
return %0: vector<4xf32> return %0: vector<4xf32>
} }
// ----- // -----
func @group_broadcast_negative_scope(%value: f32, %localid: vector<3xi32> ) -> f32 { func @group_broadcast_negative_scope(%value: f32, %localid: vector<3xi32> ) -> f32 {
// expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}} // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
%0 = spv.GroupBroadcast "Device" %value, %localid : f32, vector<3xi32> %0 = spv.GroupBroadcast "Device" %value, %localid : f32, vector<3xi32>
return %0: f32 return %0: f32
} }
// ----- // -----
func @group_broadcast_negative_locid_dtype(%value: f32, %localid: vector<3xf32> ) -> f32 { func @group_broadcast_negative_locid_dtype(%value: f32, %localid: vector<3xf32> ) -> f32 {
// expected-error @+1 {{operand #1 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values}} // expected-error @+1 {{operand #1 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values}}
%0 = spv.GroupBroadcast "Subgroup" %value, %localid : f32, vector<3xf32> %0 = spv.GroupBroadcast "Subgroup" %value, %localid : f32, vector<3xf32>
return %0: f32 return %0: f32
} }
// ----- // -----
func @group_broadcast_negative_locid_vec4(%value: f32, %localid: vector<4xi32> ) -> f32 { func @group_broadcast_negative_locid_vec4(%value: f32, %localid: vector<4xi32> ) -> f32 {
// expected-error @+1 {{localid is a vector and can be with only 2 or 3 components, actual number is 4}} // expected-error @+1 {{localid is a vector and can be with only 2 or 3 components, actual number is 4}}
%0 = spv.GroupBroadcast "Subgroup" %value, %localid : f32, vector<4xi32> %0 = spv.GroupBroadcast "Subgroup" %value, %localid : f32, vector<4xi32>
return %0: f32 return %0: f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SubgroupBlockReadINTEL // spv.SubgroupBlockReadINTEL
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @subgroup_block_read_intel(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 { func @subgroup_block_read_intel(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 {
// CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : i32 // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : i32
%0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32 %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32
return %0: i32 return %0: i32
} }
// ----- // -----
func @subgroup_block_read_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>) -> vector<3xi32> { func @subgroup_block_read_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>) -> vector<3xi32> {
// CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : vector<3xi32> // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : vector<3xi32>
%0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : vector<3xi32> %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : vector<3xi32>
return %0: vector<3xi32> return %0: vector<3xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SubgroupBlockWriteINTEL // spv.SubgroupBlockWriteINTEL
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @subgroup_block_write_intel(%ptr : !spv.ptr<i32, StorageBuffer>, %value: i32) -> () { func @subgroup_block_write_intel(%ptr : !spv.ptr<i32, StorageBuffer>, %value: i32) -> () {
// CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : i32 // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : i32
spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32 spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32
return return
} }
// ----- // -----
func @subgroup_block_write_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>, %value: vector<3xi32>) -> () { func @subgroup_block_write_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>, %value: vector<3xi32>) -> () {
// CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : vector<3xi32> // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : vector<3xi32>
spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : vector<3xi32> spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : vector<3xi32>
return return
} }
No newline at end of file No newline at end of file

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

  • This file was moved from mlir/test/Dialect/SPIRV/logical-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.IEqual // spv.IEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @iequal_scalar(%arg0: i32, %arg1: i32) -> i1 { func @iequal_scalar(%arg0: i32, %arg1: i32) -> i1 {
// CHECK: spv.IEqual {{.*}}, {{.*}} : i32 // CHECK: spv.IEqual {{.*}}, {{.*}} : i32
%0 = spv.IEqual %arg0, %arg1 : i32 %0 = spv.IEqual %arg0, %arg1 : i32
return %0 : i1 return %0 : i1
} }
// ----- // -----
func @iequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @iequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.IEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.IEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.IEqual %arg0, %arg1 : vector<4xi32> %0 = spv.IEqual %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.INotEqual // spv.INotEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @inotequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @inotequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.INotEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.INotEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.INotEqual %arg0, %arg1 : vector<4xi32> %0 = spv.INotEqual %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SGreaterThan // spv.SGreaterThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sgt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @sgt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.SGreaterThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.SGreaterThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SGreaterThan %arg0, %arg1 : vector<4xi32> %0 = spv.SGreaterThan %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SGreaterThanEqual // spv.SGreaterThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sge_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @sge_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.SGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.SGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SLessThan // spv.SLessThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @slt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @slt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.SLessThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.SLessThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SLessThan %arg0, %arg1 : vector<4xi32> %0 = spv.SLessThan %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SLessThanEqual // spv.SLessThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @slte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @slte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.SLessThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.SLessThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SLessThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.SLessThanEqual %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UGreaterThan // spv.UGreaterThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @ugt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @ugt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.UGreaterThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.UGreaterThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.UGreaterThan %arg0, %arg1 : vector<4xi32> %0 = spv.UGreaterThan %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UGreaterThanEqual // spv.UGreaterThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @ugte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @ugte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.UGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.UGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ULessThan // spv.ULessThan
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @ult_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @ult_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.ULessThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.ULessThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.ULessThan %arg0, %arg1 : vector<4xi32> %0 = spv.ULessThan %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ULessThanEqual // spv.ULessThanEqual
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @ulte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> { func @ulte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) -> vector<4xi1> {
// CHECK: spv.ULessThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: spv.ULessThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.ULessThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.ULessThanEqual %arg0, %arg1 : vector<4xi32>
return %0 : vector<4xi1> return %0 : vector<4xi1>
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/matrix-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.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK-LABEL: @matrix_times_scalar // CHECK-LABEL: @matrix_times_scalar
spv.func @matrix_times_scalar(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> !spv.matrix<3 x vector<3xf32>> "None" { spv.func @matrix_times_scalar(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> !spv.matrix<3 x vector<3xf32>> "None" {
// CHECK: {{%.*}} = spv.MatrixTimesScalar {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>> // CHECK: {{%.*}} = spv.MatrixTimesScalar {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>>
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_transpose_1 // CHECK-LABEL: @matrix_transpose_1
spv.func @matrix_transpose_1(%arg0 : !spv.matrix<3 x vector<2xf32>>) -> !spv.matrix<2 x vector<3xf32>> "None" { spv.func @matrix_transpose_1(%arg0 : !spv.matrix<3 x vector<2xf32>>) -> !spv.matrix<2 x vector<3xf32>> "None" {
// CHECK: {{%.*}} = spv.Transpose {{%.*}} : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>> // CHECK: {{%.*}} = spv.Transpose {{%.*}} : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>>
%result = spv.Transpose %arg0 : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>> %result = spv.Transpose %arg0 : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<2 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<2 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_transpose_2 // CHECK-LABEL: @matrix_transpose_2
spv.func @matrix_transpose_2(%arg0 : !spv.matrix<3 x vector<3xf32>>) -> !spv.matrix<3 x vector<3xf32>> "None" { spv.func @matrix_transpose_2(%arg0 : !spv.matrix<3 x vector<3xf32>>) -> !spv.matrix<3 x vector<3xf32>> "None" {
// CHECK: {{%.*}} = spv.Transpose {{%.*}} : !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> // CHECK: {{%.*}} = spv.Transpose {{%.*}} : !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
%result = spv.Transpose %arg0 : !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> %result = spv.Transpose %arg0 : !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_times_matrix_1 // CHECK-LABEL: @matrix_times_matrix_1
spv.func @matrix_times_matrix_1(%arg0: !spv.matrix<3 x vector<3xf32>>, %arg1: !spv.matrix<3 x vector<3xf32>>) -> !spv.matrix<3 x vector<3xf32>> "None"{ spv.func @matrix_times_matrix_1(%arg0: !spv.matrix<3 x vector<3xf32>>, %arg1: !spv.matrix<3 x vector<3xf32>>) -> !spv.matrix<3 x vector<3xf32>> "None"{
// CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> // CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_times_matrix_2 // CHECK-LABEL: @matrix_times_matrix_2
spv.func @matrix_times_matrix_2(%arg0: !spv.matrix<3 x vector<2xf32>>, %arg1: !spv.matrix<2 x vector<3xf32>>) -> !spv.matrix<2 x vector<2xf32>> "None"{ spv.func @matrix_times_matrix_2(%arg0: !spv.matrix<3 x vector<2xf32>>, %arg1: !spv.matrix<2 x vector<3xf32>>) -> !spv.matrix<2 x vector<2xf32>> "None"{
// CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>> // CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>>
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>>
spv.ReturnValue %result : !spv.matrix<2 x vector<2xf32>> spv.ReturnValue %result : !spv.matrix<2 x vector<2xf32>>
} }
} }
// ----- // -----
func @input_type_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f16) -> () { func @input_type_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f16) -> () {
// expected-error @+1 {{input matrix components' type and scaling value must have the same type}} // expected-error @+1 {{input matrix components' type and scaling value must have the same type}}
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f16 -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f16 -> !spv.matrix<3 x vector<3xf32>>
} }
// ----- // -----
func @input_type_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f64) -> () { func @input_type_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f64) -> () {
// expected-error @+1 {{input matrix components' type and scaling value must have the same type}} // expected-error @+1 {{input matrix components' type and scaling value must have the same type}}
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f64 -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f64 -> !spv.matrix<3 x vector<3xf32>>
} }
// ----- // -----
func @input_output_component_type_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> () { func @input_output_component_type_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> () {
// expected-error @+1 {{input and result matrices' columns must have the same component type}} // expected-error @+1 {{input and result matrices' columns must have the same component type}}
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf64>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf64>>
} }
// ----- // -----
func @input_output_size_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> () { func @input_output_size_mismatch(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> () {
// expected-error @+1 {{input and result matrices must have the same number of columns}} // expected-error @+1 {{input and result matrices must have the same number of columns}}
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<4 x vector<3xf32>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<4 x vector<3xf32>>
} }
// ----- // -----
func @transpose_op_shape_mismatch_1(%arg0 : !spv.matrix<3 x vector<4xf32>>) -> () { func @transpose_op_shape_mismatch_1(%arg0 : !spv.matrix<3 x vector<4xf32>>) -> () {
// expected-error @+1 {{input matrix rows count must be equal to output matrix columns count}} // expected-error @+1 {{input matrix rows count must be equal to output matrix columns count}}
%result = spv.Transpose %arg0 : !spv.matrix<3 x vector<4xf32>> -> !spv.matrix<3 x vector<3xf32>> %result = spv.Transpose %arg0 : !spv.matrix<3 x vector<4xf32>> -> !spv.matrix<3 x vector<3xf32>>
spv.Return spv.Return
} }
// ----- // -----
func @transpose_op_shape_mismatch_2(%arg0 : !spv.matrix<3 x vector<4xf32>>) -> () { func @transpose_op_shape_mismatch_2(%arg0 : !spv.matrix<3 x vector<4xf32>>) -> () {
// expected-error @+1 {{input matrix rows count must be equal to output matrix columns count}} // expected-error @+1 {{input matrix rows count must be equal to output matrix columns count}}
%result = spv.Transpose %arg0 : !spv.matrix<3 x vector<4xf32>> -> !spv.matrix<2 x vector<4xf32>> %result = spv.Transpose %arg0 : !spv.matrix<3 x vector<4xf32>> -> !spv.matrix<2 x vector<4xf32>>
spv.Return spv.Return
} }
// ----- // -----
func @transpose_op_type_mismatch(%arg0 : !spv.matrix<3 x vector<4xf32>>) -> () { func @transpose_op_type_mismatch(%arg0 : !spv.matrix<3 x vector<4xf32>>) -> () {
// expected-error @+1 {{input and output matrices must have the same component type}} // expected-error @+1 {{input and output matrices must have the same component type}}
%result = spv.Transpose %arg0 : !spv.matrix<3 x vector<4xf32>> -> !spv.matrix<4 x vector<3xf16>> %result = spv.Transpose %arg0 : !spv.matrix<3 x vector<4xf32>> -> !spv.matrix<4 x vector<3xf16>>
spv.Return spv.Return
} }
// ----- // -----
func @matrix_times_matrix_invalid_input_shape_1(%arg0 : !spv.matrix<3 x vector<2xf32>>, %arg1 : !spv.matrix<2 x vector<3xf32>>){ func @matrix_times_matrix_invalid_input_shape_1(%arg0 : !spv.matrix<3 x vector<2xf32>>, %arg1 : !spv.matrix<2 x vector<3xf32>>){
// expected-error @+1 {{right and result matrices must have equal columns' count}} // expected-error @+1 {{right and result matrices must have equal columns' count}}
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<3 x vector<2xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<3 x vector<2xf32>>
} }
// ----- // -----
func @matrix_times_matrix_invalid_input_shape_2(%arg0 : !spv.matrix<3 x vector<2xf32>>, %arg1 : !spv.matrix<2 x vector<3xf32>>){ func @matrix_times_matrix_invalid_input_shape_2(%arg0 : !spv.matrix<3 x vector<2xf32>>, %arg1 : !spv.matrix<2 x vector<3xf32>>){
// expected-error @+1 {{left and result matrices must have equal rows' count}} // expected-error @+1 {{left and result matrices must have equal rows' count}}
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<3xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<3xf32>>
} }
// ----- // -----
func @matrix_times_matrix_inputs_shape_mismatch(%arg0 : !spv.matrix<3 x vector<2xf32>>, %arg1 : !spv.matrix<2 x vector<2xf32>>){ func @matrix_times_matrix_inputs_shape_mismatch(%arg0 : !spv.matrix<3 x vector<2xf32>>, %arg1 : !spv.matrix<2 x vector<2xf32>>){
// expected-error @+1 {{left matrix columns' count must be equal to the right matrix rows' count}} // expected-error @+1 {{left matrix columns' count must be equal to the right matrix rows' count}}
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<2xf32>> -> !spv.matrix<2 x vector<2xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<2xf32>> -> !spv.matrix<2 x vector<2xf32>>
} }
// ----- // -----
func @matrix_times_matrix_component_type_mismatch_1(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : !spv.matrix<3x vector<3xf32>>){ func @matrix_times_matrix_component_type_mismatch_1(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : !spv.matrix<3x vector<3xf32>>){
// expected-error @+1 {{right and result matrices' component type must be the same}} // expected-error @+1 {{right and result matrices' component type must be the same}}
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf64>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf64>>
} }
// ----- // -----
func @matrix_times_matrix_component_type_mismatch_2(%arg0 : !spv.matrix<3 x vector<3xf64>>, %arg1 : !spv.matrix<3x vector<3xf32>>){ func @matrix_times_matrix_component_type_mismatch_2(%arg0 : !spv.matrix<3 x vector<3xf64>>, %arg1 : !spv.matrix<3x vector<3xf32>>){
// expected-error @+1 {{left and result matrices' component type must be the same}} // expected-error @+1 {{left and result matrices' component type must be the same}}
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf64>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf64>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/non-uniform-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.GroupNonUniformBallot // spv.GroupNonUniformBallot
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> { func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> {
// 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>
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// ----- // -----
func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> { func @group_non_uniform_ballot(%predicate: i1) -> vector<4xi32> {
// expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}} // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
%0 = spv.GroupNonUniformBallot "Device" %predicate : vector<4xi32> %0 = spv.GroupNonUniformBallot "Device" %predicate : vector<4xi32>
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// ----- // -----
func @group_non_uniform_ballot(%predicate: i1) -> vector<4xsi32> { func @group_non_uniform_ballot(%predicate: i1) -> vector<4xsi32> {
// expected-error @+1 {{op result #0 must be vector of 8/16/32/64-bit signless/unsigned integer values of length 4, but got 'vector<4xsi32>'}} // expected-error @+1 {{op result #0 must be vector of 8/16/32/64-bit signless/unsigned integer values of length 4, but got 'vector<4xsi32>'}}
%0 = spv.GroupNonUniformBallot "Workgroup" %predicate : vector<4xsi32> %0 = spv.GroupNonUniformBallot "Workgroup" %predicate : vector<4xsi32>
return %0: vector<4xsi32> return %0: vector<4xsi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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 {
// expected-error @+1 {{id must be the result of a constant op}} // expected-error @+1 {{id must be the result of a constant op}}
%0 = spv.GroupNonUniformBroadcast "Subgroup" %value, %localid : f32, i32 %0 = spv.GroupNonUniformBroadcast "Subgroup" %value, %localid : f32, i32
return %0: f32 return %0: f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformElect // spv.GroupNonUniformElect
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_elect // CHECK-LABEL: @group_non_uniform_elect
func @group_non_uniform_elect() -> i1 { func @group_non_uniform_elect() -> i1 {
// CHECK: %{{.+}} = spv.GroupNonUniformElect "Workgroup" : i1 // CHECK: %{{.+}} = spv.GroupNonUniformElect "Workgroup" : i1
%0 = spv.GroupNonUniformElect "Workgroup" : i1 %0 = spv.GroupNonUniformElect "Workgroup" : i1
return %0: i1 return %0: i1
} }
// ----- // -----
func @group_non_uniform_elect() -> i1 { func @group_non_uniform_elect() -> i1 {
// expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}} // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
%0 = spv.GroupNonUniformElect "CrossDevice" : i1 %0 = spv.GroupNonUniformElect "CrossDevice" : i1
return %0: i1 return %0: i1
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformFAdd // spv.GroupNonUniformFAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_fadd_reduce // CHECK-LABEL: @group_non_uniform_fadd_reduce
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>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformFMax // spv.GroupNonUniformFMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_fmax_reduce // CHECK-LABEL: @group_non_uniform_fmax_reduce
func @group_non_uniform_fmax_reduce(%val: f32) -> f32 { func @group_non_uniform_fmax_reduce(%val: f32) -> f32 {
// CHECK: %{{.+}} = spv.GroupNonUniformFMax "Workgroup" "Reduce" %{{.+}} : f32 // CHECK: %{{.+}} = spv.GroupNonUniformFMax "Workgroup" "Reduce" %{{.+}} : f32
%0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %val : f32
return %0: f32 return %0: f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformFMin // spv.GroupNonUniformFMin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_fmin_reduce // CHECK-LABEL: @group_non_uniform_fmin_reduce
func @group_non_uniform_fmin_reduce(%val: f32) -> f32 { func @group_non_uniform_fmin_reduce(%val: f32) -> f32 {
// CHECK: %{{.+}} = spv.GroupNonUniformFMin "Workgroup" "Reduce" %{{.+}} : f32 // CHECK: %{{.+}} = spv.GroupNonUniformFMin "Workgroup" "Reduce" %{{.+}} : f32
%0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %val : f32
return %0: f32 return %0: f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformIAdd // spv.GroupNonUniformIAdd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_iadd_reduce // CHECK-LABEL: @group_non_uniform_iadd_reduce
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 {
// expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}} // expected-error @+1 {{execution scope must be 'Workgroup' or 'Subgroup'}}
%0 = spv.GroupNonUniformIAdd "Device" "Reduce" %val : i32 %0 = spv.GroupNonUniformIAdd "Device" "Reduce" %val : i32
return %0: i32 return %0: i32
} }
// ----- // -----
func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> { func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>) -> vector<2xi32> {
// expected-error @+1 {{cluster size operand must be provided for 'ClusteredReduce' group operation}} // expected-error @+1 {{cluster size operand must be provided for 'ClusteredReduce' group operation}}
%0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val : vector<2xi32> %0 = spv.GroupNonUniformIAdd "Workgroup" "ClusteredReduce" %val : vector<2xi32>
return %0: vector<2xi32> return %0: vector<2xi32>
} }
// ----- // -----
func @group_non_uniform_iadd_clustered_reduce(%val: vector<2xi32>, %size: i32) -> vector<2xi32> { func @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>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformSMax // spv.GroupNonUniformSMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_smax_reduce // CHECK-LABEL: @group_non_uniform_smax_reduce
func @group_non_uniform_smax_reduce(%val: i32) -> i32 { func @group_non_uniform_smax_reduce(%val: i32) -> i32 {
// CHECK: %{{.+}} = spv.GroupNonUniformSMax "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformSMax "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %val : i32
return %0: i32 return %0: i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformSMin // spv.GroupNonUniformSMin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_smin_reduce // CHECK-LABEL: @group_non_uniform_smin_reduce
func @group_non_uniform_smin_reduce(%val: i32) -> i32 { func @group_non_uniform_smin_reduce(%val: i32) -> i32 {
// CHECK: %{{.+}} = spv.GroupNonUniformSMin "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformSMin "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %val : i32
return %0: i32 return %0: i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformUMax // spv.GroupNonUniformUMax
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_umax_reduce // CHECK-LABEL: @group_non_uniform_umax_reduce
func @group_non_uniform_umax_reduce(%val: i32) -> i32 { func @group_non_uniform_umax_reduce(%val: i32) -> i32 {
// CHECK: %{{.+}} = spv.GroupNonUniformUMax "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformUMax "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %val : i32
return %0: i32 return %0: i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.GroupNonUniformUMin // spv.GroupNonUniformUMin
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_umin_reduce // CHECK-LABEL: @group_non_uniform_umin_reduce
func @group_non_uniform_umin_reduce(%val: i32) -> i32 { func @group_non_uniform_umin_reduce(%val: i32) -> i32 {
// CHECK: %{{.+}} = spv.GroupNonUniformUMin "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformUMin "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %val : i32
return %0: i32 return %0: i32
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/ocl-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.OCL.exp // spv.OCL.exp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @exp(%arg0 : f32) -> () { func @exp(%arg0 : f32) -> () {
// CHECK: spv.OCL.exp {{%.*}} : f32 // CHECK: spv.OCL.exp {{%.*}} : f32
%2 = spv.OCL.exp %arg0 : f32 %2 = spv.OCL.exp %arg0 : f32
return return
} }
func @expvec(%arg0 : vector<3xf16>) -> () { func @expvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.OCL.exp {{%.*}} : vector<3xf16> // CHECK: spv.OCL.exp {{%.*}} : vector<3xf16>
%2 = spv.OCL.exp %arg0 : vector<3xf16> %2 = spv.OCL.exp %arg0 : vector<3xf16>
return return
} }
// ----- // -----
func @exp(%arg0 : i32) -> () { func @exp(%arg0 : i32) -> () {
// expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
%2 = spv.OCL.exp %arg0 : i32 %2 = spv.OCL.exp %arg0 : i32
return return
} }
// ----- // -----
func @exp(%arg0 : vector<5xf32>) -> () { func @exp(%arg0 : vector<5xf32>) -> () {
// expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}} // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}}
%2 = spv.OCL.exp %arg0 : vector<5xf32> %2 = spv.OCL.exp %arg0 : vector<5xf32>
return return
} }
// ----- // -----
func @exp(%arg0 : f32, %arg1 : f32) -> () { func @exp(%arg0 : f32, %arg1 : f32) -> () {
// expected-error @+1 {{expected ':'}} // expected-error @+1 {{expected ':'}}
%2 = spv.OCL.exp %arg0, %arg1 : i32 %2 = spv.OCL.exp %arg0, %arg1 : i32
return return
} }
// ----- // -----
func @exp(%arg0 : i32) -> () { func @exp(%arg0 : i32) -> () {
// expected-error @+2 {{expected non-function type}} // expected-error @+2 {{expected non-function type}}
%2 = spv.OCL.exp %arg0 : %2 = spv.OCL.exp %arg0 :
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.OCL.fabs // spv.OCL.fabs
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @fabs(%arg0 : f32) -> () { func @fabs(%arg0 : f32) -> () {
// CHECK: spv.OCL.fabs {{%.*}} : f32 // CHECK: spv.OCL.fabs {{%.*}} : f32
%2 = spv.OCL.fabs %arg0 : f32 %2 = spv.OCL.fabs %arg0 : f32
return return
} }
func @fabsvec(%arg0 : vector<3xf16>) -> () { func @fabsvec(%arg0 : vector<3xf16>) -> () {
// CHECK: spv.OCL.fabs {{%.*}} : vector<3xf16> // CHECK: spv.OCL.fabs {{%.*}} : vector<3xf16>
%2 = spv.OCL.fabs %arg0 : vector<3xf16> %2 = spv.OCL.fabs %arg0 : vector<3xf16>
return return
} }
func @fabsf64(%arg0 : f64) -> () { func @fabsf64(%arg0 : f64) -> () {
// CHECK: spv.OCL.fabs {{%.*}} : f64 // CHECK: spv.OCL.fabs {{%.*}} : f64
%2 = spv.OCL.fabs %arg0 : f64 %2 = spv.OCL.fabs %arg0 : f64
return return
} }
// ----- // -----
func @fabs(%arg0 : i32) -> () { func @fabs(%arg0 : i32) -> () {
// expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}} // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
%2 = spv.OCL.fabs %arg0 : i32 %2 = spv.OCL.fabs %arg0 : i32
return return
} }
// ----- // -----
func @fabs(%arg0 : vector<5xf32>) -> () { func @fabs(%arg0 : vector<5xf32>) -> () {
// expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}} // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}}
%2 = spv.OCL.fabs %arg0 : vector<5xf32> %2 = spv.OCL.fabs %arg0 : vector<5xf32>
return return
} }
// ----- // -----
func @fabs(%arg0 : f32, %arg1 : f32) -> () { func @fabs(%arg0 : f32, %arg1 : f32) -> () {
// expected-error @+1 {{expected ':'}} // expected-error @+1 {{expected ':'}}
%2 = spv.OCL.fabs %arg0, %arg1 : i32 %2 = spv.OCL.fabs %arg0, %arg1 : i32
return return
} }
// ----- // -----
func @fabs(%arg0 : i32) -> () { func @fabs(%arg0 : i32) -> () {
// expected-error @+2 {{expected non-function type}} // expected-error @+2 {{expected non-function type}}
%2 = spv.OCL.fabs %arg0 : %2 = spv.OCL.fabs %arg0 :
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.OCL.s_abs // spv.OCL.s_abs
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @sabs(%arg0 : i32) -> () { func @sabs(%arg0 : i32) -> () {
// CHECK: spv.OCL.s_abs {{%.*}} : i32 // CHECK: spv.OCL.s_abs {{%.*}} : i32
%2 = spv.OCL.s_abs %arg0 : i32 %2 = spv.OCL.s_abs %arg0 : i32
return return
} }
func @sabsvec(%arg0 : vector<3xi16>) -> () { func @sabsvec(%arg0 : vector<3xi16>) -> () {
// CHECK: spv.OCL.s_abs {{%.*}} : vector<3xi16> // CHECK: spv.OCL.s_abs {{%.*}} : vector<3xi16>
%2 = spv.OCL.s_abs %arg0 : vector<3xi16> %2 = spv.OCL.s_abs %arg0 : vector<3xi16>
return return
} }
func @sabsi64(%arg0 : i64) -> () { func @sabsi64(%arg0 : i64) -> () {
// CHECK: spv.OCL.s_abs {{%.*}} : i64 // CHECK: spv.OCL.s_abs {{%.*}} : i64
%2 = spv.OCL.s_abs %arg0 : i64 %2 = spv.OCL.s_abs %arg0 : i64
return return
} }
func @sabsi8(%arg0 : i8) -> () { func @sabsi8(%arg0 : i8) -> () {
// CHECK: spv.OCL.s_abs {{%.*}} : i8 // CHECK: spv.OCL.s_abs {{%.*}} : i8
%2 = spv.OCL.s_abs %arg0 : i8 %2 = spv.OCL.s_abs %arg0 : i8
return return
} }
// ----- // -----
func @sabs(%arg0 : f32) -> () { func @sabs(%arg0 : f32) -> () {
// expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values}} // expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values}}
%2 = spv.OCL.s_abs %arg0 : f32 %2 = spv.OCL.s_abs %arg0 : f32
return return
} }
// ----- // -----
func @sabs(%arg0 : vector<5xi32>) -> () { func @sabs(%arg0 : vector<5xi32>) -> () {
// expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}} // expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}}
%2 = spv.OCL.s_abs %arg0 : vector<5xi32> %2 = spv.OCL.s_abs %arg0 : vector<5xi32>
return return
} }
// ----- // -----
func @sabs(%arg0 : i32, %arg1 : i32) -> () { func @sabs(%arg0 : i32, %arg1 : i32) -> () {
// expected-error @+1 {{expected ':'}} // expected-error @+1 {{expected ':'}}
%2 = spv.OCL.s_abs %arg0, %arg1 : i32 %2 = spv.OCL.s_abs %arg0, %arg1 : i32
return return
} }
// ----- // -----
func @sabs(%arg0 : i32) -> () { func @sabs(%arg0 : i32) -> () {
// expected-error @+2 {{expected non-function type}} // expected-error @+2 {{expected non-function type}}
%2 = spv.OCL.s_abs %arg0 : %2 = spv.OCL.s_abs %arg0 :
return return
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/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.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>
// CHECK: spv.AccessChain {{.*}}[{{.*}}] : !spv.ptr<!spv.array<4 x f32>, Function> // CHECK: spv.AccessChain {{.*}}[{{.*}}] : !spv.ptr<!spv.array<4 x f32>, Function>
%1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.array<4xf32>, Function>, i32 %1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.array<4xf32>, Function>, i32
return return
} }
func @access_chain_2D_array_1(%arg0 : i32) -> () { func @access_chain_2D_array_1(%arg0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// CHECK: spv.AccessChain {{.*}}[{{.*}}, {{.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function> // CHECK: spv.AccessChain {{.*}}[{{.*}}, {{.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function>
%1 = spv.AccessChain %0[%arg0, %arg0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32 %1 = spv.AccessChain %0[%arg0, %arg0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32
%2 = spv.Load "Function" %1 ["Volatile"] : f32 %2 = spv.Load "Function" %1 ["Volatile"] : f32
return return
} }
func @access_chain_2D_array_2(%arg0 : i32) -> () { func @access_chain_2D_array_2(%arg0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// CHECK: spv.AccessChain {{.*}}[{{.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function> // CHECK: spv.AccessChain {{.*}}[{{.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function>
%1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32 %1 = spv.AccessChain %0[%arg0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32
%2 = spv.Load "Function" %1 ["Volatile"] : !spv.array<4xf32> %2 = spv.Load "Function" %1 ["Volatile"] : !spv.array<4xf32>
return return
} }
func @access_chain_rtarray(%arg0 : i32) -> () { func @access_chain_rtarray(%arg0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.rtarray<f32>, Function> %0 = spv.Variable : !spv.ptr<!spv.rtarray<f32>, Function>
// CHECK: spv.AccessChain {{.*}}[{{.*}}] : !spv.ptr<!spv.rtarray<f32>, Function> // CHECK: spv.AccessChain {{.*}}[{{.*}}] : !spv.ptr<!spv.rtarray<f32>, Function>
%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
} }
// ----- // -----
func @access_chain_no_indices(%index0 : i32) -> () { func @access_chain_no_indices(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// expected-error @+1 {{expected at least one index}} // expected-error @+1 {{expected at least one index}}
%1 = spv.AccessChain %0[] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32 %1 = spv.AccessChain %0[] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32
return return
} }
// ----- // -----
func @access_chain_missing_comma(%index0 : i32) -> () { func @access_chain_missing_comma(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
%1 = spv.AccessChain %0[%index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> i32 %1 = spv.AccessChain %0[%index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> i32
return return
} }
// ----- // -----
func @access_chain_invalid_indices_types_count(%index0 : i32) -> () { func @access_chain_invalid_indices_types_count(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// expected-error @+1 {{'spv.AccessChain' op indices types' count must be equal to indices info count}} // expected-error @+1 {{'spv.AccessChain' op indices types' count must be equal to indices info count}}
%1 = spv.AccessChain %0[%index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32 %1 = spv.AccessChain %0[%index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32
return return
} }
// ----- // -----
func @access_chain_missing_indices_type(%index0 : i32) -> () { func @access_chain_missing_indices_type(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// expected-error @+1 {{'spv.AccessChain' op indices types' count must be equal to indices info count}} // expected-error @+1 {{'spv.AccessChain' op indices types' count must be equal to indices info count}}
%1 = spv.AccessChain %0[%index0, %index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32 %1 = spv.AccessChain %0[%index0, %index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32
return return
} }
// ----- // -----
func @access_chain_invalid_type(%index0 : i32) -> () { func @access_chain_invalid_type(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
%1 = spv.Load "Function" %0 ["Volatile"] : !spv.array<4x!spv.array<4xf32>> %1 = spv.Load "Function" %0 ["Volatile"] : !spv.array<4x!spv.array<4xf32>>
// expected-error @+1 {{expected a pointer to composite type, but provided '!spv.array<4 x !spv.array<4 x f32>>'}} // expected-error @+1 {{expected a pointer to composite type, but provided '!spv.array<4 x !spv.array<4 x f32>>'}}
%2 = spv.AccessChain %1[%index0] : !spv.array<4x!spv.array<4xf32>>, i32 %2 = spv.AccessChain %1[%index0] : !spv.array<4x!spv.array<4xf32>>, i32
return return
} }
// ----- // -----
func @access_chain_invalid_index_1(%index0 : i32) -> () { func @access_chain_invalid_index_1(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>
// expected-error @+1 {{expected SSA operand}} // expected-error @+1 {{expected SSA operand}}
%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
} }
// ----- // -----
func @access_chain_invalid_accessing_type(%index0 : i32) -> () { func @access_chain_invalid_accessing_type(%index0 : i32) -> () {
%0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function> %0 = spv.Variable : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, 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}}
%1 = spv.AccessChain %0[%index, %index0, %index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32, i32 %1 = spv.AccessChain %0[%index, %index0, %index0] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32, i32
return return
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Bitcast // spv.Bitcast
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @cast1(%arg0 : f32) { func @cast1(%arg0 : f32) {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : f32 to i32 // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : f32 to i32
%0 = spv.Bitcast %arg0 : f32 to i32 %0 = spv.Bitcast %arg0 : f32 to i32
return return
} }
func @cast2(%arg0 : vector<2xf32>) { func @cast2(%arg0 : vector<2xf32>) {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : vector<2xf32> to vector<2xi32> // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : vector<2xf32> to vector<2xi32>
%0 = spv.Bitcast %arg0 : vector<2xf32> to vector<2xi32> %0 = spv.Bitcast %arg0 : vector<2xf32> to vector<2xi32>
return return
} }
func @cast3(%arg0 : vector<2xf32>) { func @cast3(%arg0 : vector<2xf32>) {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : vector<2xf32> to i64 // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : vector<2xf32> to i64
%0 = spv.Bitcast %arg0 : vector<2xf32> to i64 %0 = spv.Bitcast %arg0 : vector<2xf32> to i64
return return
} }
func @cast4(%arg0 : !spv.ptr<f32, Function>) { func @cast4(%arg0 : !spv.ptr<f32, Function>) {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : !spv.ptr<f32, Function> to !spv.ptr<i32, Function> // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : !spv.ptr<f32, Function> to !spv.ptr<i32, Function>
%0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to !spv.ptr<i32, Function> %0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to !spv.ptr<i32, Function>
return return
} }
func @cast5(%arg0 : !spv.ptr<f32, Function>) { func @cast5(%arg0 : !spv.ptr<f32, Function>) {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : !spv.ptr<f32, Function> to !spv.ptr<vector<2xi32>, Function> // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : !spv.ptr<f32, Function> to !spv.ptr<vector<2xi32>, Function>
%0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to !spv.ptr<vector<2xi32>, Function> %0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to !spv.ptr<vector<2xi32>, Function>
return return
} }
func @cast6(%arg0 : vector<4xf32>) { func @cast6(%arg0 : vector<4xf32>) {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : vector<4xf32> to vector<2xi64> // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : vector<4xf32> to vector<2xi64>
%0 = spv.Bitcast %arg0 : vector<4xf32> to vector<2xi64> %0 = spv.Bitcast %arg0 : vector<4xf32> to vector<2xi64>
return return
} }
// ----- // -----
func @cast1(%arg0 : f32) { func @cast1(%arg0 : f32) {
// expected-error @+1 {{result type must be different from operand type}} // expected-error @+1 {{result type must be different from operand type}}
%0 = spv.Bitcast %arg0 : f32 to f32 %0 = spv.Bitcast %arg0 : f32 to f32
return return
} }
// ----- // -----
func @cast1(%arg0 : f32) { func @cast1(%arg0 : f32) {
// expected-error @+1 {{mismatch in result type bitwidth 64 and operand type bitwidth 32}} // expected-error @+1 {{mismatch in result type bitwidth 64 and operand type bitwidth 32}}
%0 = spv.Bitcast %arg0 : f32 to i64 %0 = spv.Bitcast %arg0 : f32 to i64
return return
} }
// ----- // -----
func @cast1(%arg0 : vector<2xf32>) { func @cast1(%arg0 : vector<2xf32>) {
// expected-error @+1 {{mismatch in result type bitwidth 96 and operand type bitwidth 64}} // expected-error @+1 {{mismatch in result type bitwidth 96 and operand type bitwidth 64}}
%0 = spv.Bitcast %arg0 : vector<2xf32> to vector<3xf32> %0 = spv.Bitcast %arg0 : vector<2xf32> to vector<3xf32>
return return
} }
// ----- // -----
func @cast3(%arg0 : !spv.ptr<f32, Function>) { func @cast3(%arg0 : !spv.ptr<f32, Function>) {
// expected-error @+1 {{unhandled bit cast conversion from pointer type to non-pointer type}} // expected-error @+1 {{unhandled bit cast conversion from pointer type to non-pointer type}}
%0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to i64 %0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to i64
return return
} }
// ----- // -----
func @cast3(%arg0 : i64) { func @cast3(%arg0 : i64) {
// expected-error @+1 {{unhandled bit cast conversion from non-pointer type to pointer type}} // expected-error @+1 {{unhandled bit cast conversion from non-pointer type to pointer type}}
%0 = spv.Bitcast %arg0 : i64 to !spv.ptr<f32, Function> %0 = spv.Bitcast %arg0 : i64 to !spv.ptr<f32, Function>
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitCount // spv.BitCount
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bitcount(%arg: i32) -> i32 { func @bitcount(%arg: i32) -> i32 {
// CHECK: spv.BitCount {{%.*}} : i32 // CHECK: spv.BitCount {{%.*}} : i32
%0 = spv.BitCount %arg : i32 %0 = spv.BitCount %arg : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitFieldInsert // spv.BitFieldInsert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bit_field_insert_vec(%base: vector<3xi32>, %insert: vector<3xi32>, %offset: i32, %count: i16) -> vector<3xi32> { func @bit_field_insert_vec(%base: vector<3xi32>, %insert: vector<3xi32>, %offset: i32, %count: i16) -> vector<3xi32> {
// CHECK: {{%.*}} = spv.BitFieldInsert {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i32, i16 // CHECK: {{%.*}} = spv.BitFieldInsert {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i32, i16
%0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<3xi32>, i32, i16 %0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<3xi32>, i32, i16
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
// ----- // -----
func @bit_field_insert_invalid_insert_type(%base: vector<3xi32>, %insert: vector<2xi32>, %offset: i32, %count: i16) -> vector<3xi32> { func @bit_field_insert_invalid_insert_type(%base: vector<3xi32>, %insert: vector<2xi32>, %offset: i32, %count: i16) -> vector<3xi32> {
// expected-error @+1 {{all of {base, insert, result} have same type}} // expected-error @+1 {{all of {base, insert, result} have same type}}
%0 = "spv.BitFieldInsert" (%base, %insert, %offset, %count) : (vector<3xi32>, vector<2xi32>, i32, i16) -> vector<3xi32> %0 = "spv.BitFieldInsert" (%base, %insert, %offset, %count) : (vector<3xi32>, vector<2xi32>, i32, i16) -> vector<3xi32>
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitFieldSExtract // spv.BitFieldSExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bit_field_s_extract_vec(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> { func @bit_field_s_extract_vec(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> {
// CHECK: {{%.*}} = spv.BitFieldSExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8 // CHECK: {{%.*}} = spv.BitFieldSExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8
%0 = spv.BitFieldSExtract %base, %offset, %count : vector<3xi32>, i8, i8 %0 = spv.BitFieldSExtract %base, %offset, %count : vector<3xi32>, i8, i8
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitFieldUExtract // spv.BitFieldUExtract
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bit_field_u_extract_vec(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> { func @bit_field_u_extract_vec(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> {
// CHECK: {{%.*}} = spv.BitFieldUExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8 // CHECK: {{%.*}} = spv.BitFieldUExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8
%0 = spv.BitFieldUExtract %base, %offset, %count : vector<3xi32>, i8, i8 %0 = spv.BitFieldUExtract %base, %offset, %count : vector<3xi32>, i8, i8
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
// ----- // -----
func @bit_field_u_extract_invalid_result_type(%base: vector<3xi32>, %offset: i32, %count: i16) -> vector<4xi32> { func @bit_field_u_extract_invalid_result_type(%base: vector<3xi32>, %offset: i32, %count: i16) -> vector<4xi32> {
// expected-error @+1 {{failed to verify that all of {base, result} have same type}} // expected-error @+1 {{failed to verify that all of {base, result} have same type}}
%0 = "spv.BitFieldUExtract" (%base, %offset, %count) : (vector<3xi32>, i32, i16) -> vector<4xi32> %0 = "spv.BitFieldUExtract" (%base, %offset, %count) : (vector<3xi32>, i32, i16) -> vector<4xi32>
spv.ReturnValue %0 : vector<4xi32> spv.ReturnValue %0 : vector<4xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.BitReverse // spv.BitReverse
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @bitreverse(%arg: i32) -> i32 { func @bitreverse(%arg: i32) -> i32 {
// CHECK: spv.BitReverse {{%.*}} : i32 // CHECK: spv.BitReverse {{%.*}} : i32
%0 = spv.BitReverse %arg : i32 %0 = spv.BitReverse %arg : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ControlBarrier // spv.ControlBarrier
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @control_barrier_0() -> () { func @control_barrier_0() -> () {
// CHECK: spv.ControlBarrier "Workgroup", "Device", "Acquire|UniformMemory" // CHECK: spv.ControlBarrier "Workgroup", "Device", "Acquire|UniformMemory"
spv.ControlBarrier "Workgroup", "Device", "Acquire|UniformMemory" spv.ControlBarrier "Workgroup", "Device", "Acquire|UniformMemory"
return return
} }
// ----- // -----
func @control_barrier_1() -> () { func @control_barrier_1() -> () {
// expected-error @+1 {{invalid execution_scope attribute specification: "Something"}} // expected-error @+1 {{invalid execution_scope attribute specification: "Something"}}
spv.ControlBarrier "Something", "Device", "Acquire|UniformMemory" spv.ControlBarrier "Something", "Device", "Acquire|UniformMemory"
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertFToS // spv.ConvertFToS
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @convert_f_to_s_scalar(%arg0 : f32) -> i32 { func @convert_f_to_s_scalar(%arg0 : f32) -> i32 {
// CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f32 to i32 // CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f32 to i32
%0 = spv.ConvertFToS %arg0 : f32 to i32 %0 = spv.ConvertFToS %arg0 : f32 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
func @convert_f64_to_s32_scalar(%arg0 : f64) -> i32 { func @convert_f64_to_s32_scalar(%arg0 : f64) -> i32 {
// CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f64 to i32 // CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f64 to i32
%0 = spv.ConvertFToS %arg0 : f64 to i32 %0 = spv.ConvertFToS %arg0 : f64 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
func @convert_f_to_s_vector(%arg0 : vector<3xf32>) -> vector<3xi32> { func @convert_f_to_s_vector(%arg0 : vector<3xf32>) -> vector<3xi32> {
// CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : vector<3xf32> to vector<3xi32> // CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : vector<3xf32> to vector<3xi32>
%0 = spv.ConvertFToS %arg0 : vector<3xf32> to vector<3xi32> %0 = spv.ConvertFToS %arg0 : vector<3xf32> to vector<3xi32>
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertFToU // spv.ConvertFToU
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @convert_f_to_u_scalar(%arg0 : f32) -> i32 { func @convert_f_to_u_scalar(%arg0 : f32) -> i32 {
// CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f32 to i32 // CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f32 to i32
%0 = spv.ConvertFToU %arg0 : f32 to i32 %0 = spv.ConvertFToU %arg0 : f32 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
func @convert_f64_to_u32_scalar(%arg0 : f64) -> i32 { func @convert_f64_to_u32_scalar(%arg0 : f64) -> i32 {
// CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f64 to i32 // CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f64 to i32
%0 = spv.ConvertFToU %arg0 : f64 to i32 %0 = spv.ConvertFToU %arg0 : f64 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
func @convert_f_to_u_vector(%arg0 : vector<3xf32>) -> vector<3xi32> { func @convert_f_to_u_vector(%arg0 : vector<3xf32>) -> vector<3xi32> {
// CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : vector<3xf32> to vector<3xi32> // CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : vector<3xf32> to vector<3xi32>
%0 = spv.ConvertFToU %arg0 : vector<3xf32> to vector<3xi32> %0 = spv.ConvertFToU %arg0 : vector<3xf32> to vector<3xi32>
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
// ----- // -----
func @convert_f_to_u_coopmatrix(%arg0 : !spv.coopmatrix<8x16xf32, Subgroup>) { func @convert_f_to_u_coopmatrix(%arg0 : !spv.coopmatrix<8x16xf32, Subgroup>) {
// CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.ConvertFToU %arg0 : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.ConvertFToU %arg0 : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertSToF // spv.ConvertSToF
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @convert_s_to_f_scalar(%arg0 : i32) -> f32 { func @convert_s_to_f_scalar(%arg0 : i32) -> f32 {
// CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i32 to f32 // CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i32 to f32
%0 = spv.ConvertSToF %arg0 : i32 to f32 %0 = spv.ConvertSToF %arg0 : i32 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
// ----- // -----
func @convert_s64_to_f32_scalar(%arg0 : i64) -> f32 { func @convert_s64_to_f32_scalar(%arg0 : i64) -> f32 {
// CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i64 to f32 // CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i64 to f32
%0 = spv.ConvertSToF %arg0 : i64 to f32 %0 = spv.ConvertSToF %arg0 : i64 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
// ----- // -----
func @convert_s_to_f_vector(%arg0 : vector<3xi32>) -> vector<3xf32> { func @convert_s_to_f_vector(%arg0 : vector<3xi32>) -> vector<3xf32> {
// CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : vector<3xi32> to vector<3xf32> // CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : vector<3xi32> to vector<3xf32>
%0 = spv.ConvertSToF %arg0 : vector<3xi32> to vector<3xf32> %0 = spv.ConvertSToF %arg0 : vector<3xi32> to vector<3xf32>
spv.ReturnValue %0 : vector<3xf32> spv.ReturnValue %0 : vector<3xf32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ConvertUToF // spv.ConvertUToF
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @convert_u_to_f_scalar(%arg0 : i32) -> f32 { func @convert_u_to_f_scalar(%arg0 : i32) -> f32 {
// CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i32 to f32 // CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i32 to f32
%0 = spv.ConvertUToF %arg0 : i32 to f32 %0 = spv.ConvertUToF %arg0 : i32 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
// ----- // -----
func @convert_u64_to_f32_scalar(%arg0 : i64) -> f32 { func @convert_u64_to_f32_scalar(%arg0 : i64) -> f32 {
// CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i64 to f32 // CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i64 to f32
%0 = spv.ConvertUToF %arg0 : i64 to f32 %0 = spv.ConvertUToF %arg0 : i64 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
// ----- // -----
func @convert_u_to_f_vector(%arg0 : vector<3xi32>) -> vector<3xf32> { func @convert_u_to_f_vector(%arg0 : vector<3xi32>) -> vector<3xf32> {
// CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : vector<3xi32> to vector<3xf32> // CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : vector<3xi32> to vector<3xf32>
%0 = spv.ConvertUToF %arg0 : vector<3xi32> to vector<3xf32> %0 = spv.ConvertUToF %arg0 : vector<3xi32> to vector<3xf32>
spv.ReturnValue %0 : vector<3xf32> spv.ReturnValue %0 : vector<3xf32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.FConvert // spv.FConvert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @f_convert_scalar(%arg0 : f32) -> f64 { func @f_convert_scalar(%arg0 : f32) -> f64 {
// CHECK: {{%.*}} = spv.FConvert {{%.*}} : f32 to f64 // CHECK: {{%.*}} = spv.FConvert {{%.*}} : f32 to f64
%0 = spv.FConvert %arg0 : f32 to f64 %0 = spv.FConvert %arg0 : f32 to f64
spv.ReturnValue %0 : f64 spv.ReturnValue %0 : f64
} }
// ----- // -----
func @f_convert_vector(%arg0 : vector<3xf32>) -> vector<3xf64> { func @f_convert_vector(%arg0 : vector<3xf32>) -> vector<3xf64> {
// CHECK: {{%.*}} = spv.FConvert {{%.*}} : vector<3xf32> to vector<3xf64> // CHECK: {{%.*}} = spv.FConvert {{%.*}} : vector<3xf32> to vector<3xf64>
%0 = spv.FConvert %arg0 : vector<3xf32> to vector<3xf64> %0 = spv.FConvert %arg0 : vector<3xf32> to vector<3xf64>
spv.ReturnValue %0 : vector<3xf64> spv.ReturnValue %0 : vector<3xf64>
} }
// ----- // -----
func @f_convert_coop_matrix(%arg0 : !spv.coopmatrix<8x16xf32, Subgroup>) { func @f_convert_coop_matrix(%arg0 : !spv.coopmatrix<8x16xf32, Subgroup>) {
// CHECK: {{%.*}} = spv.FConvert {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xf64, Subgroup> // CHECK: {{%.*}} = spv.FConvert {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xf64, Subgroup>
%0 = spv.FConvert %arg0 : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xf64, Subgroup> %0 = spv.FConvert %arg0 : !spv.coopmatrix<8x16xf32, Subgroup> to !spv.coopmatrix<8x16xf64, Subgroup>
spv.Return spv.Return
} }
// ----- // -----
func @f_convert_vector(%arg0 : f32) -> f32 { func @f_convert_vector(%arg0 : f32) -> f32 {
// expected-error @+1 {{expected the different bit widths for operand type and result type, but provided 'f32' and 'f32'}} // expected-error @+1 {{expected the different bit widths for operand type and result type, but provided 'f32' and 'f32'}}
%0 = spv.FConvert %arg0 : f32 to f32 %0 = spv.FConvert %arg0 : f32 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SConvert // spv.SConvert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @s_convert_scalar(%arg0 : i32) -> i64 { func @s_convert_scalar(%arg0 : i32) -> i64 {
// CHECK: {{%.*}} = spv.SConvert {{%.*}} : i32 to i64 // CHECK: {{%.*}} = spv.SConvert {{%.*}} : i32 to i64
%0 = spv.SConvert %arg0 : i32 to i64 %0 = spv.SConvert %arg0 : i32 to i64
spv.ReturnValue %0 : i64 spv.ReturnValue %0 : i64
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.UConvert // spv.UConvert
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @u_convert_scalar(%arg0 : i32) -> i64 { func @u_convert_scalar(%arg0 : i32) -> i64 {
// CHECK: {{%.*}} = spv.UConvert {{%.*}} : i32 to i64 // CHECK: {{%.*}} = spv.UConvert {{%.*}} : i32 to i64
%0 = spv.UConvert %arg0 : i32 to i64 %0 = spv.UConvert %arg0 : i32 to i64
spv.ReturnValue %0 : i64 spv.ReturnValue %0 : i64
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ExecutionMode // spv.ExecutionMode
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
// CHECK: spv.ExecutionMode {{@.*}} "ContractionOff" // CHECK: spv.ExecutionMode {{@.*}} "ContractionOff"
spv.ExecutionMode @do_nothing "ContractionOff" spv.ExecutionMode @do_nothing "ContractionOff"
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
// CHECK: spv.ExecutionMode {{@.*}} "LocalSizeHint", 3, 4, 5 // CHECK: spv.ExecutionMode {{@.*}} "LocalSizeHint", 3, 4, 5
spv.ExecutionMode @do_nothing "LocalSizeHint", 3, 4, 5 spv.ExecutionMode @do_nothing "LocalSizeHint", 3, 4, 5
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
// expected-error @+1 {{custom op 'spv.ExecutionMode' invalid execution_mode attribute specification: "GLCompute"}} // expected-error @+1 {{custom op 'spv.ExecutionMode' invalid execution_mode attribute specification: "GLCompute"}}
spv.ExecutionMode @do_nothing "GLCompute", 3, 4, 5 spv.ExecutionMode @do_nothing "GLCompute", 3, 4, 5
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LoadOp // spv.LoadOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @simple_load // CHECK-LABEL: @simple_load
func @simple_load() -> () { func @simple_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load "Function" %{{.*}} : f32 // CHECK: spv.Load "Function" %{{.*}} : f32
%1 = spv.Load "Function" %0 : f32 %1 = spv.Load "Function" %0 : f32
return return
} }
// CHECK-LABEL: @load_none_access // CHECK-LABEL: @load_none_access
func @load_none_access() -> () { func @load_none_access() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load "Function" %{{.*}} ["None"] : f32 // CHECK: spv.Load "Function" %{{.*}} ["None"] : f32
%1 = spv.Load "Function" %0 ["None"] : f32 %1 = spv.Load "Function" %0 ["None"] : f32
return return
} }
// CHECK-LABEL: @volatile_load // CHECK-LABEL: @volatile_load
func @volatile_load() -> () { func @volatile_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load "Function" %{{.*}} ["Volatile"] : f32 // CHECK: spv.Load "Function" %{{.*}} ["Volatile"] : f32
%1 = spv.Load "Function" %0 ["Volatile"] : f32 %1 = spv.Load "Function" %0 ["Volatile"] : f32
return return
} }
// CHECK-LABEL: @aligned_load // CHECK-LABEL: @aligned_load
func @aligned_load() -> () { func @aligned_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load "Function" %{{.*}} ["Aligned", 4] : f32 // CHECK: spv.Load "Function" %{{.*}} ["Aligned", 4] : f32
%1 = spv.Load "Function" %0 ["Aligned", 4] : f32 %1 = spv.Load "Function" %0 ["Aligned", 4] : f32
return return
} }
// CHECK-LABEL: @volatile_aligned_load // CHECK-LABEL: @volatile_aligned_load
func @volatile_aligned_load() -> () { func @volatile_aligned_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load "Function" %{{.*}} ["Volatile|Aligned", 4] : f32 // CHECK: spv.Load "Function" %{{.*}} ["Volatile|Aligned", 4] : f32
%1 = spv.Load "Function" %0 ["Volatile|Aligned", 4] : f32 %1 = spv.Load "Function" %0 ["Volatile|Aligned", 4] : f32
return return
} }
// ----- // -----
// CHECK-LABEL: load_none_access // CHECK-LABEL: load_none_access
func @load_none_access() -> () { func @load_none_access() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load // CHECK: spv.Load
// CHECK-SAME: ["None"] // CHECK-SAME: ["None"]
%1 = "spv.Load"(%0) {memory_access = 0 : i32} : (!spv.ptr<f32, Function>) -> (f32) %1 = "spv.Load"(%0) {memory_access = 0 : i32} : (!spv.ptr<f32, Function>) -> (f32)
return return
} }
// CHECK-LABEL: volatile_load // CHECK-LABEL: volatile_load
func @volatile_load() -> () { func @volatile_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load // CHECK: spv.Load
// CHECK-SAME: ["Volatile"] // CHECK-SAME: ["Volatile"]
%1 = "spv.Load"(%0) {memory_access = 1 : i32} : (!spv.ptr<f32, Function>) -> (f32) %1 = "spv.Load"(%0) {memory_access = 1 : i32} : (!spv.ptr<f32, Function>) -> (f32)
return return
} }
// CHECK-LABEL: aligned_load // CHECK-LABEL: aligned_load
func @aligned_load() -> () { func @aligned_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load // CHECK: spv.Load
// CHECK-SAME: ["Aligned", 4] // CHECK-SAME: ["Aligned", 4]
%1 = "spv.Load"(%0) {memory_access = 2 : i32, alignment = 4 : i32} : (!spv.ptr<f32, Function>) -> (f32) %1 = "spv.Load"(%0) {memory_access = 2 : i32, alignment = 4 : i32} : (!spv.ptr<f32, Function>) -> (f32)
return return
} }
// CHECK-LABEL: volatile_aligned_load // CHECK-LABEL: volatile_aligned_load
func @volatile_aligned_load() -> () { func @volatile_aligned_load() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Load // CHECK: spv.Load
// CHECK-SAME: ["Volatile|Aligned", 4] // CHECK-SAME: ["Volatile|Aligned", 4]
%1 = "spv.Load"(%0) {memory_access = 3 : i32, alignment = 4 : i32} : (!spv.ptr<f32, Function>) -> (f32) %1 = "spv.Load"(%0) {memory_access = 3 : i32, alignment = 4 : i32} : (!spv.ptr<f32, Function>) -> (f32)
return return
} }
// ----- // -----
func @simple_load_missing_storageclass() -> () { func @simple_load_missing_storageclass() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
%1 = spv.Load %0 : f32 %1 = spv.Load %0 : f32
return return
} }
// ----- // -----
func @simple_load_missing_operand() -> () { func @simple_load_missing_operand() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected SSA operand}} // expected-error @+1 {{expected SSA operand}}
%1 = spv.Load "Function" : f32 %1 = spv.Load "Function" : f32
return return
} }
// ----- // -----
func @simple_load_missing_rettype() -> () { func @simple_load_missing_rettype() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+2 {{expected ':'}} // expected-error @+2 {{expected ':'}}
%1 = spv.Load "Function" %0 %1 = spv.Load "Function" %0
return return
} }
// ----- // -----
func @volatile_load_missing_lbrace() -> () { func @volatile_load_missing_lbrace() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ':'}} // expected-error @+1 {{expected ':'}}
%1 = spv.Load "Function" %0 "Volatile"] : f32 %1 = spv.Load "Function" %0 "Volatile"] : f32
return return
} }
// ----- // -----
func @volatile_load_missing_rbrace() -> () { func @volatile_load_missing_rbrace() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
%1 = spv.Load "Function" %0 ["Volatile"} : f32 %1 = spv.Load "Function" %0 ["Volatile"} : f32
return return
} }
// ----- // -----
func @aligned_load_missing_alignment() -> () { func @aligned_load_missing_alignment() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
%1 = spv.Load "Function" %0 ["Aligned"] : f32 %1 = spv.Load "Function" %0 ["Aligned"] : f32
return return
} }
// ----- // -----
func @aligned_load_missing_comma() -> () { func @aligned_load_missing_comma() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
%1 = spv.Load "Function" %0 ["Aligned" 4] : f32 %1 = spv.Load "Function" %0 ["Aligned" 4] : f32
return return
} }
// ----- // -----
func @load_incorrect_attributes() -> () { func @load_incorrect_attributes() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
%1 = spv.Load "Function" %0 ["Volatile", 4] : f32 %1 = spv.Load "Function" %0 ["Volatile", 4] : f32
return return
} }
// ----- // -----
func @load_unknown_memory_access() -> () { func @load_unknown_memory_access() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{custom op 'spv.Load' invalid memory_access attribute specification: "Something"}} // expected-error @+1 {{custom op 'spv.Load' invalid memory_access attribute specification: "Something"}}
%1 = spv.Load "Function" %0 ["Something"] : f32 %1 = spv.Load "Function" %0 ["Something"] : f32
return return
} }
// ----- // -----
func @load_unknown_memory_access() -> () { func @load_unknown_memory_access() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{custom op 'spv.Load' invalid memory_access attribute specification: "Volatile|Something"}} // expected-error @+1 {{custom op 'spv.Load' invalid memory_access attribute specification: "Volatile|Something"}}
%1 = spv.Load "Function" %0 ["Volatile|Something"] : f32 %1 = spv.Load "Function" %0 ["Volatile|Something"] : f32
return return
} }
// ----- // -----
func @load_unknown_memory_access() -> () { func @load_unknown_memory_access() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{failed to satisfy constraint: valid SPIR-V MemoryAccess}} // expected-error @+1 {{failed to satisfy constraint: valid SPIR-V MemoryAccess}}
%1 = "spv.Load"(%0) {memory_access = 0x80000000 : i32} : (!spv.ptr<f32, Function>) -> (f32) %1 = "spv.Load"(%0) {memory_access = 0x80000000 : i32} : (!spv.ptr<f32, Function>) -> (f32)
return return
} }
// ----- // -----
func @aligned_load_incorrect_attributes() -> () { func @aligned_load_incorrect_attributes() -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
%1 = spv.Load "Function" %0 ["Aligned", 4, 23] : f32 %1 = spv.Load "Function" %0 ["Aligned", 4, 23] : f32
return return
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @var0 : !spv.ptr<f32, Input> spv.globalVariable @var0 : !spv.ptr<f32, Input>
// CHECK_LABEL: @simple_load // CHECK_LABEL: @simple_load
spv.func @simple_load() -> () "None" { spv.func @simple_load() -> () "None" {
// CHECK: spv.Load "Input" {{%.*}} : f32 // CHECK: spv.Load "Input" {{%.*}} : f32
%0 = spv.mlir.addressof @var0 : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @var0 : !spv.ptr<f32, Input>
%1 = spv.Load "Input" %0 : f32 %1 = spv.Load "Input" %0 : f32
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalAnd // spv.LogicalAnd
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @logicalBinary(%arg0 : i1, %arg1 : i1, %arg2 : i1) func @logicalBinary(%arg0 : i1, %arg1 : i1, %arg2 : i1)
{ {
// CHECK: [[TMP:%.*]] = spv.LogicalAnd {{%.*}}, {{%.*}} : i1 // CHECK: [[TMP:%.*]] = spv.LogicalAnd {{%.*}}, {{%.*}} : i1
%0 = spv.LogicalAnd %arg0, %arg1 : i1 %0 = spv.LogicalAnd %arg0, %arg1 : i1
// CHECK: {{%.*}} = spv.LogicalAnd [[TMP]], {{%.*}} : i1 // CHECK: {{%.*}} = spv.LogicalAnd [[TMP]], {{%.*}} : i1
%1 = spv.LogicalAnd %0, %arg2 : i1 %1 = spv.LogicalAnd %0, %arg2 : i1
return return
} }
func @logicalBinary2(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>) func @logicalBinary2(%arg0 : vector<4xi1>, %arg1 : vector<4xi1>)
{ {
// CHECK: {{%.*}} = spv.LogicalAnd {{%.*}}, {{%.*}} : vector<4xi1> // CHECK: {{%.*}} = spv.LogicalAnd {{%.*}}, {{%.*}} : vector<4xi1>
%0 = spv.LogicalAnd %arg0, %arg1 : vector<4xi1> %0 = spv.LogicalAnd %arg0, %arg1 : vector<4xi1>
return return
} }
// ----- // -----
func @logicalBinary(%arg0 : i1, %arg1 : i1) func @logicalBinary(%arg0 : i1, %arg1 : i1)
{ {
// expected-error @+2 {{expected ':'}} // expected-error @+2 {{expected ':'}}
%0 = spv.LogicalAnd %arg0, %arg1 %0 = spv.LogicalAnd %arg0, %arg1
return return
} }
// ----- // -----
func @logicalBinary(%arg0 : i1, %arg1 : i1) func @logicalBinary(%arg0 : i1, %arg1 : i1)
{ {
// expected-error @+2 {{expected non-function type}} // expected-error @+2 {{expected non-function type}}
%0 = spv.LogicalAnd %arg0, %arg1 : %0 = spv.LogicalAnd %arg0, %arg1 :
return return
} }
// ----- // -----
func @logicalBinary(%arg0 : i1, %arg1 : i1) func @logicalBinary(%arg0 : i1, %arg1 : i1)
{ {
// expected-error @+1 {{custom op 'spv.LogicalAnd' expected 2 operands}} // expected-error @+1 {{custom op 'spv.LogicalAnd' expected 2 operands}}
%0 = spv.LogicalAnd %arg0 : i1 %0 = spv.LogicalAnd %arg0 : i1
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalNot // spv.LogicalNot
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @logicalUnary(%arg0 : i1, %arg1 : i1) func @logicalUnary(%arg0 : i1, %arg1 : i1)
{ {
// CHECK: [[TMP:%.*]] = spv.LogicalNot {{%.*}} : i1 // CHECK: [[TMP:%.*]] = spv.LogicalNot {{%.*}} : i1
%0 = spv.LogicalNot %arg0 : i1 %0 = spv.LogicalNot %arg0 : i1
// CHECK: {{%.*}} = spv.LogicalNot [[TMP]] : i1 // CHECK: {{%.*}} = spv.LogicalNot [[TMP]] : i1
%1 = spv.LogicalNot %0 : i1 %1 = spv.LogicalNot %0 : i1
return return
} }
func @logicalUnary2(%arg0 : vector<4xi1>) func @logicalUnary2(%arg0 : vector<4xi1>)
{ {
// CHECK: {{%.*}} = spv.LogicalNot {{%.*}} : vector<4xi1> // CHECK: {{%.*}} = spv.LogicalNot {{%.*}} : vector<4xi1>
%0 = spv.LogicalNot %arg0 : vector<4xi1> %0 = spv.LogicalNot %arg0 : vector<4xi1>
return return
} }
// ----- // -----
func @logicalUnary(%arg0 : i1) func @logicalUnary(%arg0 : i1)
{ {
// expected-error @+2 {{expected ':'}} // expected-error @+2 {{expected ':'}}
%0 = spv.LogicalNot %arg0 %0 = spv.LogicalNot %arg0
return return
} }
// ----- // -----
func @logicalUnary(%arg0 : i1) func @logicalUnary(%arg0 : i1)
{ {
// expected-error @+2 {{expected non-function type}} // expected-error @+2 {{expected non-function type}}
%0 = spv.LogicalNot %arg0 : %0 = spv.LogicalNot %arg0 :
return return
} }
// ----- // -----
func @logicalUnary(%arg0 : i1) func @logicalUnary(%arg0 : i1)
{ {
// expected-error @+1 {{expected SSA operand}} // expected-error @+1 {{expected SSA operand}}
%0 = spv.LogicalNot : i1 %0 = spv.LogicalNot : i1
return return
} }
// ----- // -----
func @logicalUnary(%arg0 : i32) func @logicalUnary(%arg0 : i32)
{ {
// expected-error @+1 {{operand #0 must be bool or vector of bool values of length 2/3/4/8/16, but got 'i32'}} // expected-error @+1 {{operand #0 must be bool or vector of bool values of length 2/3/4/8/16, but got 'i32'}}
%0 = spv.LogicalNot %arg0 : i32 %0 = spv.LogicalNot %arg0 : i32
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.MemoryBarrier // spv.MemoryBarrier
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @memory_barrier_0() -> () { func @memory_barrier_0() -> () {
// CHECK: spv.MemoryBarrier "Device", "Acquire|UniformMemory" // CHECK: spv.MemoryBarrier "Device", "Acquire|UniformMemory"
spv.MemoryBarrier "Device", "Acquire|UniformMemory" spv.MemoryBarrier "Device", "Acquire|UniformMemory"
return return
} }
// ----- // -----
func @memory_barrier_1() -> () { func @memory_barrier_1() -> () {
// CHECK: spv.MemoryBarrier "Workgroup", "Acquire" // CHECK: spv.MemoryBarrier "Workgroup", "Acquire"
spv.MemoryBarrier "Workgroup", "Acquire" spv.MemoryBarrier "Workgroup", "Acquire"
return return
} }
// ----- // -----
func @memory_barrier_2() -> () { func @memory_barrier_2() -> () {
// expected-error @+1 {{expected at most one of these four memory constraints to be set: `Acquire`, `Release`,`AcquireRelease` or `SequentiallyConsistent`}} // expected-error @+1 {{expected at most one of these four memory constraints to be set: `Acquire`, `Release`,`AcquireRelease` or `SequentiallyConsistent`}}
spv.MemoryBarrier "Device", "Acquire|Release" spv.MemoryBarrier "Device", "Acquire|Release"
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Not // spv.Not
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @not(%arg: i32) -> i32 { func @not(%arg: i32) -> i32 {
// CHECK: spv.Not {{%.*}} : i32 // CHECK: spv.Not {{%.*}} : i32
%0 = spv.Not %arg : i32 %0 = spv.Not %arg : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ShiftLeftLogical // spv.ShiftLeftLogical
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @shift_left_logical(%arg0: i32, %arg1 : i16) -> i32 { func @shift_left_logical(%arg0: i32, %arg1 : i16) -> i32 {
// CHECK: {{%.*}} = spv.ShiftLeftLogical {{%.*}}, {{%.*}} : i32, i16 // CHECK: {{%.*}} = spv.ShiftLeftLogical {{%.*}}, {{%.*}} : i32, i16
%0 = spv.ShiftLeftLogical %arg0, %arg1: i32, i16 %0 = spv.ShiftLeftLogical %arg0, %arg1: i32, i16
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// ----- // -----
func @shift_left_logical_invalid_result_type(%arg0: i32, %arg1 : i16) -> i16 { func @shift_left_logical_invalid_result_type(%arg0: i32, %arg1 : i16) -> i16 {
// expected-error @+1 {{expected the same type for the first operand and result, but provided 'i32' and 'i16'}} // expected-error @+1 {{expected the same type for the first operand and result, but provided 'i32' and 'i16'}}
%0 = "spv.ShiftLeftLogical" (%arg0, %arg1) : (i32, i16) -> (i16) %0 = "spv.ShiftLeftLogical" (%arg0, %arg1) : (i32, i16) -> (i16)
spv.ReturnValue %0 : i16 spv.ReturnValue %0 : i16
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ShiftRightArithmetic // spv.ShiftRightArithmetic
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @shift_right_arithmetic(%arg0: vector<4xi32>, %arg1 : vector<4xi8>) -> vector<4xi32> { func @shift_right_arithmetic(%arg0: vector<4xi32>, %arg1 : vector<4xi8>) -> vector<4xi32> {
// CHECK: {{%.*}} = spv.ShiftRightArithmetic {{%.*}}, {{%.*}} : vector<4xi32>, vector<4xi8> // CHECK: {{%.*}} = spv.ShiftRightArithmetic {{%.*}}, {{%.*}} : vector<4xi32>, vector<4xi8>
%0 = spv.ShiftRightArithmetic %arg0, %arg1: vector<4xi32>, vector<4xi8> %0 = spv.ShiftRightArithmetic %arg0, %arg1: vector<4xi32>, vector<4xi8>
spv.ReturnValue %0 : vector<4xi32> spv.ReturnValue %0 : vector<4xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.ShiftRightLogical // spv.ShiftRightLogical
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @shift_right_logical(%arg0: vector<2xi32>, %arg1 : vector<2xi8>) -> vector<2xi32> { func @shift_right_logical(%arg0: vector<2xi32>, %arg1 : vector<2xi8>) -> vector<2xi32> {
// CHECK: {{%.*}} = spv.ShiftRightLogical {{%.*}}, {{%.*}} : vector<2xi32>, vector<2xi8> // CHECK: {{%.*}} = spv.ShiftRightLogical {{%.*}}, {{%.*}} : vector<2xi32>, vector<2xi8>
%0 = spv.ShiftRightLogical %arg0, %arg1: vector<2xi32>, vector<2xi8> %0 = spv.ShiftRightLogical %arg0, %arg1: vector<2xi32>, vector<2xi8>
spv.ReturnValue %0 : vector<2xi32> spv.ReturnValue %0 : vector<2xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.StoreOp // spv.StoreOp
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @simple_store(%arg0 : f32) -> () { func @simple_store(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Store "Function" %0, %arg0 : f32 // CHECK: spv.Store "Function" %0, %arg0 : f32
spv.Store "Function" %0, %arg0 : f32 spv.Store "Function" %0, %arg0 : f32
return return
} }
// CHECK_LABEL: @volatile_store // CHECK_LABEL: @volatile_store
func @volatile_store(%arg0 : f32) -> () { func @volatile_store(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Store "Function" %0, %arg0 ["Volatile"] : f32 // CHECK: spv.Store "Function" %0, %arg0 ["Volatile"] : f32
spv.Store "Function" %0, %arg0 ["Volatile"] : f32 spv.Store "Function" %0, %arg0 ["Volatile"] : f32
return return
} }
// CHECK_LABEL: @aligned_store // CHECK_LABEL: @aligned_store
func @aligned_store(%arg0 : f32) -> () { func @aligned_store(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// CHECK: spv.Store "Function" %0, %arg0 ["Aligned", 4] : f32 // CHECK: spv.Store "Function" %0, %arg0 ["Aligned", 4] : f32
spv.Store "Function" %0, %arg0 ["Aligned", 4] : f32 spv.Store "Function" %0, %arg0 ["Aligned", 4] : f32
return return
} }
// ----- // -----
func @simple_store_missing_ptr_type(%arg0 : f32) -> () { func @simple_store_missing_ptr_type(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
spv.Store %0, %arg0 : f32 spv.Store %0, %arg0 : f32
return return
} }
// ----- // -----
func @simple_store_missing_operand(%arg0 : f32) -> () { func @simple_store_missing_operand(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{custom op 'spv.Store' invalid operand}} : f32 // expected-error @+1 {{custom op 'spv.Store' invalid operand}} : f32
spv.Store "Function" , %arg0 : f32 spv.Store "Function" , %arg0 : f32
return return
} }
// ----- // -----
func @simple_store_missing_operand(%arg0 : f32) -> () { func @simple_store_missing_operand(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{custom op 'spv.Store' expected 2 operands}} : f32 // expected-error @+1 {{custom op 'spv.Store' expected 2 operands}} : f32
spv.Store "Function" %0 : f32 spv.Store "Function" %0 : f32
return return
} }
// ----- // -----
func @volatile_store_missing_lbrace(%arg0 : f32) -> () { func @volatile_store_missing_lbrace(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ':'}} // expected-error @+1 {{expected ':'}}
spv.Store "Function" %0, %arg0 "Volatile"] : f32 spv.Store "Function" %0, %arg0 "Volatile"] : f32
return return
} }
// ----- // -----
func @volatile_store_missing_rbrace(%arg0 : f32) -> () { func @volatile_store_missing_rbrace(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
spv.Store "Function" %0, %arg0 ["Volatile"} : f32 spv.Store "Function" %0, %arg0 ["Volatile"} : f32
return return
} }
// ----- // -----
func @aligned_store_missing_alignment(%arg0 : f32) -> () { func @aligned_store_missing_alignment(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
spv.Store "Function" %0, %arg0 ["Aligned"] : f32 spv.Store "Function" %0, %arg0 ["Aligned"] : f32
return return
} }
// ----- // -----
func @aligned_store_missing_comma(%arg0 : f32) -> () { func @aligned_store_missing_comma(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
spv.Store "Function" %0, %arg0 ["Aligned" 4] : f32 spv.Store "Function" %0, %arg0 ["Aligned" 4] : f32
return return
} }
// ----- // -----
func @load_incorrect_attributes(%arg0 : f32) -> () { func @load_incorrect_attributes(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
spv.Store "Function" %0, %arg0 ["Volatile", 4] : f32 spv.Store "Function" %0, %arg0 ["Volatile", 4] : f32
return return
} }
// ----- // -----
func @aligned_store_incorrect_attributes(%arg0 : f32) -> () { func @aligned_store_incorrect_attributes(%arg0 : f32) -> () {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
spv.Store "Function" %0, %arg0 ["Aligned", 4, 23] : f32 spv.Store "Function" %0, %arg0 ["Aligned", 4, 23] : f32
return return
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @var0 : !spv.ptr<f32, Input> spv.globalVariable @var0 : !spv.ptr<f32, Input>
spv.func @simple_store(%arg0 : f32) -> () "None" { spv.func @simple_store(%arg0 : f32) -> () "None" {
%0 = spv.mlir.addressof @var0 : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @var0 : !spv.ptr<f32, Input>
// CHECK: spv.Store "Input" {{%.*}}, {{%.*}} : f32 // CHECK: spv.Store "Input" {{%.*}}, {{%.*}} : f32
spv.Store "Input" %0, %arg0 : f32 spv.Store "Input" %0, %arg0 : f32
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.SubgroupBallotKHR // spv.SubgroupBallotKHR
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @subgroup_ballot(%predicate: i1) -> vector<4xi32> { func @subgroup_ballot(%predicate: i1) -> vector<4xi32> {
%0 = spv.SubgroupBallotKHR %predicate: vector<4xi32> %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.undef // spv.undef
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @undef() -> () { func @undef() -> () {
%0 = spv.undef : f32 %0 = spv.undef : f32
%1 = spv.undef : vector<4xf32> %1 = spv.undef : vector<4xf32>
spv.Return spv.Return
} }
// ----- // -----
func @undef() -> () { func @undef() -> () {
// expected-error @+2{{expected non-function type}} // expected-error @+2{{expected non-function type}}
%0 = spv.undef : %0 = spv.undef :
spv.Return spv.Return
} }
// ----- // -----
func @undef() -> () { func @undef() -> () {
// expected-error @+2{{expected ':'}} // expected-error @+2{{expected ':'}}
%0 = spv.undef %0 = spv.undef
spv.Return spv.Return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Variable // spv.Variable
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @variable(%arg0: f32) -> () { func @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 {
spv.globalVariable @global : !spv.ptr<f32, Workgroup> spv.globalVariable @global : !spv.ptr<f32, Workgroup>
spv.func @variable_init_global_variable() -> () "None" { spv.func @variable_init_global_variable() -> () "None" {
%0 = spv.mlir.addressof @global : !spv.ptr<f32, Workgroup> %0 = spv.mlir.addressof @global : !spv.ptr<f32, Workgroup>
// CHECK: spv.Variable init({{.*}}) : !spv.ptr<!spv.ptr<f32, Workgroup>, Function> // CHECK: spv.Variable init({{.*}}) : !spv.ptr<!spv.ptr<f32, Workgroup>, Function>
%1 = spv.Variable init(%0) : !spv.ptr<!spv.ptr<f32, Workgroup>, Function> %1 = spv.Variable init(%0) : !spv.ptr<!spv.ptr<f32, Workgroup>, Function>
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc = 42 : i32 spv.specConstant @sc = 42 : i32
// CHECK-LABEL: @variable_init_spec_constant // CHECK-LABEL: @variable_init_spec_constant
spv.func @variable_init_spec_constant() -> () "None" { spv.func @variable_init_spec_constant() -> () "None" {
%0 = spv.mlir.referenceof @sc : i32 %0 = spv.mlir.referenceof @sc : i32
// CHECK: spv.Variable init(%0) : !spv.ptr<i32, Function> // CHECK: spv.Variable init(%0) : !spv.ptr<i32, Function>
%1 = spv.Variable init(%0) : !spv.ptr<i32, Function> %1 = spv.Variable init(%0) : !spv.ptr<i32, Function>
spv.Return spv.Return
} }
} }
// ----- // -----
func @variable_bind() -> () { func @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() -> () {
// expected-error @+1 {{cannot have 'built_in' attribute (only allowed in spv.globalVariable)}} // expected-error @+1 {{cannot have 'built_in' attribute (only allowed in spv.globalVariable)}}
%1 = spv.Variable built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Function> %1 = spv.Variable built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Function>
return return
} }
// ----- // -----
func @expect_ptr_result_type(%arg0: f32) -> () { func @expect_ptr_result_type(%arg0: f32) -> () {
// expected-error @+1 {{expected spv.ptr type}} // expected-error @+1 {{expected spv.ptr type}}
%0 = spv.Variable : f32 %0 = spv.Variable : f32
return return
} }
// ----- // -----
func @variable_init(%arg0: f32) -> () { func @variable_init(%arg0: f32) -> () {
// expected-error @+1 {{op initializer must be the result of a constant or spv.globalVariable op}} // expected-error @+1 {{op initializer must be the result of a constant or spv.globalVariable op}}
%0 = spv.Variable init(%arg0) : !spv.ptr<f32, Function> %0 = spv.Variable init(%arg0) : !spv.ptr<f32, Function>
return return
} }
// ----- // -----
func @cannot_be_generic_storage_class(%arg0: f32) -> () { func @cannot_be_generic_storage_class(%arg0: f32) -> () {
// expected-error @+1 {{op can only be used to model function-level variables. Use spv.globalVariable for module-level variables}} // expected-error @+1 {{op can only be used to model function-level variables. Use spv.globalVariable for module-level variables}}
%0 = spv.Variable : !spv.ptr<f32, Generic> %0 = spv.Variable : !spv.ptr<f32, Generic>
return return
} }
// ----- // -----
func @copy_memory_incompatible_ptrs() { func @copy_memory_incompatible_ptrs() {
%0 = spv.Variable : !spv.ptr<f32, Function> %0 = spv.Variable : !spv.ptr<f32, Function>
%1 = spv.Variable : !spv.ptr<i32, Function> %1 = spv.Variable : !spv.ptr<i32, Function>
// expected-error @+1 {{both operands must be pointers to the same type}} // expected-error @+1 {{both operands must be pointers to the same type}}
"spv.CopyMemory"(%0, %1) {} : (!spv.ptr<f32, Function>, !spv.ptr<i32, Function>) -> () "spv.CopyMemory"(%0, %1) {} : (!spv.ptr<f32, Function>, !spv.ptr<i32, Function>) -> ()
spv.Return spv.Return
} }
// ----- // -----
func @copy_memory_invalid_maa() { func @copy_memory_invalid_maa() {
%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>
// expected-error @+1 {{missing alignment value}} // expected-error @+1 {{missing alignment value}}
"spv.CopyMemory"(%0, %1) {memory_access=0x0002 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {memory_access=0x0002 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
spv.Return spv.Return
} }
// ----- // -----
func @copy_memory_invalid_source_maa() { func @copy_memory_invalid_source_maa() {
%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>
// expected-error @+1 {{invalid alignment specification with non-aligned memory access specification}} // expected-error @+1 {{invalid alignment specification with non-aligned memory access specification}}
"spv.CopyMemory"(%0, %1) {source_memory_access=0x0001 : i32, memory_access=0x0002 : i32, source_alignment=8 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {source_memory_access=0x0001 : i32, memory_access=0x0002 : i32, source_alignment=8 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
spv.Return spv.Return
} }
// ----- // -----
func @copy_memory_invalid_source_maa2() { func @copy_memory_invalid_source_maa2() {
%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>
// expected-error @+1 {{missing alignment value}} // expected-error @+1 {{missing alignment value}}
"spv.CopyMemory"(%0, %1) {source_memory_access=0x0002 : i32, memory_access=0x0002 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {source_memory_access=0x0002 : i32, memory_access=0x0002 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
spv.Return spv.Return
} }
// ----- // -----
func @copy_memory_print_maa() { func @copy_memory_print_maa() {
%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.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"] : f32
"spv.CopyMemory"(%0, %1) {memory_access=0x0001 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {memory_access=0x0001 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4] : f32
"spv.CopyMemory"(%0, %1) {memory_access=0x0002 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {memory_access=0x0002 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4], ["Volatile"] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4], ["Volatile"] : f32
"spv.CopyMemory"(%0, %1) {source_memory_access=0x0001 : i32, memory_access=0x0002 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {source_memory_access=0x0001 : i32, memory_access=0x0002 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4], ["Aligned", 8] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4], ["Aligned", 8] : f32
"spv.CopyMemory"(%0, %1) {source_memory_access=0x0002 : i32, memory_access=0x0002 : i32, source_alignment=8 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> () "spv.CopyMemory"(%0, %1) {source_memory_access=0x0002 : i32, memory_access=0x0002 : i32, source_alignment=8 : i32, alignment=4 : i32} : (!spv.ptr<f32, Function>, !spv.ptr<f32, Function>) -> ()
spv.Return spv.Return
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/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
} }
} }
// ----- // -----
// Allow taking address of global variables in other module-like ops // Allow taking address of global variables in other module-like ops
spv.globalVariable @var : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input> spv.globalVariable @var : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>
func @addressof() -> () { func @addressof() -> () {
// CHECK: spv.mlir.addressof @var // CHECK: spv.mlir.addressof @var
%1 = spv.mlir.addressof @var : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input> %1 = spv.mlir.addressof @var : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>
return return
} }
// ----- // -----
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 @foo() -> () "None" { spv.func @foo() -> () "None" {
// expected-error @+1 {{expected spv.globalVariable symbol}} // expected-error @+1 {{expected spv.globalVariable symbol}}
%0 = spv.mlir.addressof @var2 : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input> %0 = spv.mlir.addressof @var2 : !spv.ptr<!spv.struct<(f32, !spv.array<4xf32>)>, Input>
} }
} }
// ----- // -----
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 @foo() -> () "None" { 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
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
// CHECK: spv.EntryPoint "GLCompute" @do_nothing // CHECK: spv.EntryPoint "GLCompute" @do_nothing
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @var2 : !spv.ptr<f32, Input> spv.globalVariable @var2 : !spv.ptr<f32, Input>
spv.globalVariable @var3 : !spv.ptr<f32, Output> spv.globalVariable @var3 : !spv.ptr<f32, Output>
spv.func @do_something(%arg0 : !spv.ptr<f32, Input>, %arg1 : !spv.ptr<f32, Output>) -> () "None" { spv.func @do_something(%arg0 : !spv.ptr<f32, Input>, %arg1 : !spv.ptr<f32, Output>) -> () "None" {
%1 = spv.Load "Input" %arg0 : f32 %1 = spv.Load "Input" %arg0 : f32
spv.Store "Output" %arg1, %1 : f32 spv.Store "Output" %arg1, %1 : f32
spv.Return spv.Return
} }
// CHECK: spv.EntryPoint "GLCompute" @do_something, @var2, @var3 // CHECK: spv.EntryPoint "GLCompute" @do_something, @var2, @var3
spv.EntryPoint "GLCompute" @do_something, @var2, @var3 spv.EntryPoint "GLCompute" @do_something, @var2, @var3
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
// expected-error @+1 {{invalid kind of attribute specified}} // expected-error @+1 {{invalid kind of attribute specified}}
spv.EntryPoint "GLCompute" "do_nothing" spv.EntryPoint "GLCompute" "do_nothing"
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
// expected-error @+1 {{function 'do_something' not found in 'spv.module'}} // expected-error @+1 {{function 'do_something' not found in 'spv.module'}}
spv.EntryPoint "GLCompute" @do_something spv.EntryPoint "GLCompute" @do_something
} }
/// TODO: Add a test that verifies an error is thrown /// TODO: Add a test that verifies an error is thrown
/// when interface entries of EntryPointOp are not /// when interface entries of EntryPointOp are not
/// spv.Variables. There is currently no other op that has a spv.ptr /// spv.Variables. There is currently no other op that has a spv.ptr
/// return type /// return type
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
// expected-error @+1 {{op must appear in a module-like op's block}} // expected-error @+1 {{op must appear in a module-like op's block}}
spv.EntryPoint "GLCompute" @do_something spv.EntryPoint "GLCompute" @do_something
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
// expected-error @+1 {{duplicate of a previous EntryPointOp}} // expected-error @+1 {{duplicate of a previous EntryPointOp}}
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @do_nothing spv.EntryPoint "GLCompute" @do_nothing
// expected-error @+1 {{'spv.EntryPoint' invalid execution_model attribute specification: "ContractionOff"}} // expected-error @+1 {{'spv.EntryPoint' invalid execution_model attribute specification: "ContractionOff"}}
spv.EntryPoint "ContractionOff" @do_nothing spv.EntryPoint "ContractionOff" @do_nothing
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.func // spv.func
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: spv.func @foo() "None" // CHECK: spv.func @foo() "None"
spv.func @foo() "None" spv.func @foo() "None"
// CHECK: spv.func @bar(%{{.+}}: i32) -> i32 "Inline|Pure" { // CHECK: spv.func @bar(%{{.+}}: i32) -> i32 "Inline|Pure" {
spv.func @bar(%arg: i32) -> (i32) "Inline|Pure" { spv.func @bar(%arg: i32) -> (i32) "Inline|Pure" {
// CHECK-NEXT: spv. // CHECK-NEXT: spv.
spv.ReturnValue %arg: i32 spv.ReturnValue %arg: i32
// CHECK-NEXT: } // CHECK-NEXT: }
} }
// CHECK: spv.func @baz(%{{.+}}: i32) "DontInline" attributes {additional_stuff = 64 : i64} // CHECK: spv.func @baz(%{{.+}}: i32) "DontInline" attributes {additional_stuff = 64 : i64}
spv.func @baz(%arg: i32) "DontInline" attributes { spv.func @baz(%arg: i32) "DontInline" attributes {
additional_stuff = 64 additional_stuff = 64
} { spv.Return } } { spv.Return }
// ----- // -----
// expected-error @+1 {{expected function_control attribute specified as string}} // expected-error @+1 {{expected function_control attribute specified as string}}
spv.func @missing_function_control() { spv.Return } spv.func @missing_function_control() { spv.Return }
// ----- // -----
// expected-error @+1 {{cannot have more than one result}} // expected-error @+1 {{cannot have more than one result}}
spv.func @cannot_have_more_than_one_result(%arg: i32) -> (i32, i32) "None" spv.func @cannot_have_more_than_one_result(%arg: i32) -> (i32, i32) "None"
// ----- // -----
// expected-error @+1 {{expected SSA identifier}} // expected-error @+1 {{expected SSA identifier}}
spv.func @cannot_have_variadic_arguments(%arg: i32, ...) "None" spv.func @cannot_have_variadic_arguments(%arg: i32, ...) "None"
// ----- // -----
// Nested function // Nested function
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @outer_func() -> () "None" { spv.func @outer_func() -> () "None" {
// expected-error @+1 {{must appear in a module-like op's block}} // expected-error @+1 {{must appear in a module-like op's block}}
spv.func @inner_func() -> () "None" { spv.func @inner_func() -> () "None" {
spv.Return spv.Return
} }
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.globalVariable // spv.globalVariable
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
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
// CHECK: spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private> // CHECK: spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private>
spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private> spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private>
} }
// ----- // -----
// Allow initializers coming from other module-like ops // Allow initializers coming from other module-like ops
spv.specConstant @sc = 4.0 : f32 spv.specConstant @sc = 4.0 : f32
// CHECK: spv.globalVariable @var initializer(@sc) // CHECK: spv.globalVariable @var initializer(@sc)
spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private> spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private>
// ----- // -----
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>
spv.globalVariable @var1 built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @var1 built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Input>
// CHECK: spv.globalVariable @var2 built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Input> // CHECK: spv.globalVariable @var2 built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Input>
spv.globalVariable @var2 {built_in = "GlobalInvocationID"} : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @var2 {built_in = "GlobalInvocationID"} : !spv.ptr<vector<3xi32>, Input>
} }
// ----- // -----
// Allow in other module-like ops // Allow in other module-like ops
module { module {
// CHECK: spv.globalVariable // CHECK: spv.globalVariable
spv.globalVariable @var0 : !spv.ptr<f32, Input> spv.globalVariable @var0 : !spv.ptr<f32, Input>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{expected spv.ptr type}} // expected-error @+1 {{expected spv.ptr type}}
spv.globalVariable @var0 : f32 spv.globalVariable @var0 : f32
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{op initializer must be result of a spv.specConstant or spv.globalVariable op}} // expected-error @+1 {{op initializer must be result of a spv.specConstant or spv.globalVariable op}}
spv.globalVariable @var0 initializer(@var1) : !spv.ptr<f32, Private> spv.globalVariable @var0 initializer(@var1) : !spv.ptr<f32, Private>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{storage class cannot be 'Generic'}} // expected-error @+1 {{storage class cannot be 'Generic'}}
spv.globalVariable @var0 : !spv.ptr<f32, Generic> spv.globalVariable @var0 : !spv.ptr<f32, Generic>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{storage class cannot be 'Function'}} // expected-error @+1 {{storage class cannot be 'Function'}}
spv.globalVariable @var0 : !spv.ptr<f32, Function> spv.globalVariable @var0 : !spv.ptr<f32, Function>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo() "None" { spv.func @foo() "None" {
// expected-error @+1 {{op must appear in a module-like op's block}} // expected-error @+1 {{op must appear in a module-like op's block}}
spv.globalVariable @var0 : !spv.ptr<f32, Input> spv.globalVariable @var0 : !spv.ptr<f32, Input>
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.module // spv.module
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Module without capability and extension // Module without capability and extension
// CHECK: spv.module Logical GLSL450 // CHECK: spv.module Logical GLSL450
spv.module Logical GLSL450 { } spv.module Logical GLSL450 { }
// Module with a name // Module with a name
// CHECK: spv.module @{{.*}} Logical GLSL450 // CHECK: spv.module @{{.*}} Logical GLSL450
spv.module @name Logical GLSL450 { } spv.module @name Logical GLSL450 { }
// Module with (version, capabilities, extensions) triple // Module with (version, capabilities, extensions) triple
// CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> // CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]>
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> { } spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> { }
// Module with additional attributes // Module with additional attributes
// CHECK: spv.module Logical GLSL450 attributes {foo = "bar"} // CHECK: spv.module Logical GLSL450 attributes {foo = "bar"}
spv.module Logical GLSL450 attributes {foo = "bar"} { } spv.module Logical GLSL450 attributes {foo = "bar"} { }
// Module with VCE triple and additional attributes // Module with VCE triple and additional attributes
// CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> attributes {foo = "bar"} // CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> attributes {foo = "bar"}
spv.module Logical GLSL450 spv.module Logical GLSL450
requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]> requires #spv.vce<v1.0, [Shader], [SPV_KHR_16bit_storage]>
attributes {foo = "bar"} { } attributes {foo = "bar"} { }
// Module with explicit spv.mlir.endmodule // Module with explicit spv.mlir.endmodule
// CHECK: spv.module // CHECK: spv.module
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.mlir.endmodule spv.mlir.endmodule
} }
// Module with function // Module with function
// CHECK: spv.module // CHECK: spv.module
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
spv.Return spv.Return
} }
} }
// ----- // -----
// Missing addressing model // Missing addressing model
// expected-error@+1 {{'spv.module' expected valid keyword}} // expected-error@+1 {{'spv.module' expected valid keyword}}
spv.module { } spv.module { }
// ----- // -----
// Wrong addressing model // Wrong addressing model
// expected-error@+1 {{'spv.module' invalid addressing_model attribute specification: Physical}} // expected-error@+1 {{'spv.module' invalid addressing_model attribute specification: Physical}}
spv.module Physical { } spv.module Physical { }
// ----- // -----
// Missing memory model // Missing memory model
// expected-error@+1 {{'spv.module' expected valid keyword}} // expected-error@+1 {{'spv.module' expected valid keyword}}
spv.module Logical { } spv.module Logical { }
// ----- // -----
// Wrong memory model // Wrong memory model
// expected-error@+1 {{'spv.module' invalid memory_model attribute specification: Bla}} // expected-error@+1 {{'spv.module' invalid memory_model attribute specification: Bla}}
spv.module Logical Bla { } spv.module Logical Bla { }
// ----- // -----
// Module with multiple blocks // Module with multiple blocks
// expected-error @+1 {{expects region #0 to have 0 or 1 blocks}} // expected-error @+1 {{expects region #0 to have 0 or 1 blocks}}
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
^first: ^first:
spv.Return spv.Return
^second: ^second:
spv.Return spv.Return
} }
// ----- // -----
// 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"() : () -> ()
} }
// ----- // -----
// Use non SPIR-V op inside function // Use non SPIR-V op inside function
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @do_nothing() -> () "None" { spv.func @do_nothing() -> () "None" {
// expected-error @+1 {{functions in 'spv.module' can only contain spv.* ops}} // expected-error @+1 {{functions in 'spv.module' can only contain spv.* ops}}
"dialect.op"() : () -> () "dialect.op"() : () -> ()
} }
} }
// ----- // -----
// Use external function // Use external function
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{'spv.module' cannot contain external functions}} // expected-error @+1 {{'spv.module' cannot contain external functions}}
spv.func @extern() -> () "None" spv.func @extern() -> () "None"
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.mlir.endmodule // spv.mlir.endmodule
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @module_end_not_in_module() -> () { func @module_end_not_in_module() -> () {
// expected-error @+1 {{op must appear in a module-like op's block}} // expected-error @+1 {{op must appear in a module-like op's block}}
spv.mlir.endmodule spv.mlir.endmodule
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.mlir.referenceof // spv.mlir.referenceof
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = false spv.specConstant @sc1 = false
spv.specConstant @sc2 = 42 : i64 spv.specConstant @sc2 = 42 : i64
spv.specConstant @sc3 = 1.5 : f32 spv.specConstant @sc3 = 1.5 : f32
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i1, i64, f32)> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i1, i64, f32)>
// CHECK-LABEL: @reference // CHECK-LABEL: @reference
spv.func @reference() -> i1 "None" { spv.func @reference() -> i1 "None" {
// CHECK: spv.mlir.referenceof @sc1 : i1 // CHECK: spv.mlir.referenceof @sc1 : i1
%0 = spv.mlir.referenceof @sc1 : i1 %0 = spv.mlir.referenceof @sc1 : i1
spv.ReturnValue %0 : i1 spv.ReturnValue %0 : i1
} }
// CHECK-LABEL: @reference_composite // CHECK-LABEL: @reference_composite
spv.func @reference_composite() -> i1 "None" { spv.func @reference_composite() -> i1 "None" {
// CHECK: spv.mlir.referenceof @scc : !spv.struct<(i1, i64, f32)> // CHECK: spv.mlir.referenceof @scc : !spv.struct<(i1, i64, f32)>
%0 = spv.mlir.referenceof @scc : !spv.struct<(i1, i64, f32)> %0 = spv.mlir.referenceof @scc : !spv.struct<(i1, i64, f32)>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.struct<(i1, i64, f32)> %1 = spv.CompositeExtract %0[0 : i32] : !spv.struct<(i1, i64, f32)>
spv.ReturnValue %1 : i1 spv.ReturnValue %1 : i1
} }
// CHECK-LABEL: @initialize // CHECK-LABEL: @initialize
spv.func @initialize() -> i64 "None" { spv.func @initialize() -> i64 "None" {
// CHECK: spv.mlir.referenceof @sc2 : i64 // CHECK: spv.mlir.referenceof @sc2 : i64
%0 = spv.mlir.referenceof @sc2 : i64 %0 = spv.mlir.referenceof @sc2 : i64
%1 = spv.Variable init(%0) : !spv.ptr<i64, Function> %1 = spv.Variable init(%0) : !spv.ptr<i64, Function>
%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
spv.specConstant @sc = 5 : i32 spv.specConstant @sc = 5 : i32
func @reference_of() { func @reference_of() {
// CHECK: spv.mlir.referenceof @sc // CHECK: spv.mlir.referenceof @sc
%0 = spv.mlir.referenceof @sc : i32 %0 = spv.mlir.referenceof @sc : i32
return return
} }
// ----- // -----
spv.specConstant @sc = 5 : i32 spv.specConstant @sc = 5 : i32
spv.specConstantComposite @scc (@sc) : !spv.array<1 x i32> spv.specConstantComposite @scc (@sc) : !spv.array<1 x i32>
func @reference_of_composite() { func @reference_of_composite() {
// CHECK: spv.mlir.referenceof @scc : !spv.array<1 x i32> // CHECK: spv.mlir.referenceof @scc : !spv.array<1 x i32>
%0 = spv.mlir.referenceof @scc : !spv.array<1 x i32> %0 = spv.mlir.referenceof @scc : !spv.array<1 x i32>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.array<1 x i32> %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<1 x i32>
return return
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// expected-error @+1 {{expected spv.specConstant or spv.SpecConstantComposite symbol}} // expected-error @+1 {{expected spv.specConstant or spv.SpecConstantComposite symbol}}
%0 = spv.mlir.referenceof @sc : i32 %0 = spv.mlir.referenceof @sc : i32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc = 42 : i32 spv.specConstant @sc = 42 : i32
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// expected-error @+1 {{result type mismatch with the referenced specialization constant's type}} // expected-error @+1 {{result type mismatch with the referenced specialization constant's type}}
%0 = spv.mlir.referenceof @sc : f32 %0 = spv.mlir.referenceof @sc : f32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc = 42 : i32 spv.specConstant @sc = 42 : i32
spv.specConstantComposite @scc (@sc) : !spv.array<1 x i32> spv.specConstantComposite @scc (@sc) : !spv.array<1 x i32>
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
// expected-error @+1 {{result type mismatch with the referenced specialization constant's type}} // expected-error @+1 {{result type mismatch with the referenced specialization constant's type}}
%0 = spv.mlir.referenceof @scc : f32 %0 = spv.mlir.referenceof @scc : f32
spv.Return spv.Return
} }
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.specConstant // spv.specConstant
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// CHECK: spv.specConstant @sc1 = false // CHECK: spv.specConstant @sc1 = false
spv.specConstant @sc1 = false spv.specConstant @sc1 = false
// CHECK: spv.specConstant @sc2 spec_id(5) = 42 : i64 // CHECK: spv.specConstant @sc2 spec_id(5) = 42 : i64
spv.specConstant @sc2 spec_id(5) = 42 : i64 spv.specConstant @sc2 spec_id(5) = 42 : i64
// CHECK: spv.specConstant @sc3 = 1.500000e+00 : f32 // CHECK: spv.specConstant @sc3 = 1.500000e+00 : f32
spv.specConstant @sc3 = 1.5 : f32 spv.specConstant @sc3 = 1.5 : f32
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{SpecId cannot be negative}} // expected-error @+1 {{SpecId cannot be negative}}
spv.specConstant @sc2 spec_id(-5) = 42 : i64 spv.specConstant @sc2 spec_id(-5) = 42 : i64
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{default value bitwidth disallowed}} // expected-error @+1 {{default value bitwidth disallowed}}
spv.specConstant @sc = 15 : i4 spv.specConstant @sc = 15 : i4
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{default value can only be a bool, integer, or float scalar}} // expected-error @+1 {{default value can only be a bool, integer, or float scalar}}
spv.specConstant @sc = dense<[2, 3]> : vector<2xi32> spv.specConstant @sc = dense<[2, 3]> : vector<2xi32>
} }
// ----- // -----
func @use_in_function() -> () { func @use_in_function() -> () {
// expected-error @+1 {{op must appear in a module-like op's block}} // expected-error @+1 {{op must appear in a module-like op's block}}
spv.specConstant @sc = false spv.specConstant @sc = false
return return
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.specConstantComposite // spv.specConstantComposite
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
// expected-error @+1 {{result type must be a composite type}} // expected-error @+1 {{result type must be a composite type}}
spv.specConstantComposite @scc2 (@sc1, @sc2, @sc3) : i32 spv.specConstantComposite @scc2 (@sc1, @sc2, @sc3) : i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.specConstantComposite (spv.array) // spv.specConstantComposite (spv.array)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1.5 : f32 spv.specConstant @sc1 = 1.5 : f32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32> // CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = false spv.specConstant @sc1 = false
spv.specConstant @sc2 spec_id(5) = 42 : i64 spv.specConstant @sc2 spec_id(5) = 42 : i64
spv.specConstant @sc3 = 1.5 : f32 spv.specConstant @sc3 = 1.5 : f32
// expected-error @+1 {{has incorrect number of operands: expected 4, but provided 3}} // expected-error @+1 {{has incorrect number of operands: expected 4, but provided 3}}
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<4 x f32> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<4 x f32>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1 : i32 spv.specConstant @sc1 = 1 : i32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// expected-error @+1 {{has incorrect types of operands: expected 'f32', but provided 'i32'}} // expected-error @+1 {{has incorrect types of operands: expected 'f32', but provided 'i32'}}
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.specConstantComposite (spv.struct) // spv.specConstantComposite (spv.struct)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1 : i32 spv.specConstant @sc1 = 1 : i32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)> // CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1 : i32 spv.specConstant @sc1 = 1 : i32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// expected-error @+1 {{has incorrect number of operands: expected 2, but provided 3}} // expected-error @+1 {{has incorrect number of operands: expected 2, but provided 3}}
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32)> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32)>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1.5 : f32 spv.specConstant @sc1 = 1.5 : f32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// expected-error @+1 {{has incorrect types of operands: expected 'i32', but provided 'f32'}} // expected-error @+1 {{has incorrect types of operands: expected 'i32', but provided 'f32'}}
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.specConstantComposite (vector) // spv.specConstantComposite (vector)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1.5 : f32 spv.specConstant @sc1 = 1.5 : f32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32> // CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32>
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3 x f32> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3 x f32>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = false spv.specConstant @sc1 = false
spv.specConstant @sc2 spec_id(5) = 42 : i64 spv.specConstant @sc2 spec_id(5) = 42 : i64
spv.specConstant @sc3 = 1.5 : f32 spv.specConstant @sc3 = 1.5 : f32
// expected-error @+1 {{has incorrect number of operands: expected 4, but provided 3}} // expected-error @+1 {{has incorrect number of operands: expected 4, but provided 3}}
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<4xf32> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<4xf32>
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1 : i32 spv.specConstant @sc1 = 1 : i32
spv.specConstant @sc2 = 2.5 : f32 spv.specConstant @sc2 = 2.5 : f32
spv.specConstant @sc3 = 3.5 : f32 spv.specConstant @sc3 = 3.5 : f32
// expected-error @+1 {{has incorrect types of operands: expected 'f32', but provided 'i32'}} // expected-error @+1 {{has incorrect types of operands: expected 'f32', but provided 'i32'}}
spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32> spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.specConstantComposite (spv.coopmatrix) // spv.specConstantComposite (spv.coopmatrix)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @sc1 = 1.5 : f32 spv.specConstant @sc1 = 1.5 : f32
// expected-error @+1 {{unsupported composite type}} // expected-error @+1 {{unsupported composite type}}
spv.specConstantComposite @scc (@sc1) : !spv.coopmatrix<8x16xf32, Device> spv.specConstantComposite @scc (@sc1) : !spv.coopmatrix<8x16xf32, Device>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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
} }
} }
// ----- // -----
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 {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
%0 = spv.Variable : !spv.ptr<i32, Function> %0 = spv.Variable : !spv.ptr<i32, Function>
// expected-error @+1 {{invalid enclosed op}} // expected-error @+1 {{invalid enclosed op}}
%1 = spv.SpecConstantOperation wraps "spv.Load"(%0) {memory_access = 0 : i32} : (!spv.ptr<i32, Function>) -> i32 %1 = spv.SpecConstantOperation wraps "spv.Load"(%0) {memory_access = 0 : i32} : (!spv.ptr<i32, Function>) -> i32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo() -> () "None" { spv.func @foo() -> () "None" {
%0 = spv.Variable : !spv.ptr<i32, Function> %0 = spv.Variable : !spv.ptr<i32, Function>
%1 = spv.Load "Function" %0 : i32 %1 = spv.Load "Function" %0 : i32
// expected-error @+1 {{invalid operand, must be defined by a constant operation}} // expected-error @+1 {{invalid operand, must be defined by a constant operation}}
%2 = spv.SpecConstantOperation wraps "spv.IAdd"(%1, %1) : (i32, i32) -> i32 %2 = spv.SpecConstantOperation wraps "spv.IAdd"(%1, %1) : (i32, i32) -> i32
spv.Return spv.Return
} }
} }

mlir/test/Dialect/SPIRV/IR/target-and-abi.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/target-and-abi.mlir.
// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
// expected-error @+1 {{found unsupported 'spv.something' attribute on operation}} // expected-error @+1 {{found unsupported 'spv.something' attribute on operation}}
func @unknown_attr_on_op() attributes { func @unknown_attr_on_op() attributes {
spv.something = 64 spv.something = 64
} { return } } { return }
// ----- // -----
// expected-error @+1 {{found unsupported 'spv.something' attribute on region argument}} // expected-error @+1 {{found unsupported 'spv.something' attribute on region argument}}
func @unknown_attr_on_region(%arg: i32 {spv.something}) { func @unknown_attr_on_region(%arg: i32 {spv.something}) {
return return
} }
// ----- // -----
// expected-error @+1 {{cannot attach SPIR-V attributes to region result}} // expected-error @+1 {{cannot attach SPIR-V attributes to region result}}
func @unknown_attr_on_region() -> (i32 {spv.something}) { func @unknown_attr_on_region() -> (i32 {spv.something}) {
%0 = constant 10.0 : f32 %0 = constant 10.0 : f32
return %0: f32 return %0: f32
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.entry_point_abi // spv.entry_point_abi
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// expected-error @+1 {{'spv.entry_point_abi' attribute must be a dictionary attribute containing one 32-bit integer elements attribute: 'local_size'}} // expected-error @+1 {{'spv.entry_point_abi' attribute must be a dictionary attribute containing one 32-bit integer elements attribute: 'local_size'}}
func @spv_entry_point() attributes { func @spv_entry_point() attributes {
spv.entry_point_abi = 64 spv.entry_point_abi = 64
} { return } } { return }
// ----- // -----
// expected-error @+1 {{'spv.entry_point_abi' attribute must be a dictionary attribute containing one 32-bit integer elements attribute: 'local_size'}} // expected-error @+1 {{'spv.entry_point_abi' attribute must be a dictionary attribute containing one 32-bit integer elements attribute: 'local_size'}}
func @spv_entry_point() attributes { func @spv_entry_point() attributes {
spv.entry_point_abi = {local_size = 64} spv.entry_point_abi = {local_size = 64}
} { return } } { return }
// ----- // -----
func @spv_entry_point() attributes { func @spv_entry_point() attributes {
// CHECK: {spv.entry_point_abi = {local_size = dense<[64, 1, 1]> : vector<3xi32>}} // CHECK: {spv.entry_point_abi = {local_size = dense<[64, 1, 1]> : vector<3xi32>}}
spv.entry_point_abi = {local_size = dense<[64, 1, 1]>: vector<3xi32>} spv.entry_point_abi = {local_size = dense<[64, 1, 1]>: vector<3xi32>}
} { return } } { return }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.interface_var_abi // spv.interface_var_abi
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// expected-error @+1 {{'spv.interface_var_abi' must be a spirv::InterfaceVarABIAttr}} // expected-error @+1 {{'spv.interface_var_abi' must be a spirv::InterfaceVarABIAttr}}
func @interface_var( func @interface_var(
%arg0 : f32 {spv.interface_var_abi = 64} %arg0 : f32 {spv.interface_var_abi = 64}
) { return } ) { return }
// ----- // -----
func @interface_var( func @interface_var(
// expected-error @+1 {{missing descriptor set}} // expected-error @+1 {{missing descriptor set}}
%arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<()>} %arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<()>}
) { return } ) { return }
// ----- // -----
func @interface_var( func @interface_var(
// expected-error @+1 {{missing binding}} // expected-error @+1 {{missing binding}}
%arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(1,)>} %arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(1,)>}
) { return } ) { return }
// ----- // -----
func @interface_var( func @interface_var(
// expected-error @+1 {{unknown storage class: }} // expected-error @+1 {{unknown storage class: }}
%arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(1,2), Foo>} %arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(1,2), Foo>}
) { return } ) { return }
// ----- // -----
// CHECK: {spv.interface_var_abi = #spv.interface_var_abi<(0, 1), Uniform>} // CHECK: {spv.interface_var_abi = #spv.interface_var_abi<(0, 1), Uniform>}
func @interface_var( func @interface_var(
%arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(0, 1), Uniform>} %arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(0, 1), Uniform>}
) { return } ) { return }
// ----- // -----
// CHECK: {spv.interface_var_abi = #spv.interface_var_abi<(0, 1)>} // CHECK: {spv.interface_var_abi = #spv.interface_var_abi<(0, 1)>}
func @interface_var( func @interface_var(
%arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(0, 1)>} %arg0 : f32 {spv.interface_var_abi = #spv.interface_var_abi<(0, 1)>}
) { return } ) { return }
// ----- // -----
// expected-error @+1 {{'spv.interface_var_abi' attribute cannot specify storage class when attaching to a non-scalar value}} // expected-error @+1 {{'spv.interface_var_abi' attribute cannot specify storage class when attaching to a non-scalar value}}
func @interface_var( func @interface_var(
%arg0 : memref<4xf32> {spv.interface_var_abi = #spv.interface_var_abi<(0, 1), Uniform>} %arg0 : memref<4xf32> {spv.interface_var_abi = #spv.interface_var_abi<(0, 1), Uniform>}
) { return } ) { return }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.target_env // spv.target_env
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @target_env_wrong_limits() attributes { func @target_env_wrong_limits() 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]>,
// expected-error @+1 {{limits must be a dictionary attribute containing two 32-bit integer attributes 'max_compute_workgroup_invocations' and 'max_compute_workgroup_size'}} // expected-error @+1 {{limits must be a dictionary attribute containing two 32-bit integer attributes 'max_compute_workgroup_invocations' and 'max_compute_workgroup_size'}}
{max_compute_workgroup_invocations = 128 : i64, max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32>}> {max_compute_workgroup_invocations = 128 : i64, max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32>}>
} { return } } { return }
// ----- // -----
func @target_env() attributes { func @target_env() attributes {
// CHECK: spv.target_env = #spv.target_env< // CHECK: spv.target_env = #spv.target_env<
// CHECK-SAME: #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>, // CHECK-SAME: #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>,
// CHECK-SAME: {max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32>}> // CHECK-SAME: {max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32>}>
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]>,
{ {
max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_invocations = 128 : i32,
max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32> max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32>
}> }>
} { return } } { return }
// ----- // -----
func @target_env_vendor_id() attributes { func @target_env_vendor_id() attributes {
// CHECK: spv.target_env = #spv.target_env< // CHECK: spv.target_env = #spv.target_env<
// CHECK-SAME: #spv.vce<v1.0, [], []>, // CHECK-SAME: #spv.vce<v1.0, [], []>,
// CHECK-SAME: NVIDIA, // CHECK-SAME: NVIDIA,
// CHECK-SAME: {}> // CHECK-SAME: {}>
spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, NVIDIA, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, NVIDIA, {}>
} { return } } { return }
// ----- // -----
func @target_env_vendor_id_device_type() attributes { func @target_env_vendor_id_device_type() attributes {
// CHECK: spv.target_env = #spv.target_env< // CHECK: spv.target_env = #spv.target_env<
// CHECK-SAME: #spv.vce<v1.0, [], []>, // CHECK-SAME: #spv.vce<v1.0, [], []>,
// CHECK-SAME: AMD:DiscreteGPU, // CHECK-SAME: AMD:DiscreteGPU,
// CHECK-SAME: {}> // CHECK-SAME: {}>
spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, AMD:DiscreteGPU, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, AMD:DiscreteGPU, {}>
} { return } } { return }
// ----- // -----
func @target_env_vendor_id_device_type_device_id() attributes { func @target_env_vendor_id_device_type_device_id() attributes {
// CHECK: spv.target_env = #spv.target_env< // CHECK: spv.target_env = #spv.target_env<
// CHECK-SAME: #spv.vce<v1.0, [], []>, // CHECK-SAME: #spv.vce<v1.0, [], []>,
// CHECK-SAME: Qualcomm:IntegratedGPU:100925441, // CHECK-SAME: Qualcomm:IntegratedGPU:100925441,
// CHECK-SAME: {}> // CHECK-SAME: {}>
spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, Qualcomm:IntegratedGPU:0x6040001, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [], []>, Qualcomm:IntegratedGPU:0x6040001, {}>
} { return } } { return }
// ----- // -----
func @target_env_extra_fields() attributes { func @target_env_extra_fields() attributes {
// expected-error @+6 {{expected '>'}} // expected-error @+6 {{expected '>'}}
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]>,
{ {
max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_invocations = 128 : i32,
max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32> max_compute_workgroup_size = dense<[128, 64, 64]> : vector<3xi32>
}, },
more_stuff more_stuff
> >
} { return } } { return }
// ----- // -----
func @target_env_cooperative_matrix() attributes{ func @target_env_cooperative_matrix() attributes{
// CHECK: spv.target_env = #spv.target_env< // CHECK: spv.target_env = #spv.target_env<
// CHECK-SAME: SPV_NV_cooperative_matrix // CHECK-SAME: SPV_NV_cooperative_matrix
// CHECK-SAME: cooperative_matrix_properties_nv = [ // CHECK-SAME: cooperative_matrix_properties_nv = [
// CHECK-SAME: {a_type = i8, b_type = i8, c_type = i32, // CHECK-SAME: {a_type = i8, b_type = i8, c_type = i32,
// CHECK-SAME: k_size = 32 : i32, m_size = 8 : i32, n_size = 8 : i32 // CHECK-SAME: k_size = 32 : i32, m_size = 8 : i32, n_size = 8 : i32
// CHECK-SAME: result_type = i32, scope = 3 : i32} // CHECK-SAME: result_type = i32, scope = 3 : i32}
// CHECK-SAME: {a_type = f16, b_type = f16, c_type = f16, // CHECK-SAME: {a_type = f16, b_type = f16, c_type = f16,
// CHECK-SAME: k_size = 16 : i32, m_size = 8 : i32, n_size = 8 : i32 // CHECK-SAME: k_size = 16 : i32, m_size = 8 : i32, n_size = 8 : i32
// CHECK-SAME: result_type = f16, scope = 3 : i32} // CHECK-SAME: result_type = f16, scope = 3 : i32}
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,
SPV_NV_cooperative_matrix]>, SPV_NV_cooperative_matrix]>,
{ {
cooperative_matrix_properties_nv = [{ cooperative_matrix_properties_nv = [{
m_size = 8: i32, m_size = 8: i32,
n_size = 8: i32, n_size = 8: i32,
k_size = 32: i32, k_size = 32: i32,
a_type = i8, a_type = i8,
b_type = i8, b_type = i8,
c_type = i32, c_type = i32,
result_type = i32, result_type = i32,
scope = 3: i32 scope = 3: i32
}, { }, {
m_size = 8: i32, m_size = 8: i32,
n_size = 8: i32, n_size = 8: i32,
k_size = 16: i32, k_size = 16: i32,
a_type = f16, a_type = f16,
b_type = f16, b_type = f16,
c_type = f16, c_type = f16,
result_type = f16, result_type = f16,
scope = 3: i32 scope = 3: i32
}] }]
}> }>
} { return } } { return }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.vce // spv.vce
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @vce_wrong_type() attributes { func @vce_wrong_type() attributes {
// expected-error @+1 {{expected valid keyword}} // expected-error @+1 {{expected valid keyword}}
vce = #spv.vce<64> vce = #spv.vce<64>
} { return } } { return }
// ----- // -----
func @vce_missing_fields() attributes { func @vce_missing_fields() attributes {
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
vce = #spv.vce<v1.0> vce = #spv.vce<v1.0>
} { return } } { return }
// ----- // -----
func @vce_wrong_version() attributes { func @vce_wrong_version() attributes {
// expected-error @+1 {{unknown version: V_x_y}} // expected-error @+1 {{unknown version: V_x_y}}
vce = #spv.vce<V_x_y, []> vce = #spv.vce<V_x_y, []>
} { return } } { return }
// ----- // -----
func @vce_wrong_extension_type() attributes { func @vce_wrong_extension_type() attributes {
// expected-error @+1 {{expected valid keyword}} // expected-error @+1 {{expected valid keyword}}
vce = #spv.vce<v1.0, [32: i32], [Shader]> vce = #spv.vce<v1.0, [32: i32], [Shader]>
} { return } } { return }
// ----- // -----
func @vce_wrong_extension() attributes { func @vce_wrong_extension() attributes {
// expected-error @+1 {{unknown extension: SPV_Something}} // expected-error @+1 {{unknown extension: SPV_Something}}
vce = #spv.vce<v1.0, [Shader], [SPV_Something]> vce = #spv.vce<v1.0, [Shader], [SPV_Something]>
} { return } } { return }
// ----- // -----
func @vce_wrong_capability() attributes { func @vce_wrong_capability() attributes {
// expected-error @+1 {{unknown capability: Something}} // expected-error @+1 {{unknown capability: Something}}
vce = #spv.vce<v1.0, [Something], []> vce = #spv.vce<v1.0, [Something], []>
} { return } } { return }
// ----- // -----
func @vce() attributes { func @vce() attributes {
// CHECK: #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]> // CHECK: #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>
vce = #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]> vce = #spv.vce<v1.0, [Shader], [SPV_KHR_storage_buffer_storage_class]>
} { return } } { return }

mlir/test/Dialect/SPIRV/IR/target-env.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/target-env.mlir.
// RUN: mlir-opt -mlir-disable-threading -test-spirv-target-env %s | FileCheck %s // RUN: mlir-opt -mlir-disable-threading -test-spirv-target-env %s | FileCheck %s
// Note: The following tests check that a spv.target_env can properly control // Note: The following tests check that a spv.target_env can properly control
// the conversion target and filter unavailable ops during the conversion. // the conversion target and filter unavailable ops during the conversion.
// We don't care about the op argument consistency too much; so certain enum // We don't care about the op argument consistency too much; so certain enum
// values for enum attributes may not make much sense for the test op. // values for enum attributes may not make much sense for the test op.
// spv.AtomicCompareExchangeWeak is available from SPIR-V 1.0 to 1.3 under // spv.AtomicCompareExchangeWeak is available from SPIR-V 1.0 to 1.3 under
// Kernel capability. // Kernel capability.
// spv.AtomicCompareExchangeWeak has two memory semantics enum attribute, // spv.AtomicCompareExchangeWeak has two memory semantics enum attribute,
// whose value, if containing AtomicCounterMemory bit, additionally requires // whose value, if containing AtomicCounterMemory bit, additionally requires
// AtomicStorage capability. // AtomicStorage capability.
// spv.BitReverse is available in all SPIR-V versions under Shader capability. // spv.BitReverse is available in all SPIR-V versions under Shader capability.
// spv.GroupNonUniformBallot is available starting from SPIR-V 1.3 under // spv.GroupNonUniformBallot is available starting from SPIR-V 1.3 under
// GroupNonUniform capability. // GroupNonUniform capability.
// spv.SubgroupBallotKHR is available under in all SPIR-V versions under // spv.SubgroupBallotKHR is available under in all SPIR-V versions under
// SubgroupBallotKHR capability and SPV_KHR_shader_ballot extension. // SubgroupBallotKHR capability and SPV_KHR_shader_ballot extension.
// The GeometryPointSize capability implies the Geometry capability, which // The GeometryPointSize capability implies the Geometry capability, which
// implies the Shader capability. // implies the Shader capability.
// PhysicalStorageBuffer64 addressing model is available via extension // PhysicalStorageBuffer64 addressing model is available via extension
// SPV_EXT_physical_storage_buffer or SPV_KHR_physical_storage_buffer; // SPV_EXT_physical_storage_buffer or SPV_KHR_physical_storage_buffer;
// both extensions are incorporated into SPIR-V 1.5. // both extensions are incorporated into SPIR-V 1.5.
// Vulkan memory model is available via extension SPV_KHR_vulkan_memory_model, // Vulkan memory model is available via extension SPV_KHR_vulkan_memory_model,
// which extensions are incorporated into SPIR-V 1.5. // which extensions are incorporated into SPIR-V 1.5.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MaxVersion // MaxVersion
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @cmp_exchange_weak_suitable_version_capabilities // CHECK-LABEL: @cmp_exchange_weak_suitable_version_capabilities
func @cmp_exchange_weak_suitable_version_capabilities(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes { func @cmp_exchange_weak_suitable_version_capabilities(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.1, [Kernel, AtomicStorage], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.1, [Kernel, AtomicStorage], []>, {}>
} { } {
// CHECK: spv.AtomicCompareExchangeWeak "Workgroup" "AcquireRelease|AtomicCounterMemory" "Acquire" // CHECK: spv.AtomicCompareExchangeWeak "Workgroup" "AcquireRelease|AtomicCounterMemory" "Acquire"
%0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32) %0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32)
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @cmp_exchange_weak_unsupported_version // CHECK-LABEL: @cmp_exchange_weak_unsupported_version
func @cmp_exchange_weak_unsupported_version(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes { func @cmp_exchange_weak_unsupported_version(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.4, [Kernel, AtomicStorage], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.4, [Kernel, AtomicStorage], []>, {}>
} { } {
// CHECK: test.convert_to_atomic_compare_exchange_weak_op // CHECK: test.convert_to_atomic_compare_exchange_weak_op
%0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32) %0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32)
return %0: i32 return %0: i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// MinVersion // MinVersion
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @group_non_uniform_ballot_suitable_version // CHECK-LABEL: @group_non_uniform_ballot_suitable_version
func @group_non_uniform_ballot_suitable_version(%predicate: i1) -> vector<4xi32> attributes { func @group_non_uniform_ballot_suitable_version(%predicate: i1) -> vector<4xi32> attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.4, [GroupNonUniformBallot], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.4, [GroupNonUniformBallot], []>, {}>
} { } {
// CHECK: spv.GroupNonUniformBallot "Workgroup" // CHECK: spv.GroupNonUniformBallot "Workgroup"
%0 = "test.convert_to_group_non_uniform_ballot_op"(%predicate): (i1) -> (vector<4xi32>) %0 = "test.convert_to_group_non_uniform_ballot_op"(%predicate): (i1) -> (vector<4xi32>)
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// CHECK-LABEL: @group_non_uniform_ballot_unsupported_version // CHECK-LABEL: @group_non_uniform_ballot_unsupported_version
func @group_non_uniform_ballot_unsupported_version(%predicate: i1) -> vector<4xi32> attributes { func @group_non_uniform_ballot_unsupported_version(%predicate: i1) -> vector<4xi32> attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.1, [GroupNonUniformBallot], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.1, [GroupNonUniformBallot], []>, {}>
} { } {
// CHECK: test.convert_to_group_non_uniform_ballot_op // CHECK: test.convert_to_group_non_uniform_ballot_op
%0 = "test.convert_to_group_non_uniform_ballot_op"(%predicate): (i1) -> (vector<4xi32>) %0 = "test.convert_to_group_non_uniform_ballot_op"(%predicate): (i1) -> (vector<4xi32>)
return %0: vector<4xi32> return %0: vector<4xi32>
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Capability // Capability
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @cmp_exchange_weak_missing_capability_kernel // CHECK-LABEL: @cmp_exchange_weak_missing_capability_kernel
func @cmp_exchange_weak_missing_capability_kernel(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes { func @cmp_exchange_weak_missing_capability_kernel(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.3, [AtomicStorage], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.3, [AtomicStorage], []>, {}>
} { } {
// CHECK: test.convert_to_atomic_compare_exchange_weak_op // CHECK: test.convert_to_atomic_compare_exchange_weak_op
%0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32) %0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32)
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @cmp_exchange_weak_missing_capability_atomic_storage // CHECK-LABEL: @cmp_exchange_weak_missing_capability_atomic_storage
func @cmp_exchange_weak_missing_capability_atomic_storage(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes { func @cmp_exchange_weak_missing_capability_atomic_storage(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.3, [Kernel], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.3, [Kernel], []>, {}>
} { } {
// CHECK: test.convert_to_atomic_compare_exchange_weak_op // CHECK: test.convert_to_atomic_compare_exchange_weak_op
%0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32) %0 = "test.convert_to_atomic_compare_exchange_weak_op"(%ptr, %value, %comparator): (!spv.ptr<i32, Workgroup>, i32, i32) -> (i32)
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @subgroup_ballot_missing_capability // CHECK-LABEL: @subgroup_ballot_missing_capability
func @subgroup_ballot_missing_capability(%predicate: i1) -> vector<4xi32> attributes { func @subgroup_ballot_missing_capability(%predicate: i1) -> vector<4xi32> attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.4, [], [SPV_KHR_shader_ballot]>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.4, [], [SPV_KHR_shader_ballot]>, {}>
} { } {
// CHECK: test.convert_to_subgroup_ballot_op // CHECK: test.convert_to_subgroup_ballot_op
%0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>) %0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>)
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// CHECK-LABEL: @bit_reverse_directly_implied_capability // CHECK-LABEL: @bit_reverse_directly_implied_capability
func @bit_reverse_directly_implied_capability(%operand: i32) -> i32 attributes { func @bit_reverse_directly_implied_capability(%operand: i32) -> i32 attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [Geometry], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [Geometry], []>, {}>
} { } {
// CHECK: spv.BitReverse // CHECK: spv.BitReverse
%0 = "test.convert_to_bit_reverse_op"(%operand): (i32) -> (i32) %0 = "test.convert_to_bit_reverse_op"(%operand): (i32) -> (i32)
return %0: i32 return %0: i32
} }
// CHECK-LABEL: @bit_reverse_recursively_implied_capability // CHECK-LABEL: @bit_reverse_recursively_implied_capability
func @bit_reverse_recursively_implied_capability(%operand: i32) -> i32 attributes { func @bit_reverse_recursively_implied_capability(%operand: i32) -> i32 attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [GeometryPointSize], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [GeometryPointSize], []>, {}>
} { } {
// CHECK: spv.BitReverse // CHECK: spv.BitReverse
%0 = "test.convert_to_bit_reverse_op"(%operand): (i32) -> (i32) %0 = "test.convert_to_bit_reverse_op"(%operand): (i32) -> (i32)
return %0: i32 return %0: i32
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Extension // Extension
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK-LABEL: @subgroup_ballot_suitable_extension // CHECK-LABEL: @subgroup_ballot_suitable_extension
func @subgroup_ballot_suitable_extension(%predicate: i1) -> vector<4xi32> attributes { func @subgroup_ballot_suitable_extension(%predicate: i1) -> vector<4xi32> attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.4, [SubgroupBallotKHR], [SPV_KHR_shader_ballot]>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.4, [SubgroupBallotKHR], [SPV_KHR_shader_ballot]>, {}>
} { } {
// CHECK: spv.SubgroupBallotKHR // CHECK: spv.SubgroupBallotKHR
%0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>) %0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>)
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// CHECK-LABEL: @subgroup_ballot_missing_extension // CHECK-LABEL: @subgroup_ballot_missing_extension
func @subgroup_ballot_missing_extension(%predicate: i1) -> vector<4xi32> attributes { func @subgroup_ballot_missing_extension(%predicate: i1) -> vector<4xi32> attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.4, [SubgroupBallotKHR], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.4, [SubgroupBallotKHR], []>, {}>
} { } {
// CHECK: test.convert_to_subgroup_ballot_op // CHECK: test.convert_to_subgroup_ballot_op
%0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>) %0 = "test.convert_to_subgroup_ballot_op"(%predicate): (i1) -> (vector<4xi32>)
return %0: vector<4xi32> return %0: vector<4xi32>
} }
// CHECK-LABEL: @module_suitable_extension1 // CHECK-LABEL: @module_suitable_extension1
func @module_suitable_extension1() attributes { func @module_suitable_extension1() attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_vulkan_memory_model, SPV_EXT_physical_storage_buffer]>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_vulkan_memory_model, SPV_EXT_physical_storage_buffer]>, {}>
} { } {
// CHECK: spv.module PhysicalStorageBuffer64 Vulkan // CHECK: spv.module PhysicalStorageBuffer64 Vulkan
"test.convert_to_module_op"() : () ->() "test.convert_to_module_op"() : () ->()
return return
} }
// CHECK-LABEL: @module_suitable_extension2 // CHECK-LABEL: @module_suitable_extension2
func @module_suitable_extension2() attributes { func @module_suitable_extension2() attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_vulkan_memory_model, SPV_KHR_physical_storage_buffer]>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_vulkan_memory_model, SPV_KHR_physical_storage_buffer]>, {}>
} { } {
// CHECK: spv.module PhysicalStorageBuffer64 Vulkan // CHECK: spv.module PhysicalStorageBuffer64 Vulkan
"test.convert_to_module_op"() : () -> () "test.convert_to_module_op"() : () -> ()
return return
} }
// CHECK-LABEL: @module_missing_extension_mm // CHECK-LABEL: @module_missing_extension_mm
func @module_missing_extension_mm() attributes { func @module_missing_extension_mm() attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_physical_storage_buffer]>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_physical_storage_buffer]>, {}>
} { } {
// CHECK: test.convert_to_module_op // CHECK: test.convert_to_module_op
"test.convert_to_module_op"() : () -> () "test.convert_to_module_op"() : () -> ()
return return
} }
// CHECK-LABEL: @module_missing_extension_am // CHECK-LABEL: @module_missing_extension_am
func @module_missing_extension_am() attributes { func @module_missing_extension_am() attributes {
spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_vulkan_memory_model]>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.0, [VulkanMemoryModel, PhysicalStorageBufferAddresses], [SPV_KHR_vulkan_memory_model]>, {}>
} { } {
// CHECK: test.convert_to_module_op // CHECK: test.convert_to_module_op
"test.convert_to_module_op"() : () -> () "test.convert_to_module_op"() : () -> ()
return return
} }
// CHECK-LABEL: @module_implied_extension // CHECK-LABEL: @module_implied_extension
func @module_implied_extension() attributes { func @module_implied_extension() attributes {
// Version 1.5 implies SPV_KHR_vulkan_memory_model and SPV_KHR_physical_storage_buffer. // Version 1.5 implies SPV_KHR_vulkan_memory_model and SPV_KHR_physical_storage_buffer.
spv.target_env = #spv.target_env<#spv.vce<v1.5, [VulkanMemoryModel, PhysicalStorageBufferAddresses], []>, {}> spv.target_env = #spv.target_env<#spv.vce<v1.5, [VulkanMemoryModel, PhysicalStorageBufferAddresses], []>, {}>
} { } {
// CHECK: spv.module PhysicalStorageBuffer64 Vulkan // CHECK: spv.module PhysicalStorageBuffer64 Vulkan
"test.convert_to_module_op"() : () -> () "test.convert_to_module_op"() : () -> ()
return return
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/types.mlir.
// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
// TODO: Add more tests after switching to the generic parser. // TODO: Add more tests after switching to the generic parser.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ArrayType // ArrayType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @scalar_array_type(!spv.array<16 x f32>, !spv.array<8 x i32>) // CHECK: func private @scalar_array_type(!spv.array<16 x f32>, !spv.array<8 x i32>)
func private @scalar_array_type(!spv.array<16xf32>, !spv.array<8 x i32>) -> () func private @scalar_array_type(!spv.array<16xf32>, !spv.array<8 x i32>) -> ()
// CHECK: func private @vector_array_type(!spv.array<32 x vector<4xf32>>) // CHECK: func private @vector_array_type(!spv.array<32 x vector<4xf32>>)
func private @vector_array_type(!spv.array< 32 x vector<4xf32> >) -> () func private @vector_array_type(!spv.array< 32 x vector<4xf32> >) -> ()
// CHECK: func private @array_type_stride(!spv.array<4 x !spv.array<4 x f32, stride=4>, stride=128>) // CHECK: func private @array_type_stride(!spv.array<4 x !spv.array<4 x f32, stride=4>, stride=128>)
func private @array_type_stride(!spv.array< 4 x !spv.array<4 x f32, stride=4>, stride = 128>) -> () func private @array_type_stride(!spv.array< 4 x !spv.array<4 x f32, stride=4>, stride = 128>) -> ()
// ----- // -----
// expected-error @+1 {{expected '<'}} // expected-error @+1 {{expected '<'}}
func private @missing_left_angle_bracket(!spv.array 4xf32>) -> () func private @missing_left_angle_bracket(!spv.array 4xf32>) -> ()
// ----- // -----
// expected-error @+1 {{expected single integer for array element count}} // expected-error @+1 {{expected single integer for array element count}}
func private @missing_count(!spv.array<f32>) -> () func private @missing_count(!spv.array<f32>) -> ()
// ----- // -----
// expected-error @+1 {{expected 'x' in dimension list}} // expected-error @+1 {{expected 'x' in dimension list}}
func private @missing_x(!spv.array<4 f32>) -> () func private @missing_x(!spv.array<4 f32>) -> ()
// ----- // -----
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
func private @missing_element_type(!spv.array<4x>) -> () func private @missing_element_type(!spv.array<4x>) -> ()
// ----- // -----
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
func private @cannot_parse_type(!spv.array<4xblabla>) -> () func private @cannot_parse_type(!spv.array<4xblabla>) -> ()
// ----- // -----
// expected-error @+1 {{expected single integer for array element count}} // expected-error @+1 {{expected single integer for array element count}}
func private @more_than_one_dim(!spv.array<4x3xf32>) -> () func private @more_than_one_dim(!spv.array<4x3xf32>) -> ()
// ----- // -----
// expected-error @+1 {{only 1-D vector allowed but found 'vector<4x3xf32>'}} // expected-error @+1 {{only 1-D vector allowed but found 'vector<4x3xf32>'}}
func private @non_1D_vector(!spv.array<4xvector<4x3xf32>>) -> () func private @non_1D_vector(!spv.array<4xvector<4x3xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{cannot use 'tensor<4xf32>' to compose SPIR-V types}} // expected-error @+1 {{cannot use 'tensor<4xf32>' to compose SPIR-V types}}
func private @tensor_type(!spv.array<4xtensor<4xf32>>) -> () func private @tensor_type(!spv.array<4xtensor<4xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{cannot use 'bf16' to compose SPIR-V types}} // expected-error @+1 {{cannot use 'bf16' to compose SPIR-V types}}
func private @bf16_type(!spv.array<4xbf16>) -> () func private @bf16_type(!spv.array<4xbf16>) -> ()
// ----- // -----
// expected-error @+1 {{only 1/8/16/32/64-bit integer type allowed but found 'i256'}} // expected-error @+1 {{only 1/8/16/32/64-bit integer type allowed but found 'i256'}}
func private @i256_type(!spv.array<4xi256>) -> () func private @i256_type(!spv.array<4xi256>) -> ()
// ----- // -----
// expected-error @+1 {{cannot use 'index' to compose SPIR-V types}} // expected-error @+1 {{cannot use 'index' to compose SPIR-V types}}
func private @index_type(!spv.array<4xindex>) -> () func private @index_type(!spv.array<4xindex>) -> ()
// ----- // -----
// expected-error @+1 {{cannot use '!llvm.i32' to compose SPIR-V types}} // expected-error @+1 {{cannot use '!llvm.i32' to compose SPIR-V types}}
func private @llvm_type(!spv.array<4x!llvm.i32>) -> () func private @llvm_type(!spv.array<4x!llvm.i32>) -> ()
// ----- // -----
// expected-error @+1 {{ArrayStride must be greater than zero}} // expected-error @+1 {{ArrayStride must be greater than zero}}
func private @array_type_zero_stride(!spv.array<4xi32, stride=0>) -> () func private @array_type_zero_stride(!spv.array<4xi32, stride=0>) -> ()
// ----- // -----
// expected-error @+1 {{expected array length greater than 0}} // expected-error @+1 {{expected array length greater than 0}}
func private @array_type_zero_length(!spv.array<0xf32>) -> () func private @array_type_zero_length(!spv.array<0xf32>) -> ()
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// PointerType // PointerType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: @bool_ptr_type(!spv.ptr<i1, Uniform>) // CHECK: @bool_ptr_type(!spv.ptr<i1, Uniform>)
func private @bool_ptr_type(!spv.ptr<i1, Uniform>) -> () func private @bool_ptr_type(!spv.ptr<i1, Uniform>) -> ()
// CHECK: @scalar_ptr_type(!spv.ptr<f32, Uniform>) // CHECK: @scalar_ptr_type(!spv.ptr<f32, Uniform>)
func private @scalar_ptr_type(!spv.ptr<f32, Uniform>) -> () func private @scalar_ptr_type(!spv.ptr<f32, Uniform>) -> ()
// CHECK: @vector_ptr_type(!spv.ptr<vector<4xi32>, PushConstant>) // CHECK: @vector_ptr_type(!spv.ptr<vector<4xi32>, PushConstant>)
func private @vector_ptr_type(!spv.ptr<vector<4xi32>,PushConstant>) -> () func private @vector_ptr_type(!spv.ptr<vector<4xi32>,PushConstant>) -> ()
// ----- // -----
// expected-error @+1 {{expected '<'}} // expected-error @+1 {{expected '<'}}
func private @missing_left_angle_bracket(!spv.ptr f32, Uniform>) -> () func private @missing_left_angle_bracket(!spv.ptr f32, Uniform>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @missing_comma(!spv.ptr<f32 Uniform>) -> () func private @missing_comma(!spv.ptr<f32 Uniform>) -> ()
// ----- // -----
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
func private @missing_pointee_type(!spv.ptr<, Uniform>) -> () func private @missing_pointee_type(!spv.ptr<, Uniform>) -> ()
// ----- // -----
// expected-error @+1 {{unknown storage class: SomeStorageClass}} // expected-error @+1 {{unknown storage class: SomeStorageClass}}
func private @unknown_storage_class(!spv.ptr<f32, SomeStorageClass>) -> () func private @unknown_storage_class(!spv.ptr<f32, SomeStorageClass>) -> ()
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// RuntimeArrayType // RuntimeArrayType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @scalar_runtime_array_type(!spv.rtarray<f32>, !spv.rtarray<i32>) // CHECK: func private @scalar_runtime_array_type(!spv.rtarray<f32>, !spv.rtarray<i32>)
func private @scalar_runtime_array_type(!spv.rtarray<f32>, !spv.rtarray<i32>) -> () func private @scalar_runtime_array_type(!spv.rtarray<f32>, !spv.rtarray<i32>) -> ()
// CHECK: func private @vector_runtime_array_type(!spv.rtarray<vector<4xf32>>) // CHECK: func private @vector_runtime_array_type(!spv.rtarray<vector<4xf32>>)
func private @vector_runtime_array_type(!spv.rtarray< vector<4xf32> >) -> () func private @vector_runtime_array_type(!spv.rtarray< vector<4xf32> >) -> ()
// CHECK: func private @runtime_array_type_stride(!spv.rtarray<f32, stride=4>) // CHECK: func private @runtime_array_type_stride(!spv.rtarray<f32, stride=4>)
func private @runtime_array_type_stride(!spv.rtarray<f32, stride=4>) -> () func private @runtime_array_type_stride(!spv.rtarray<f32, stride=4>) -> ()
// ----- // -----
// expected-error @+1 {{expected '<'}} // expected-error @+1 {{expected '<'}}
func private @missing_left_angle_bracket(!spv.rtarray f32>) -> () func private @missing_left_angle_bracket(!spv.rtarray f32>) -> ()
// ----- // -----
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
func private @missing_element_type(!spv.rtarray<>) -> () func private @missing_element_type(!spv.rtarray<>) -> ()
// ----- // -----
// expected-error @+1 {{expected non-function type}} // expected-error @+1 {{expected non-function type}}
func private @redundant_count(!spv.rtarray<4xf32>) -> () func private @redundant_count(!spv.rtarray<4xf32>) -> ()
// ----- // -----
// expected-error @+1 {{ArrayStride must be greater than zero}} // expected-error @+1 {{ArrayStride must be greater than zero}}
func private @runtime_array_type_zero_stride(!spv.rtarray<i32, stride=0>) -> () func private @runtime_array_type_zero_stride(!spv.rtarray<i32, stride=0>) -> ()
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ImageType // ImageType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @image_parameters_1D(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) // CHECK: func private @image_parameters_1D(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>)
func private @image_parameters_1D(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> () func private @image_parameters_1D(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_one_element(!spv.image<f32>) -> () func private @image_parameters_one_element(!spv.image<f32>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_two_elements(!spv.image<f32, Dim1D>) -> () func private @image_parameters_two_elements(!spv.image<f32, Dim1D>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_three_elements(!spv.image<f32, Dim1D, NoDepth>) -> () func private @image_parameters_three_elements(!spv.image<f32, Dim1D, NoDepth>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_four_elements(!spv.image<f32, Dim1D, NoDepth, NonArrayed>) -> () func private @image_parameters_four_elements(!spv.image<f32, Dim1D, NoDepth, NonArrayed>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_five_elements(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled>) -> () func private @image_parameters_five_elements(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_six_elements(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown>) -> () func private @image_parameters_six_elements(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected '<'}} // expected-error @+1 {{expected '<'}}
func private @image_parameters_delimiter(!spv.image f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> () func private @image_parameters_delimiter(!spv.image f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_nocomma_1(!spv.image<f32, Dim1D NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> () func private @image_parameters_nocomma_1(!spv.image<f32, Dim1D NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_nocomma_2(!spv.image<f32, Dim1D, NoDepth NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> () func private @image_parameters_nocomma_2(!spv.image<f32, Dim1D, NoDepth NonArrayed, SingleSampled, SamplerUnknown, Unknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_nocomma_3(!spv.image<f32, Dim1D, NoDepth, NonArrayed SingleSampled, SamplerUnknown, Unknown>) -> () func private @image_parameters_nocomma_3(!spv.image<f32, Dim1D, NoDepth, NonArrayed SingleSampled, SamplerUnknown, Unknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_nocomma_4(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled SamplerUnknown, Unknown>) -> () func private @image_parameters_nocomma_4(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled SamplerUnknown, Unknown>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @image_parameters_nocomma_5(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown Unknown>) -> () func private @image_parameters_nocomma_5(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown Unknown>) -> ()
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StructType // StructType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @struct_type(!spv.struct<(f32)>) // CHECK: func private @struct_type(!spv.struct<(f32)>)
func private @struct_type(!spv.struct<(f32)>) -> () func private @struct_type(!spv.struct<(f32)>) -> ()
// CHECK: func private @struct_type2(!spv.struct<(f32 [0])>) // CHECK: func private @struct_type2(!spv.struct<(f32 [0])>)
func private @struct_type2(!spv.struct<(f32 [0])>) -> () func private @struct_type2(!spv.struct<(f32 [0])>) -> ()
// CHECK: func private @struct_type_simple(!spv.struct<(f32, !spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>)>) // CHECK: func private @struct_type_simple(!spv.struct<(f32, !spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>)>)
func private @struct_type_simple(!spv.struct<(f32, !spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>)>) -> () func private @struct_type_simple(!spv.struct<(f32, !spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown, Unknown>)>) -> ()
// CHECK: func private @struct_type_with_offset(!spv.struct<(f32 [0], i32 [4])>) // CHECK: func private @struct_type_with_offset(!spv.struct<(f32 [0], i32 [4])>)
func private @struct_type_with_offset(!spv.struct<(f32 [0], i32 [4])>) -> () func private @struct_type_with_offset(!spv.struct<(f32 [0], i32 [4])>) -> ()
// CHECK: func private @nested_struct(!spv.struct<(f32, !spv.struct<(f32, i32)>)>) // CHECK: func private @nested_struct(!spv.struct<(f32, !spv.struct<(f32, i32)>)>)
func private @nested_struct(!spv.struct<(f32, !spv.struct<(f32, i32)>)>) func private @nested_struct(!spv.struct<(f32, !spv.struct<(f32, i32)>)>)
// CHECK: func private @nested_struct_with_offset(!spv.struct<(f32 [0], !spv.struct<(f32 [0], i32 [4])> [4])>) // CHECK: func private @nested_struct_with_offset(!spv.struct<(f32 [0], !spv.struct<(f32 [0], i32 [4])> [4])>)
func private @nested_struct_with_offset(!spv.struct<(f32 [0], !spv.struct<(f32 [0], i32 [4])> [4])>) func private @nested_struct_with_offset(!spv.struct<(f32 [0], !spv.struct<(f32 [0], i32 [4])> [4])>)
// CHECK: func private @struct_type_with_decoration(!spv.struct<(f32 [NonWritable])>) // CHECK: func private @struct_type_with_decoration(!spv.struct<(f32 [NonWritable])>)
func private @struct_type_with_decoration(!spv.struct<(f32 [NonWritable])>) func private @struct_type_with_decoration(!spv.struct<(f32 [NonWritable])>)
// CHECK: func private @struct_type_with_decoration_and_offset(!spv.struct<(f32 [0, NonWritable])>) // CHECK: func private @struct_type_with_decoration_and_offset(!spv.struct<(f32 [0, NonWritable])>)
func private @struct_type_with_decoration_and_offset(!spv.struct<(f32 [0, NonWritable])>) func private @struct_type_with_decoration_and_offset(!spv.struct<(f32 [0, NonWritable])>)
// CHECK: func private @struct_type_with_decoration2(!spv.struct<(f32 [NonWritable], i32 [NonReadable])>) // CHECK: func private @struct_type_with_decoration2(!spv.struct<(f32 [NonWritable], i32 [NonReadable])>)
func private @struct_type_with_decoration2(!spv.struct<(f32 [NonWritable], i32 [NonReadable])>) func private @struct_type_with_decoration2(!spv.struct<(f32 [NonWritable], i32 [NonReadable])>)
// CHECK: func private @struct_type_with_decoration3(!spv.struct<(f32, i32 [NonReadable])>) // CHECK: func private @struct_type_with_decoration3(!spv.struct<(f32, i32 [NonReadable])>)
func private @struct_type_with_decoration3(!spv.struct<(f32, i32 [NonReadable])>) func private @struct_type_with_decoration3(!spv.struct<(f32, i32 [NonReadable])>)
// CHECK: func private @struct_type_with_decoration4(!spv.struct<(f32 [0], i32 [4, NonReadable])>) // CHECK: func private @struct_type_with_decoration4(!spv.struct<(f32 [0], i32 [4, NonReadable])>)
func private @struct_type_with_decoration4(!spv.struct<(f32 [0], i32 [4, NonReadable])>) func private @struct_type_with_decoration4(!spv.struct<(f32 [0], i32 [4, NonReadable])>)
// CHECK: func private @struct_type_with_decoration5(!spv.struct<(f32 [NonWritable, NonReadable])>) // CHECK: func private @struct_type_with_decoration5(!spv.struct<(f32 [NonWritable, NonReadable])>)
func private @struct_type_with_decoration5(!spv.struct<(f32 [NonWritable, NonReadable])>) func private @struct_type_with_decoration5(!spv.struct<(f32 [NonWritable, NonReadable])>)
// CHECK: func private @struct_type_with_decoration6(!spv.struct<(f32, !spv.struct<(i32 [NonWritable, NonReadable])>)>) // CHECK: func private @struct_type_with_decoration6(!spv.struct<(f32, !spv.struct<(i32 [NonWritable, NonReadable])>)>)
func private @struct_type_with_decoration6(!spv.struct<(f32, !spv.struct<(i32 [NonWritable, NonReadable])>)>) func private @struct_type_with_decoration6(!spv.struct<(f32, !spv.struct<(i32 [NonWritable, NonReadable])>)>)
// CHECK: func private @struct_type_with_decoration7(!spv.struct<(f32 [0], !spv.struct<(i32, f32 [NonReadable])> [4])>) // CHECK: func private @struct_type_with_decoration7(!spv.struct<(f32 [0], !spv.struct<(i32, f32 [NonReadable])> [4])>)
func private @struct_type_with_decoration7(!spv.struct<(f32 [0], !spv.struct<(i32, f32 [NonReadable])> [4])>) func private @struct_type_with_decoration7(!spv.struct<(f32 [0], !spv.struct<(i32, f32 [NonReadable])> [4])>)
// CHECK: func private @struct_type_with_decoration8(!spv.struct<(f32, !spv.struct<(i32 [0], f32 [4, NonReadable])>)>) // CHECK: func private @struct_type_with_decoration8(!spv.struct<(f32, !spv.struct<(i32 [0], f32 [4, NonReadable])>)>)
func private @struct_type_with_decoration8(!spv.struct<(f32, !spv.struct<(i32 [0], f32 [4, NonReadable])>)>) func private @struct_type_with_decoration8(!spv.struct<(f32, !spv.struct<(i32 [0], f32 [4, NonReadable])>)>)
// CHECK: func private @struct_type_with_matrix_1(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>) // CHECK: func private @struct_type_with_matrix_1(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>)
func private @struct_type_with_matrix_1(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>) func private @struct_type_with_matrix_1(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>)
// CHECK: func private @struct_type_with_matrix_2(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=16])>) // CHECK: func private @struct_type_with_matrix_2(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=16])>)
func private @struct_type_with_matrix_2(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=16])>) func private @struct_type_with_matrix_2(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=16])>)
// CHECK: func private @struct_empty(!spv.struct<()>) // CHECK: func private @struct_empty(!spv.struct<()>)
func private @struct_empty(!spv.struct<()>) func private @struct_empty(!spv.struct<()>)
// ----- // -----
// expected-error @+1 {{offset specification must be given for all members}} // expected-error @+1 {{offset specification must be given for all members}}
func private @struct_type_missing_offset1((!spv.struct<(f32, i32 [4])>) -> () func private @struct_type_missing_offset1((!spv.struct<(f32, i32 [4])>) -> ()
// ----- // -----
// expected-error @+1 {{offset specification must be given for all members}} // expected-error @+1 {{offset specification must be given for all members}}
func private @struct_type_missing_offset2(!spv.struct<(f32 [3], i32)>) -> () func private @struct_type_missing_offset2(!spv.struct<(f32 [3], i32)>) -> ()
// ----- // -----
// expected-error @+1 {{expected ')'}} // expected-error @+1 {{expected ')'}}
func private @struct_type_missing_comma1(!spv.struct<(f32 i32)>) -> () func private @struct_type_missing_comma1(!spv.struct<(f32 i32)>) -> ()
// ----- // -----
// expected-error @+1 {{expected ')'}} // expected-error @+1 {{expected ')'}}
func private @struct_type_missing_comma2(!spv.struct<(f32 [0] i32)>) -> () func private @struct_type_missing_comma2(!spv.struct<(f32 [0] i32)>) -> ()
// ----- // -----
// expected-error @+1 {{unbalanced ')' character in pretty dialect name}} // expected-error @+1 {{unbalanced ')' character in pretty dialect name}}
func private @struct_type_neg_offset(!spv.struct<(f32 [0)>) -> () func private @struct_type_neg_offset(!spv.struct<(f32 [0)>) -> ()
// ----- // -----
// expected-error @+1 {{unbalanced ']' character in pretty dialect name}} // expected-error @+1 {{unbalanced ']' character in pretty dialect name}}
func private @struct_type_neg_offset(!spv.struct<(f32 0])>) -> () func private @struct_type_neg_offset(!spv.struct<(f32 0])>) -> ()
// ----- // -----
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
func private @struct_type_neg_offset(!spv.struct<(f32 [NonWritable 0])>) -> () func private @struct_type_neg_offset(!spv.struct<(f32 [NonWritable 0])>) -> ()
// ----- // -----
// expected-error @+1 {{expected valid keyword}} // expected-error @+1 {{expected valid keyword}}
func private @struct_type_neg_offset(!spv.struct<(f32 [NonWritable, 0])>) -> () func private @struct_type_neg_offset(!spv.struct<(f32 [NonWritable, 0])>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @struct_type_missing_comma(!spv.struct<(f32 [0 NonWritable], i32 [4])>) func private @struct_type_missing_comma(!spv.struct<(f32 [0 NonWritable], i32 [4])>)
// ----- // -----
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
func private @struct_type_missing_comma(!spv.struct<(f32 [0, NonWritable NonReadable], i32 [4])>) func private @struct_type_missing_comma(!spv.struct<(f32 [0, NonWritable NonReadable], i32 [4])>)
// ----- // -----
// expected-error @+1 {{expected ']'}} // expected-error @+1 {{expected ']'}}
func private @struct_type_missing_comma(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor MatrixStride=16])>) func private @struct_type_missing_comma(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor MatrixStride=16])>)
// ----- // -----
// expected-error @+1 {{expected integer value}} // expected-error @+1 {{expected integer value}}
func private @struct_missing_member_decorator_value(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=])>) func private @struct_missing_member_decorator_value(!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=])>)
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StructType (identified) // StructType (identified)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @id_struct_empty(!spv.struct<empty, ()>) // CHECK: func private @id_struct_empty(!spv.struct<empty, ()>)
func private @id_struct_empty(!spv.struct<empty, ()>) -> () func private @id_struct_empty(!spv.struct<empty, ()>) -> ()
// ----- // -----
// CHECK: func private @id_struct_simple(!spv.struct<simple, (f32)>) // CHECK: func private @id_struct_simple(!spv.struct<simple, (f32)>)
func private @id_struct_simple(!spv.struct<simple, (f32)>) -> () func private @id_struct_simple(!spv.struct<simple, (f32)>) -> ()
// ----- // -----
// CHECK: func private @id_struct_multiple_elements(!spv.struct<multi_elements, (f32, i32)>) // CHECK: func private @id_struct_multiple_elements(!spv.struct<multi_elements, (f32, i32)>)
func private @id_struct_multiple_elements(!spv.struct<multi_elements, (f32, i32)>) -> () func private @id_struct_multiple_elements(!spv.struct<multi_elements, (f32, i32)>) -> ()
// ----- // -----
// CHECK: func private @id_struct_nested_literal(!spv.struct<a1, (!spv.struct<()>)>) // CHECK: func private @id_struct_nested_literal(!spv.struct<a1, (!spv.struct<()>)>)
func private @id_struct_nested_literal(!spv.struct<a1, (!spv.struct<()>)>) -> () func private @id_struct_nested_literal(!spv.struct<a1, (!spv.struct<()>)>) -> ()
// ----- // -----
// CHECK: func private @id_struct_nested_id(!spv.struct<a2, (!spv.struct<b2, ()>)>) // CHECK: func private @id_struct_nested_id(!spv.struct<a2, (!spv.struct<b2, ()>)>)
func private @id_struct_nested_id(!spv.struct<a2, (!spv.struct<b2, ()>)>) -> () func private @id_struct_nested_id(!spv.struct<a2, (!spv.struct<b2, ()>)>) -> ()
// ----- // -----
// CHECK: func private @literal_struct_nested_id(!spv.struct<(!spv.struct<a3, ()>)>) // CHECK: func private @literal_struct_nested_id(!spv.struct<(!spv.struct<a3, ()>)>)
func private @literal_struct_nested_id(!spv.struct<(!spv.struct<a3, ()>)>) -> () func private @literal_struct_nested_id(!spv.struct<(!spv.struct<a3, ()>)>) -> ()
// ----- // -----
// CHECK: func private @id_struct_self_recursive(!spv.struct<a4, (!spv.ptr<!spv.struct<a4>, Uniform>)>) // CHECK: func private @id_struct_self_recursive(!spv.struct<a4, (!spv.ptr<!spv.struct<a4>, Uniform>)>)
func private @id_struct_self_recursive(!spv.struct<a4, (!spv.ptr<!spv.struct<a4>, Uniform>)>) -> () func private @id_struct_self_recursive(!spv.struct<a4, (!spv.ptr<!spv.struct<a4>, Uniform>)>) -> ()
// ----- // -----
// CHECK: func private @id_struct_self_recursive2(!spv.struct<a5, (i32, !spv.ptr<!spv.struct<a5>, Uniform>)>) // CHECK: func private @id_struct_self_recursive2(!spv.struct<a5, (i32, !spv.ptr<!spv.struct<a5>, Uniform>)>)
func private @id_struct_self_recursive2(!spv.struct<a5, (i32, !spv.ptr<!spv.struct<a5>, Uniform>)>) -> () func private @id_struct_self_recursive2(!spv.struct<a5, (i32, !spv.ptr<!spv.struct<a5>, Uniform>)>) -> ()
// ----- // -----
// expected-error @+1 {{recursive struct reference not nested in struct definition}} // expected-error @+1 {{recursive struct reference not nested in struct definition}}
func private @id_wrong_recursive_reference(!spv.struct<a6>) -> () func private @id_wrong_recursive_reference(!spv.struct<a6>) -> ()
// ----- // -----
// expected-error @+1 {{recursive struct reference not nested in struct definition}} // expected-error @+1 {{recursive struct reference not nested in struct definition}}
func private @id_struct_recursive_invalid(!spv.struct<a7, (!spv.ptr<!spv.struct<b7>, Uniform>)>) -> () func private @id_struct_recursive_invalid(!spv.struct<a7, (!spv.ptr<!spv.struct<b7>, Uniform>)>) -> ()
// ----- // -----
// expected-error @+1 {{identifier already used for an enclosing struct}} // expected-error @+1 {{identifier already used for an enclosing struct}}
func private @id_struct_redefinition(!spv.struct<a8, (!spv.ptr<!spv.struct<a8, (!spv.ptr<!spv.struct<a8>, Uniform>)>, Uniform>)>) -> () func private @id_struct_redefinition(!spv.struct<a8, (!spv.ptr<!spv.struct<a8, (!spv.ptr<!spv.struct<a8>, Uniform>)>, Uniform>)>) -> ()
// ----- // -----
// Equivalent to: // Equivalent to:
// struct a { struct b *bPtr; }; // struct a { struct b *bPtr; };
// struct b { struct a *aPtr; }; // struct b { struct a *aPtr; };
// CHECK: func private @id_struct_recursive(!spv.struct<a9, (!spv.ptr<!spv.struct<b9, (!spv.ptr<!spv.struct<a9>, Uniform>)>, Uniform>)>) // CHECK: func private @id_struct_recursive(!spv.struct<a9, (!spv.ptr<!spv.struct<b9, (!spv.ptr<!spv.struct<a9>, Uniform>)>, Uniform>)>)
func private @id_struct_recursive(!spv.struct<a9, (!spv.ptr<!spv.struct<b9, (!spv.ptr<!spv.struct<a9>, Uniform>)>, Uniform>)>) -> () func private @id_struct_recursive(!spv.struct<a9, (!spv.ptr<!spv.struct<b9, (!spv.ptr<!spv.struct<a9>, Uniform>)>, Uniform>)>) -> ()
// ----- // -----
// Equivalent to: // Equivalent to:
// struct a { struct b *bPtr; }; // struct a { struct b *bPtr; };
// struct b { struct a *aPtr, struct b *bPtr; }; // struct b { struct a *aPtr, struct b *bPtr; };
// CHECK: func private @id_struct_recursive(!spv.struct<a10, (!spv.ptr<!spv.struct<b10, (!spv.ptr<!spv.struct<a10>, Uniform>, !spv.ptr<!spv.struct<b10>, Uniform>)>, Uniform>)>) // CHECK: func private @id_struct_recursive(!spv.struct<a10, (!spv.ptr<!spv.struct<b10, (!spv.ptr<!spv.struct<a10>, Uniform>, !spv.ptr<!spv.struct<b10>, Uniform>)>, Uniform>)>)
func private @id_struct_recursive(!spv.struct<a10, (!spv.ptr<!spv.struct<b10, (!spv.ptr<!spv.struct<a10>, Uniform>, !spv.ptr<!spv.struct<b10>, Uniform>)>, Uniform>)>) -> () func private @id_struct_recursive(!spv.struct<a10, (!spv.ptr<!spv.struct<b10, (!spv.ptr<!spv.struct<a10>, Uniform>, !spv.ptr<!spv.struct<b10>, Uniform>)>, Uniform>)>) -> ()
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CooperativeMatrix // CooperativeMatrix
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @coop_matrix_type(!spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xf32, Workgroup>) // CHECK: func private @coop_matrix_type(!spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xf32, Workgroup>)
func private @coop_matrix_type(!spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xf32, Workgroup>) -> () func private @coop_matrix_type(!spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xf32, Workgroup>) -> ()
// ----- // -----
// expected-error @+1 {{expected ','}} // expected-error @+1 {{expected ','}}
func private @missing_scope(!spv.coopmatrix<8x16xi32>) -> () func private @missing_scope(!spv.coopmatrix<8x16xi32>) -> ()
// ----- // -----
// expected-error @+1 {{expected rows and columns size}} // expected-error @+1 {{expected rows and columns size}}
func private @missing_count(!spv.coopmatrix<8xi32, Subgroup>) -> () func private @missing_count(!spv.coopmatrix<8xi32, Subgroup>) -> ()
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Matrix // Matrix
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// CHECK: func private @matrix_type(!spv.matrix<2 x vector<2xf16>>) // CHECK: func private @matrix_type(!spv.matrix<2 x vector<2xf16>>)
func private @matrix_type(!spv.matrix<2 x vector<2xf16>>) -> () func private @matrix_type(!spv.matrix<2 x vector<2xf16>>) -> ()
// ----- // -----
// CHECK: func private @matrix_type(!spv.matrix<3 x vector<3xf32>>) // CHECK: func private @matrix_type(!spv.matrix<3 x vector<3xf32>>)
func private @matrix_type(!spv.matrix<3 x vector<3xf32>>) -> () func private @matrix_type(!spv.matrix<3 x vector<3xf32>>) -> ()
// ----- // -----
// CHECK: func private @matrix_type(!spv.matrix<4 x vector<4xf16>>) // CHECK: func private @matrix_type(!spv.matrix<4 x vector<4xf16>>)
func private @matrix_type(!spv.matrix<4 x vector<4xf16>>) -> () func private @matrix_type(!spv.matrix<4 x vector<4xf16>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix is expected to have 2, 3, or 4 columns}} // expected-error @+1 {{matrix is expected to have 2, 3, or 4 columns}}
func private @matrix_invalid_size(!spv.matrix<5 x vector<3xf32>>) -> () func private @matrix_invalid_size(!spv.matrix<5 x vector<3xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix is expected to have 2, 3, or 4 columns}} // expected-error @+1 {{matrix is expected to have 2, 3, or 4 columns}}
func private @matrix_invalid_size(!spv.matrix<1 x vector<3xf32>>) -> () func private @matrix_invalid_size(!spv.matrix<1 x vector<3xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix columns size has to be less than or equal to 4 and greater than or equal 2, but found 5}} // expected-error @+1 {{matrix columns size has to be less than or equal to 4 and greater than or equal 2, but found 5}}
func private @matrix_invalid_columns_size(!spv.matrix<3 x vector<5xf32>>) -> () func private @matrix_invalid_columns_size(!spv.matrix<3 x vector<5xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix columns size has to be less than or equal to 4 and greater than or equal 2, but found 1}} // expected-error @+1 {{matrix columns size has to be less than or equal to 4 and greater than or equal 2, but found 1}}
func private @matrix_invalid_columns_size(!spv.matrix<3 x vector<1xf32>>) -> () func private @matrix_invalid_columns_size(!spv.matrix<3 x vector<1xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{expected '<'}} // expected-error @+1 {{expected '<'}}
func private @matrix_invalid_format(!spv.matrix 3 x vector<3xf32>>) -> () func private @matrix_invalid_format(!spv.matrix 3 x vector<3xf32>>) -> ()
// ----- // -----
// expected-error @+1 {{unbalanced ')' character in pretty dialect name}} // expected-error @+1 {{unbalanced ')' character in pretty dialect name}}
func private @matrix_invalid_format(!spv.matrix< 3 x vector<3xf32>) -> () func private @matrix_invalid_format(!spv.matrix< 3 x vector<3xf32>) -> ()
// ----- // -----
// expected-error @+1 {{expected 'x' in dimension list}} // expected-error @+1 {{expected 'x' in dimension list}}
func private @matrix_invalid_format(!spv.matrix<2 vector<3xi32>>) -> () func private @matrix_invalid_format(!spv.matrix<2 vector<3xi32>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix must be composed using vector type, got 'i32'}} // expected-error @+1 {{matrix must be composed using vector type, got 'i32'}}
func private @matrix_invalid_type(!spv.matrix< 3 x i32>) -> () func private @matrix_invalid_type(!spv.matrix< 3 x i32>) -> ()
// ----- // -----
// expected-error @+1 {{matrix must be composed using vector type, got '!spv.array<16 x f32>'}} // expected-error @+1 {{matrix must be composed using vector type, got '!spv.array<16 x f32>'}}
func private @matrix_invalid_type(!spv.matrix< 3 x !spv.array<16 x f32>>) -> () func private @matrix_invalid_type(!spv.matrix< 3 x !spv.array<16 x f32>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix must be composed using vector type, got '!spv.rtarray<i32>'}} // expected-error @+1 {{matrix must be composed using vector type, got '!spv.rtarray<i32>'}}
func private @matrix_invalid_type(!spv.matrix< 3 x !spv.rtarray<i32>>) -> () func private @matrix_invalid_type(!spv.matrix< 3 x !spv.rtarray<i32>>) -> ()
// ----- // -----
// expected-error @+1 {{matrix columns' elements must be of Float type, got 'i32'}} // expected-error @+1 {{matrix columns' elements must be of Float type, got 'i32'}}
func private @matrix_invalid_type(!spv.matrix<2 x vector<3xi32>>) -> () func private @matrix_invalid_type(!spv.matrix<2 x vector<3xi32>>) -> ()
// ----- // -----
// expected-error @+1 {{expected single unsigned integer for number of columns}} // expected-error @+1 {{expected single unsigned integer for number of columns}}
func private @matrix_size_type(!spv.matrix< x vector<3xi32>>) -> () func private @matrix_size_type(!spv.matrix< x vector<3xi32>>) -> ()
// ----- // -----
// expected-error @+1 {{expected single unsigned integer for number of columns}} // expected-error @+1 {{expected single unsigned integer for number of columns}}
func private @matrix_size_type(!spv.matrix<2.0 x vector<3xi32>>) -> () func private @matrix_size_type(!spv.matrix<2.0 x vector<3xi32>>) -> ()
// ----- // -----

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/conflict-resolution.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/conflict_resolution.mlir.
// RUN: mlir-opt -test-spirv-module-combiner -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -test-spirv-module-combiner -split-input-file -verify-diagnostics %s | FileCheck %s
// Test basic renaming of conflicting funcOps. // Test basic renaming of conflicting funcOps.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_1 // CHECK-NEXT: spv.func @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : f32) -> f32 "None" { spv.func @foo(%arg0 : f32) -> f32 "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
} }
} }
// ----- // -----
// Test basic renaming of conflicting funcOps across 3 modules. // Test basic renaming of conflicting funcOps across 3 modules.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_1 // CHECK-NEXT: spv.func @foo_1
// CHECK-NEXT: spv.FAdd // CHECK-NEXT: spv.FAdd
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_2 // CHECK-NEXT: spv.func @foo_2
// CHECK-NEXT: spv.ISub // CHECK-NEXT: spv.ISub
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : f32) -> f32 "None" { spv.func @foo(%arg0 : f32) -> f32 "None" {
%0 = spv.FAdd %arg0, %arg0 : f32 %0 = spv.FAdd %arg0, %arg0 : f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
%0 = spv.ISub %arg0, %arg0 : i32 %0 = spv.ISub %arg0, %arg0 : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
} }
} }
// ----- // -----
// Test properly updating references to a renamed funcOp. // Test properly updating references to a renamed funcOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_1 // CHECK-NEXT: spv.func @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.FunctionCall @foo_1 // CHECK-NEXT: spv.FunctionCall @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : f32) -> f32 "None" { spv.func @foo(%arg0 : f32) -> f32 "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
spv.func @bar(%arg0 : f32) -> f32 "None" { spv.func @bar(%arg0 : f32) -> f32 "None" {
%0 = spv.FunctionCall @foo(%arg0) : (f32) -> (f32) %0 = spv.FunctionCall @foo(%arg0) : (f32) -> (f32)
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
} }
} }
// ----- // -----
// Test properly updating references to a renamed funcOp if the functionCallOp // Test properly updating references to a renamed funcOp if the functionCallOp
// preceeds the callee funcOp definition. // preceeds the callee funcOp definition.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.FunctionCall @foo_1 // CHECK-NEXT: spv.FunctionCall @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_1 // CHECK-NEXT: spv.func @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @bar(%arg0 : f32) -> f32 "None" { spv.func @bar(%arg0 : f32) -> f32 "None" {
%0 = spv.FunctionCall @foo(%arg0) : (f32) -> (f32) %0 = spv.FunctionCall @foo(%arg0) : (f32) -> (f32)
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
spv.func @foo(%arg0 : f32) -> f32 "None" { spv.func @foo(%arg0 : f32) -> f32 "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
} }
} }
// ----- // -----
// Test properly updating entryPointOp and executionModeOp attached to renamed // Test properly updating entryPointOp and executionModeOp attached to renamed
// funcOp. // funcOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_1 // CHECK-NEXT: spv.func @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.EntryPoint "GLCompute" @foo_1 // CHECK-NEXT: spv.EntryPoint "GLCompute" @foo_1
// CHECK-NEXT: spv.ExecutionMode @foo_1 "ContractionOff" // CHECK-NEXT: spv.ExecutionMode @foo_1 "ContractionOff"
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : f32) -> f32 "None" { spv.func @foo(%arg0 : f32) -> f32 "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
spv.EntryPoint "GLCompute" @foo spv.EntryPoint "GLCompute" @foo
spv.ExecutionMode @foo "ContractionOff" spv.ExecutionMode @foo "ContractionOff"
} }
} }
// ----- // -----
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.EntryPoint "GLCompute" @fo // CHECK-NEXT: spv.EntryPoint "GLCompute" @fo
// CHECK-NEXT: spv.ExecutionMode @foo "ContractionOff" // CHECK-NEXT: spv.ExecutionMode @foo "ContractionOff"
// CHECK-NEXT: spv.func @foo_1 // CHECK-NEXT: spv.func @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.EntryPoint "GLCompute" @foo_1 // CHECK-NEXT: spv.EntryPoint "GLCompute" @foo_1
// CHECK-NEXT: spv.ExecutionMode @foo_1 "ContractionOff" // CHECK-NEXT: spv.ExecutionMode @foo_1 "ContractionOff"
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
spv.EntryPoint "GLCompute" @foo spv.EntryPoint "GLCompute" @foo
spv.ExecutionMode @foo "ContractionOff" spv.ExecutionMode @foo "ContractionOff"
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : f32) -> f32 "None" { spv.func @foo(%arg0 : f32) -> f32 "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
spv.EntryPoint "GLCompute" @foo spv.EntryPoint "GLCompute" @foo
spv.ExecutionMode @foo "ContractionOff" spv.ExecutionMode @foo "ContractionOff"
} }
} }
// ----- // -----
// Resolve conflicting funcOp and globalVariableOp. // Resolve conflicting funcOp and globalVariableOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.globalVariable @foo_1 // CHECK-NEXT: spv.globalVariable @foo_1
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
} }
} }
// ----- // -----
// Resolve conflicting funcOp and globalVariableOp and update the global variable's // Resolve conflicting funcOp and globalVariableOp and update the global variable's
// references. // references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.globalVariable @foo_1 // CHECK-NEXT: spv.globalVariable @foo_1
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.mlir.addressof @foo_1 // CHECK-NEXT: spv.mlir.addressof @foo_1
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
spv.func @bar() -> f32 "None" { spv.func @bar() -> f32 "None" {
%0 = spv.mlir.addressof @foo : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @foo : !spv.ptr<f32, Input>
%1 = spv.Load "Input" %0 : f32 %1 = spv.Load "Input" %0 : f32
spv.ReturnValue %1 : f32 spv.ReturnValue %1 : f32
} }
} }
} }
// ----- // -----
// Resolve conflicting globalVariableOp and funcOp and update the global variable's // Resolve conflicting globalVariableOp and funcOp and update the global variable's
// references. // references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo_1 // CHECK-NEXT: spv.globalVariable @foo_1
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.mlir.addressof @foo_1 // CHECK-NEXT: spv.mlir.addressof @foo_1
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
spv.func @bar() -> f32 "None" { spv.func @bar() -> f32 "None" {
%0 = spv.mlir.addressof @foo : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @foo : !spv.ptr<f32, Input>
%1 = spv.Load "Input" %0 : f32 %1 = spv.Load "Input" %0 : f32
spv.ReturnValue %1 : f32 spv.ReturnValue %1 : f32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
} }
// ----- // -----
// Resolve conflicting funcOp and specConstantOp. // Resolve conflicting funcOp and specConstantOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.specConstant @foo_1 // CHECK-NEXT: spv.specConstant @foo_1
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @foo = -5 : i32 spv.specConstant @foo = -5 : i32
} }
} }
// ----- // -----
// Resolve conflicting funcOp and specConstantOp and update the spec constant's // Resolve conflicting funcOp and specConstantOp and update the spec constant's
// references. // references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.specConstant @foo_1 // CHECK-NEXT: spv.specConstant @foo_1
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.mlir.referenceof @foo_1 // CHECK-NEXT: spv.mlir.referenceof @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @foo = -5 : i32 spv.specConstant @foo = -5 : i32
spv.func @bar() -> i32 "None" { spv.func @bar() -> i32 "None" {
%0 = spv.mlir.referenceof @foo : i32 %0 = spv.mlir.referenceof @foo : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
} }
} }
// ----- // -----
// Resolve conflicting specConstantOp and funcOp and update the spec constant's // Resolve conflicting specConstantOp and funcOp and update the spec constant's
// references. // references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @foo_1 // CHECK-NEXT: spv.specConstant @foo_1
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.mlir.referenceof @foo_1 // CHECK-NEXT: spv.mlir.referenceof @foo_1
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @foo = -5 : i32 spv.specConstant @foo = -5 : i32
spv.func @bar() -> i32 "None" { spv.func @bar() -> i32 "None" {
%0 = spv.mlir.referenceof @foo : i32 %0 = spv.mlir.referenceof @foo : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
} }
// ----- // -----
// Resolve conflicting funcOp and specConstantCompositeOp. // Resolve conflicting funcOp and specConstantCompositeOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.specConstant @bar // CHECK-NEXT: spv.specConstant @bar
// CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar) // CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar)
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar = -5 : i32 spv.specConstant @bar = -5 : i32
spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32> spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
} }
} }
// ----- // -----
// Resolve conflicting funcOp and specConstantCompositeOp and update the spec // Resolve conflicting funcOp and specConstantCompositeOp and update the spec
// constant's references. // constant's references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.specConstant @bar // CHECK-NEXT: spv.specConstant @bar
// CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar) // CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar)
// CHECK-NEXT: spv.func @baz // CHECK-NEXT: spv.func @baz
// CHECK-NEXT: spv.mlir.referenceof @foo_1 // CHECK-NEXT: spv.mlir.referenceof @foo_1
// CHECK-NEXT: spv.CompositeExtract // CHECK-NEXT: spv.CompositeExtract
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar = -5 : i32 spv.specConstant @bar = -5 : i32
spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32> spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
spv.func @baz() -> i32 "None" { spv.func @baz() -> i32 "None" {
%0 = spv.mlir.referenceof @foo : !spv.array<2 x i32> %0 = spv.mlir.referenceof @foo : !spv.array<2 x i32>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32> %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
} }
} }
// ----- // -----
// Resolve conflicting specConstantCompositeOp and funcOp and update the spec // Resolve conflicting specConstantCompositeOp and funcOp and update the spec
// constant's references. // constant's references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @bar // CHECK-NEXT: spv.specConstant @bar
// CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar) // CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar)
// CHECK-NEXT: spv.func @baz // CHECK-NEXT: spv.func @baz
// CHECK-NEXT: spv.mlir.referenceof @foo_1 // CHECK-NEXT: spv.mlir.referenceof @foo_1
// CHECK-NEXT: spv.CompositeExtract // CHECK-NEXT: spv.CompositeExtract
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar = -5 : i32 spv.specConstant @bar = -5 : i32
spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32> spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
spv.func @baz() -> i32 "None" { spv.func @baz() -> i32 "None" {
%0 = spv.mlir.referenceof @foo : !spv.array<2 x i32> %0 = spv.mlir.referenceof @foo : !spv.array<2 x i32>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32> %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
} }
} }
// ----- // -----
// Resolve conflicting spec constants and funcOps and update the spec constant's // Resolve conflicting spec constants and funcOps and update the spec constant's
// references. // references.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @bar_1 // CHECK-NEXT: spv.specConstant @bar_1
// CHECK-NEXT: spv.specConstantComposite @foo_2 (@bar_1, @bar_1) // CHECK-NEXT: spv.specConstantComposite @foo_2 (@bar_1, @bar_1)
// CHECK-NEXT: spv.func @baz // CHECK-NEXT: spv.func @baz
// CHECK-NEXT: spv.mlir.referenceof @foo_2 // CHECK-NEXT: spv.mlir.referenceof @foo_2
// CHECK-NEXT: spv.CompositeExtract // CHECK-NEXT: spv.CompositeExtract
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo // CHECK-NEXT: spv.func @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @bar // CHECK-NEXT: spv.func @bar
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar = -5 : i32 spv.specConstant @bar = -5 : i32
spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32> spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
spv.func @baz() -> i32 "None" { spv.func @baz() -> i32 "None" {
%0 = spv.mlir.referenceof @foo : !spv.array<2 x i32> %0 = spv.mlir.referenceof @foo : !spv.array<2 x i32>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32> %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.func @foo(%arg0 : i32) -> i32 "None" { spv.func @foo(%arg0 : i32) -> i32 "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
spv.func @bar(%arg0 : f32) -> f32 "None" { spv.func @bar(%arg0 : f32) -> f32 "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
} }
} }
// ----- // -----
// Resolve conflicting globalVariableOps. // Resolve conflicting globalVariableOps.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo_1 bind(1, 0) // CHECK-NEXT: spv.globalVariable @foo_1 bind(1, 0)
// CHECK-NEXT: spv.globalVariable @foo bind(2, 0) // CHECK-NEXT: spv.globalVariable @foo bind(2, 0)
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(2, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(2, 0) : !spv.ptr<f32, Input>
} }
} }
// ----- // -----
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo_1 built_in("GlobalInvocationId") // CHECK-NEXT: spv.globalVariable @foo_1 built_in("GlobalInvocationId")
// CHECK-NEXT: spv.globalVariable @foo built_in("LocalInvocationId") // CHECK-NEXT: spv.globalVariable @foo built_in("LocalInvocationId")
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @foo built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo built_in("LocalInvocationId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @foo built_in("LocalInvocationId") : !spv.ptr<vector<3xi32>, Input>
} }
} }
// ----- // -----
// Resolve conflicting globalVariableOp and specConstantOp. // Resolve conflicting globalVariableOp and specConstantOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo_1 // CHECK-NEXT: spv.globalVariable @foo_1
// CHECK-NEXT: spv.specConstant @foo // CHECK-NEXT: spv.specConstant @foo
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @foo = -5 : i32 spv.specConstant @foo = -5 : i32
} }
} }
// ----- // -----
// Resolve conflicting specConstantOp and globalVariableOp. // Resolve conflicting specConstantOp and globalVariableOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @foo_1 // CHECK-NEXT: spv.specConstant @foo_1
// CHECK-NEXT: spv.globalVariable @foo // CHECK-NEXT: spv.globalVariable @foo
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @foo = -5 : i32 spv.specConstant @foo = -5 : i32
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
} }
} }
// ----- // -----
// Resolve conflicting globalVariableOp and specConstantCompositeOp. // Resolve conflicting globalVariableOp and specConstantCompositeOp.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo_1 // CHECK-NEXT: spv.globalVariable @foo_1
// CHECK-NEXT: spv.specConstant @bar // CHECK-NEXT: spv.specConstant @bar
// CHECK-NEXT: spv.specConstantComposite @foo (@bar, @bar) // CHECK-NEXT: spv.specConstantComposite @foo (@bar, @bar)
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar = -5 : i32 spv.specConstant @bar = -5 : i32
spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32> spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
} }
} }
// ----- // -----
// Resolve conflicting globalVariableOp and specConstantComposite. // Resolve conflicting globalVariableOp and specConstantComposite.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @bar // CHECK-NEXT: spv.specConstant @bar
// CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar) // CHECK-NEXT: spv.specConstantComposite @foo_1 (@bar, @bar)
// CHECK-NEXT: spv.globalVariable @foo // CHECK-NEXT: spv.globalVariable @foo
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar = -5 : i32 spv.specConstant @bar = -5 : i32
spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32> spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
} }
} }

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/conflict_resolution.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/conflict-resolution.mlir.

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication_basic.mlir.
// RUN: mlir-opt -test-spirv-module-combiner -split-input-file -verify-diagnostics %s | FileCheck %s // RUN: mlir-opt -test-spirv-module-combiner -split-input-file -verify-diagnostics %s | FileCheck %s
// Deduplicate 2 global variables with the same descriptor set and binding. // Deduplicate 2 global variables with the same descriptor set and binding.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo // CHECK-NEXT: spv.globalVariable @foo
// CHECK-NEXT: spv.func @use_foo // CHECK-NEXT: spv.func @use_foo
// CHECK-NEXT: spv.mlir.addressof @foo // CHECK-NEXT: spv.mlir.addressof @foo
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @use_bar // CHECK-NEXT: spv.func @use_bar
// CHECK-NEXT: spv.mlir.addressof @foo // CHECK-NEXT: spv.mlir.addressof @foo
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
// CHECK-NEXT: spv.FAdd // CHECK-NEXT: spv.FAdd
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
spv.func @use_foo() -> f32 "None" { spv.func @use_foo() -> f32 "None" {
%0 = spv.mlir.addressof @foo : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @foo : !spv.ptr<f32, Input>
%1 = spv.Load "Input" %0 : f32 %1 = spv.Load "Input" %0 : f32
spv.ReturnValue %1 : f32 spv.ReturnValue %1 : f32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @bar bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @bar bind(1, 0) : !spv.ptr<f32, Input>
spv.func @use_bar() -> f32 "None" { spv.func @use_bar() -> f32 "None" {
%0 = spv.mlir.addressof @bar : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @bar : !spv.ptr<f32, Input>
%1 = spv.Load "Input" %0 : f32 %1 = spv.Load "Input" %0 : f32
%2 = spv.FAdd %1, %1 : f32 %2 = spv.FAdd %1, %1 : f32
spv.ReturnValue %2 : f32 spv.ReturnValue %2 : f32
} }
} }
} }
// ----- // -----
// Deduplicate 2 global variables with the same descriptor set and binding but different types. // Deduplicate 2 global variables with the same descriptor set and binding but different types.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo bind(1, 0) // CHECK-NEXT: spv.globalVariable @foo bind(1, 0)
// CHECK-NEXT: spv.globalVariable @bar bind(1, 0) // CHECK-NEXT: spv.globalVariable @bar bind(1, 0)
// CHECK-NEXT: spv.func @use_bar // CHECK-NEXT: spv.func @use_bar
// CHECK-NEXT: spv.mlir.addressof @bar // CHECK-NEXT: spv.mlir.addressof @bar
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo bind(1, 0) : !spv.ptr<i32, Input> spv.globalVariable @foo bind(1, 0) : !spv.ptr<i32, Input>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @bar bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @bar bind(1, 0) : !spv.ptr<f32, Input>
spv.func @use_bar() -> f32 "None" { spv.func @use_bar() -> f32 "None" {
%0 = spv.mlir.addressof @bar : !spv.ptr<f32, Input> %0 = spv.mlir.addressof @bar : !spv.ptr<f32, Input>
%1 = spv.Load "Input" %0 : f32 %1 = spv.Load "Input" %0 : f32
spv.ReturnValue %1 : f32 spv.ReturnValue %1 : f32
} }
} }
} }
// ----- // -----
// Deduplicate 2 global variables with the same built-in attribute. // Deduplicate 2 global variables with the same built-in attribute.
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.globalVariable @foo built_in("GlobalInvocationId") // CHECK-NEXT: spv.globalVariable @foo built_in("GlobalInvocationId")
// CHECK-NEXT: spv.func @use_bar // CHECK-NEXT: spv.func @use_bar
// CHECK-NEXT: spv.mlir.addressof @foo // CHECK-NEXT: spv.mlir.addressof @foo
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @foo built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @foo built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.globalVariable @bar built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @bar built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
spv.func @use_bar() -> vector<3xi32> "None" { spv.func @use_bar() -> vector<3xi32> "None" {
%0 = spv.mlir.addressof @bar : !spv.ptr<vector<3xi32>, Input> %0 = spv.mlir.addressof @bar : !spv.ptr<vector<3xi32>, Input>
%1 = spv.Load "Input" %0 : vector<3xi32> %1 = spv.Load "Input" %0 : vector<3xi32>
spv.ReturnValue %1 : vector<3xi32> spv.ReturnValue %1 : vector<3xi32>
} }
} }
} }
// ----- // -----
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @foo spec_id(5) // CHECK-NEXT: spv.specConstant @foo spec_id(5)
// CHECK-NEXT: spv.func @use_foo() // CHECK-NEXT: spv.func @use_foo()
// CHECK-NEXT: %0 = spv.mlir.referenceof @foo // CHECK-NEXT: %0 = spv.mlir.referenceof @foo
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @use_bar() // CHECK-NEXT: spv.func @use_bar()
// CHECK-NEXT: %0 = spv.mlir.referenceof @foo // CHECK-NEXT: %0 = spv.mlir.referenceof @foo
// CHECK-NEXT: spv.FAdd // CHECK-NEXT: spv.FAdd
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @foo spec_id(5) = 1. : f32 spv.specConstant @foo spec_id(5) = 1. : f32
spv.func @use_foo() -> (f32) "None" { spv.func @use_foo() -> (f32) "None" {
%0 = spv.mlir.referenceof @foo : f32 %0 = spv.mlir.referenceof @foo : f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
} }
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar spec_id(5) = 1. : f32 spv.specConstant @bar spec_id(5) = 1. : f32
spv.func @use_bar() -> (f32) "None" { spv.func @use_bar() -> (f32) "None" {
%0 = spv.mlir.referenceof @bar : f32 %0 = spv.mlir.referenceof @bar : f32
%1 = spv.FAdd %0, %0 : f32 %1 = spv.FAdd %0, %0 : f32
spv.ReturnValue %1 : f32 spv.ReturnValue %1 : f32
} }
} }
} }
// ----- // -----
// CHECK: module { // CHECK: module {
// CHECK-NEXT: spv.module Logical GLSL450 { // CHECK-NEXT: spv.module Logical GLSL450 {
// CHECK-NEXT: spv.specConstant @bar spec_id(5) // CHECK-NEXT: spv.specConstant @bar spec_id(5)
// CHECK-NEXT: spv.func @foo(%arg0: f32) // CHECK-NEXT: spv.func @foo(%arg0: f32)
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @foo_different_body(%arg0: f32) // CHECK-NEXT: spv.func @foo_different_body(%arg0: f32)
// CHECK-NEXT: spv.mlir.referenceof // CHECK-NEXT: spv.mlir.referenceof
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @baz(%arg0: i32) // CHECK-NEXT: spv.func @baz(%arg0: i32)
// CHECK-NEXT: spv.ReturnValue // CHECK-NEXT: spv.ReturnValue
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @baz_no_return(%arg0: i32) // CHECK-NEXT: spv.func @baz_no_return(%arg0: i32)
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @baz_no_return_different_control // CHECK-NEXT: spv.func @baz_no_return_different_control
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @baz_no_return_another_control // CHECK-NEXT: spv.func @baz_no_return_another_control
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @kernel // CHECK-NEXT: spv.func @kernel
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: spv.func @kernel_different_attr // CHECK-NEXT: spv.func @kernel_different_attr
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
module { module {
spv.module Logical GLSL450 { spv.module Logical GLSL450 {
spv.specConstant @bar spec_id(5) = 1. : f32 spv.specConstant @bar spec_id(5) = 1. : f32
spv.func @foo(%arg0: f32) -> (f32) "None" { spv.func @foo(%arg0: f32) -> (f32) "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
spv.func @foo_duplicate(%arg0: f32) -> (f32) "None" { spv.func @foo_duplicate(%arg0: f32) -> (f32) "None" {
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
spv.func @foo_different_body(%arg0: f32) -> (f32) "None" { spv.func @foo_different_body(%arg0: f32) -> (f32) "None" {
%0 = spv.mlir.referenceof @bar : f32 %0 = spv.mlir.referenceof @bar : f32
spv.ReturnValue %arg0 : f32 spv.ReturnValue %arg0 : f32
} }
spv.func @baz(%arg0: i32) -> (i32) "None" { spv.func @baz(%arg0: i32) -> (i32) "None" {
spv.ReturnValue %arg0 : i32 spv.ReturnValue %arg0 : i32
} }
spv.func @baz_no_return(%arg0: i32) "None" { spv.func @baz_no_return(%arg0: i32) "None" {
spv.Return spv.Return
} }
spv.func @baz_no_return_duplicate(%arg0: i32) -> () "None" { spv.func @baz_no_return_duplicate(%arg0: i32) -> () "None" {
spv.Return spv.Return
} }
spv.func @baz_no_return_different_control(%arg0: i32) -> () "Inline" { spv.func @baz_no_return_different_control(%arg0: i32) -> () "Inline" {
spv.Return spv.Return
} }
spv.func @baz_no_return_another_control(%arg0: i32) -> () "Inline|Pure" { spv.func @baz_no_return_another_control(%arg0: i32) -> () "Inline|Pure" {
spv.Return spv.Return
} }
spv.func @kernel( spv.func @kernel(
%arg0: f32, %arg0: f32,
%arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, CrossWorkgroup>) "None" %arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, CrossWorkgroup>) "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>}} {
spv.Return spv.Return
} }
spv.func @kernel_different_attr( spv.func @kernel_different_attr(
%arg0: f32, %arg0: f32,
%arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, CrossWorkgroup>) "None" %arg1: !spv.ptr<!spv.struct<(!spv.array<12 x f32>)>, CrossWorkgroup>) "None"
attributes {spv.entry_point_abi = {local_size = dense<[64, 1, 1]> : vector<3xi32>}} { attributes {spv.entry_point_abi = {local_size = dense<[64, 1, 1]> : vector<3xi32>}} {
spv.Return spv.Return
} }
} }
} }

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication_basic.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication.mlir.

mlir/test/Dialect/SPIRV/Serialization/arithmetic-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/arithmetic-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/array.mlir

  • This file was moved to mlir/test/Target/SPIRV/array.mlir.

mlir/test/Dialect/SPIRV/Serialization/atomic-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/atomic-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/barrier.mlir

  • This file was moved to mlir/test/Target/SPIRV/barrier.mlir.

mlir/test/Dialect/SPIRV/Serialization/bit-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/bit-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/cast-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/cast-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/composite-op.mlir

  • This file was moved to mlir/test/Target/SPIRV/composite-op.mlir.

mlir/test/Dialect/SPIRV/Serialization/constant.mlir

  • This file was moved to mlir/test/Target/SPIRV/constant.mlir.

mlir/test/Dialect/SPIRV/Serialization/cooperative-matrix.mlir

  • This file was moved to mlir/test/Target/SPIRV/cooperative-matrix-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/debug.mlir

  • This file was moved to mlir/test/Target/SPIRV/debug.mlir.

mlir/test/Dialect/SPIRV/Serialization/decorations.mlir

  • This file was moved to mlir/test/Target/SPIRV/decorations.mlir.

mlir/test/Dialect/SPIRV/Serialization/entry-point.mlir

  • This file was moved to mlir/test/Target/SPIRV/entry-point.mlir.

mlir/test/Dialect/SPIRV/Serialization/execution-mode.mlir

  • This file was moved to mlir/test/Target/SPIRV/execution-mode.mlir.

mlir/test/Dialect/SPIRV/Serialization/function-call.mlir

  • This file was moved to mlir/test/Target/SPIRV/function-call.mlir.

mlir/test/Dialect/SPIRV/Serialization/global-variable.mlir

  • This file was moved to mlir/test/Target/SPIRV/global-variable.mlir.

mlir/test/Dialect/SPIRV/Serialization/glsl-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/glsl-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/group-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/group-ops.mlir.

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

  • This file was moved to mlir/test/Target/SPIRV/logical-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/loop.mlir

  • This file was moved to mlir/test/Target/SPIRV/loop.mlir.

mlir/test/Dialect/SPIRV/Serialization/matrix.mlir

  • This file was moved to mlir/test/Target/SPIRV/matrix.mlir.

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

  • This file was moved to mlir/test/Target/SPIRV/memory-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/module.mlir

  • This file was moved to mlir/test/Target/SPIRV/module.mlir.

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

  • This file was moved to mlir/test/Target/SPIRV/non-uniform-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/ocl-ops.mlir

  • This file was moved to mlir/test/Target/SPIRV/ocl-ops.mlir.

mlir/test/Dialect/SPIRV/Serialization/phi.mlir

  • This file was moved to mlir/test/Target/SPIRV/phi.mlir.

mlir/test/Dialect/SPIRV/Serialization/selection.mlir

  • This file was moved to mlir/test/Target/SPIRV/selection.mlir.

mlir/test/Dialect/SPIRV/Serialization/spec-constant.mlir

  • This file was moved to mlir/test/Target/SPIRV/spec-constant.mlir.

mlir/test/Dialect/SPIRV/Serialization/struct.mlir

  • This file was moved to mlir/test/Target/SPIRV/struct.mlir.

mlir/test/Dialect/SPIRV/Serialization/terminator.mlir

  • This file was moved to mlir/test/Target/SPIRV/terminator.mlir.

mlir/test/Dialect/SPIRV/Serialization/undef.mlir

  • This file was moved to mlir/test/Target/SPIRV/undef.mlir.

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

  • This file was moved from mlir/test/Dialect/SPIRV/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>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.Bitcast // spv.Bitcast
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @convert_bitcast_full(%arg0 : vector<2xf32>) -> f64 { func @convert_bitcast_full(%arg0 : vector<2xf32>) -> f64 {
// CHECK: %[[RESULT:.*]] = spv.Bitcast {{%.*}} : vector<2xf32> to f64 // CHECK: %[[RESULT:.*]] = spv.Bitcast {{%.*}} : vector<2xf32> to f64
// CHECK-NEXT: spv.ReturnValue %[[RESULT]] // CHECK-NEXT: spv.ReturnValue %[[RESULT]]
%0 = spv.Bitcast %arg0 : vector<2xf32> to vector<2xi32> %0 = spv.Bitcast %arg0 : vector<2xf32> to vector<2xi32>
%1 = spv.Bitcast %0 : vector<2xi32> to i64 %1 = spv.Bitcast %0 : vector<2xi32> to i64
%2 = spv.Bitcast %1 : i64 to f64 %2 = spv.Bitcast %1 : i64 to f64
spv.ReturnValue %2 : f64 spv.ReturnValue %2 : f64
} }
// ----- // -----
func @convert_bitcast_multi_use(%arg0 : vector<2xf32>, %arg1 : !spv.ptr<i64, Uniform>) -> f64 { func @convert_bitcast_multi_use(%arg0 : vector<2xf32>, %arg1 : !spv.ptr<i64, Uniform>) -> f64 {
// CHECK: %[[RESULT_0:.*]] = spv.Bitcast {{%.*}} : vector<2xf32> to i64 // CHECK: %[[RESULT_0:.*]] = spv.Bitcast {{%.*}} : vector<2xf32> to i64
// CHECK-NEXT: %[[RESULT_1:.*]] = spv.Bitcast {{%.*}} : vector<2xf32> to f64 // CHECK-NEXT: %[[RESULT_1:.*]] = spv.Bitcast {{%.*}} : vector<2xf32> to f64
// CHECK-NEXT: spv.Store {{".*"}} {{%.*}}, %[[RESULT_0]] // CHECK-NEXT: spv.Store {{".*"}} {{%.*}}, %[[RESULT_0]]
// CHECK-NEXT: spv.ReturnValue %[[RESULT_1]] // CHECK-NEXT: spv.ReturnValue %[[RESULT_1]]
%0 = spv.Bitcast %arg0 : vector<2xf32> to i64 %0 = spv.Bitcast %arg0 : vector<2xf32> to i64
%1 = spv.Bitcast %0 : i64 to f64 %1 = spv.Bitcast %0 : i64 to f64
spv.Store "Uniform" %arg1, %0 : i64 spv.Store "Uniform" %arg1, %0 : i64
spv.ReturnValue %1 : f64 spv.ReturnValue %1 : f64
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// spv.LogicalNot // spv.LogicalNot
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
func @convert_logical_not_to_not_equal(%arg0: vector<3xi64>, %arg1: vector<3xi64>) -> vector<3xi1> { func @convert_logical_not_to_not_equal(%arg0: vector<3xi64>, %arg1: vector<3xi64>) -> vector<3xi1> {
// CHECK: %[[RESULT:.*]] = spv.INotEqual {{%.*}}, {{%.*}} : vector<3xi64> // CHECK: %[[RESULT:.*]] = spv.INotEqual {{%.*}}, {{%.*}} : vector<3xi64>
// CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1> // CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1>
%2 = spv.IEqual %arg0, %arg1 : vector<3xi64> %2 = spv.IEqual %arg0, %arg1 : vector<3xi64>
%3 = spv.LogicalNot %2 : vector<3xi1> %3 = spv.LogicalNot %2 : vector<3xi1>
spv.ReturnValue %3 : vector<3xi1> spv.ReturnValue %3 : vector<3xi1>
} }
// ----- // -----
func @convert_logical_not_to_equal(%arg0: vector<3xi64>, %arg1: vector<3xi64>) -> vector<3xi1> { func @convert_logical_not_to_equal(%arg0: vector<3xi64>, %arg1: vector<3xi64>) -> vector<3xi1> {
// CHECK: %[[RESULT:.*]] = spv.IEqual {{%.*}}, {{%.*}} : vector<3xi64> // CHECK: %[[RESULT:.*]] = spv.IEqual {{%.*}}, {{%.*}} : vector<3xi64>
// CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1> // CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1>
%2 = spv.INotEqual %arg0, %arg1 : vector<3xi64> %2 = spv.INotEqual %arg0, %arg1 : vector<3xi64>
%3 = spv.LogicalNot %2 : vector<3xi1> %3 = spv.LogicalNot %2 : vector<3xi1>
spv.ReturnValue %3 : vector<3xi1> spv.ReturnValue %3 : vector<3xi1>
} }
// ----- // -----
func @convert_logical_not_parent_multi_use(%arg0: vector<3xi64>, %arg1: vector<3xi64>, %arg2: !spv.ptr<vector<3xi1>, Uniform>) -> vector<3xi1> { func @convert_logical_not_parent_multi_use(%arg0: vector<3xi64>, %arg1: vector<3xi64>, %arg2: !spv.ptr<vector<3xi1>, Uniform>) -> vector<3xi1> {
// CHECK: %[[RESULT_0:.*]] = spv.INotEqual {{%.*}}, {{%.*}} : vector<3xi64> // CHECK: %[[RESULT_0:.*]] = spv.INotEqual {{%.*}}, {{%.*}} : vector<3xi64>
// CHECK-NEXT: %[[RESULT_1:.*]] = spv.IEqual {{%.*}}, {{%.*}} : vector<3xi64> // CHECK-NEXT: %[[RESULT_1:.*]] = spv.IEqual {{%.*}}, {{%.*}} : vector<3xi64>
// CHECK-NEXT: spv.Store "Uniform" {{%.*}}, %[[RESULT_0]] // CHECK-NEXT: spv.Store "Uniform" {{%.*}}, %[[RESULT_0]]
// CHECK-NEXT: spv.ReturnValue %[[RESULT_1]] // CHECK-NEXT: spv.ReturnValue %[[RESULT_1]]
%0 = spv.INotEqual %arg0, %arg1 : vector<3xi64> %0 = spv.INotEqual %arg0, %arg1 : vector<3xi64>
%1 = spv.LogicalNot %0 : vector<3xi1> %1 = spv.LogicalNot %0 : vector<3xi1>
spv.Store "Uniform" %arg2, %0 : vector<3xi1> spv.Store "Uniform" %arg2, %0 : vector<3xi1>
spv.ReturnValue %1 : vector<3xi1> spv.ReturnValue %1 : vector<3xi1>
} }
// ----- // -----
func @convert_logical_not_to_logical_not_equal(%arg0: vector<3xi1>, %arg1: vector<3xi1>) -> vector<3xi1> { func @convert_logical_not_to_logical_not_equal(%arg0: vector<3xi1>, %arg1: vector<3xi1>) -> vector<3xi1> {
// CHECK: %[[RESULT:.*]] = spv.LogicalNotEqual {{%.*}}, {{%.*}} : vector<3xi1> // CHECK: %[[RESULT:.*]] = spv.LogicalNotEqual {{%.*}}, {{%.*}} : vector<3xi1>
// CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1> // CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1>
%2 = spv.LogicalEqual %arg0, %arg1 : vector<3xi1> %2 = spv.LogicalEqual %arg0, %arg1 : vector<3xi1>
%3 = spv.LogicalNot %2 : vector<3xi1> %3 = spv.LogicalNot %2 : vector<3xi1>
spv.ReturnValue %3 : vector<3xi1> spv.ReturnValue %3 : vector<3xi1>
} }
// ----- // -----
func @convert_logical_not_to_logical_equal(%arg0: vector<3xi1>, %arg1: vector<3xi1>) -> vector<3xi1> { func @convert_logical_not_to_logical_equal(%arg0: vector<3xi1>, %arg1: vector<3xi1>) -> vector<3xi1> {
// CHECK: %[[RESULT:.*]] = spv.LogicalEqual {{%.*}}, {{%.*}} : vector<3xi1> // CHECK: %[[RESULT:.*]] = spv.LogicalEqual {{%.*}}, {{%.*}} : vector<3xi1>
// CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1> // CHECK-NEXT: spv.ReturnValue %[[RESULT]] : vector<3xi1>
%2 = spv.LogicalNotEqual %arg0, %arg1 : vector<3xi1> %2 = spv.LogicalNotEqual %arg0, %arg1 : vector<3xi1>
%3 = spv.LogicalNot %2 : vector<3xi1> %3 = spv.LogicalNot %2 : vector<3xi1>
spv.ReturnValue %3 : vector<3xi1> spv.ReturnValue %3 : vector<3xi1>
} }
// ----- // -----
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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
^else: ^else:
spv.Store "Function" %3, %2 ["Aligned", 4]: i32 spv.Store "Function" %3, %2 ["Aligned", 4]: i32
spv.Branch ^merge spv.Branch ^merge
^then: ^then:
spv.Store "Function" %3, %1 ["Aligned", 4]: i32 spv.Store "Function" %3, %1 ["Aligned", 4]: i32
spv.Branch ^merge spv.Branch ^merge
^merge: ^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
^then: ^then:
spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32> spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^else: ^else:
spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
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
// CHECK-SAME: ^bb1(%[[DST_VAR_0]], %[[SRC_VALUE_0]] // CHECK-SAME: ^bb1(%[[DST_VAR_0]], %[[SRC_VALUE_0]]
// CHECK-SAME: ^bb1(%[[DST_VAR_1]], %[[SRC_VALUE_1]] // CHECK-SAME: ^bb1(%[[DST_VAR_1]], %[[SRC_VALUE_1]]
spv.BranchConditional %cond, ^then, ^else spv.BranchConditional %cond, ^then, ^else
^then: ^then:
// CHECK: ^bb1(%[[ARG0:.*]]: !spv.ptr<vector<3xi32>, Function>, %[[ARG1:.*]]: vector<3xi32>): // CHECK: ^bb1(%[[ARG0:.*]]: !spv.ptr<vector<3xi32>, Function>, %[[ARG1:.*]]: vector<3xi32>):
// CHECK: spv.Store "Function" %[[ARG0]], %[[ARG1]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[ARG0]], %[[ARG1]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32> spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^else: ^else:
spv.Store "Function" %4, %2 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %4, %2 ["Aligned", 8] : vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
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
^then: ^then:
// CHECK: spv.Store "Function" %[[DST_VAR_0]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR_0]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %1 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %3, %1 ["Aligned", 8] : vector<3xi32>
// CHECK: spv.Store "Function" %[[DST_VAR_1]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR_1]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %4, %1 ["Aligned", 8]: vector<3xi32> spv.Store "Function" %4, %1 ["Aligned", 8]: vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^else: ^else:
// CHECK: spv.Store "Function" %[[DST_VAR_1]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR_1]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %4, %2 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %4, %2 ["Aligned", 8] : vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
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:
// CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32> spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^else: ^else:
// CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
spv.Branch ^then spv.Branch ^then
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
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:
// CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_0]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32> spv.Store "Function" %3, %1 ["Aligned", 8]: vector<3xi32>
spv.Return spv.Return
^else: ^else:
// CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
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:
// CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_0]] ["Aligned", 4] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_0]] ["Aligned", 4] : vector<3xi32>
spv.Store "Function" %3, %1 ["Aligned", 4]: vector<3xi32> spv.Store "Function" %3, %1 ["Aligned", 4]: vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^else: ^else:
// CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32> // CHECK: spv.Store "Function" %[[DST_VAR]], %[[SRC_VALUE_1]] ["Aligned", 8] : vector<3xi32>
spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32> spv.Store "Function" %3, %2 ["Aligned", 8] : vector<3xi32>
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }

mlir/test/Dialect/SPIRV/arithmetic-ops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/arithmetic-ops.mlir.

mlir/test/Dialect/SPIRV/atomic-ops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/atomic-ops.mlir.

mlir/test/Dialect/SPIRV/availability.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/availability.mlir.

mlir/test/Dialect/SPIRV/bit-ops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/bit-ops.mlir.

mlir/test/Dialect/SPIRV/canonicalize.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/Transforms/canonicalize.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/composite-ops.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/control-flow-ops.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/cooperative-matrix-ops.mlir.

mlir/test/Dialect/SPIRV/glslops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/glsl-ops.mlir.

mlir/test/Dialect/SPIRV/group-ops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/group-ops.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/logical-ops.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/matrix-ops.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/non-uniform-ops.mlir.

mlir/test/Dialect/SPIRV/ocl-ops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir.

mlir/test/Dialect/SPIRV/ops.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/ops.mlir.

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

  • This file was moved to mlir/test/Dialect/SPIRV/IR/structure-ops.mlir.

mlir/test/Dialect/SPIRV/target-and-abi.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/target-and-abi.mlir.

mlir/test/Dialect/SPIRV/target-env.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/target-env.mlir.

mlir/test/Dialect/SPIRV/types.mlir

  • This file was moved to mlir/test/Dialect/SPIRV/IR/types.mlir.

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/arithmetic-ops.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.func @fmul(%arg0 : f32, %arg1 : f32) "None" { spv.func @fmul(%arg0 : f32, %arg1 : f32) "None" {
// CHECK: {{%.*}}= spv.FMul {{%.*}}, {{%.*}} : f32 // CHECK: {{%.*}}= spv.FMul {{%.*}}, {{%.*}} : f32
%0 = spv.FMul %arg0, %arg1 : f32 %0 = spv.FMul %arg0, %arg1 : f32
spv.Return spv.Return
} }
spv.func @fadd(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" { spv.func @fadd(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" {
// CHECK: {{%.*}} = spv.FAdd {{%.*}}, {{%.*}} : vector<4xf32> // CHECK: {{%.*}} = spv.FAdd {{%.*}}, {{%.*}} : vector<4xf32>
%0 = spv.FAdd %arg0, %arg1 : vector<4xf32> %0 = spv.FAdd %arg0, %arg1 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @fdiv(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" { spv.func @fdiv(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" {
// CHECK: {{%.*}} = spv.FDiv {{%.*}}, {{%.*}} : vector<4xf32> // CHECK: {{%.*}} = spv.FDiv {{%.*}}, {{%.*}} : vector<4xf32>
%0 = spv.FDiv %arg0, %arg1 : vector<4xf32> %0 = spv.FDiv %arg0, %arg1 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @fmod(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" { spv.func @fmod(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" {
// CHECK: {{%.*}} = spv.FMod {{%.*}}, {{%.*}} : vector<4xf32> // CHECK: {{%.*}} = spv.FMod {{%.*}}, {{%.*}} : vector<4xf32>
%0 = spv.FMod %arg0, %arg1 : vector<4xf32> %0 = spv.FMod %arg0, %arg1 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @fnegate(%arg0 : vector<4xf32>) "None" { spv.func @fnegate(%arg0 : vector<4xf32>) "None" {
// CHECK: {{%.*}} = spv.FNegate {{%.*}} : vector<4xf32> // CHECK: {{%.*}} = spv.FNegate {{%.*}} : vector<4xf32>
%0 = spv.FNegate %arg0 : vector<4xf32> %0 = spv.FNegate %arg0 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @fsub(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" { spv.func @fsub(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" {
// CHECK: {{%.*}} = spv.FSub {{%.*}}, {{%.*}} : vector<4xf32> // CHECK: {{%.*}} = spv.FSub {{%.*}}, {{%.*}} : vector<4xf32>
%0 = spv.FSub %arg0, %arg1 : vector<4xf32> %0 = spv.FSub %arg0, %arg1 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @frem(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" { spv.func @frem(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" {
// CHECK: {{%.*}} = spv.FRem {{%.*}}, {{%.*}} : vector<4xf32> // CHECK: {{%.*}} = spv.FRem {{%.*}}, {{%.*}} : vector<4xf32>
%0 = spv.FRem %arg0, %arg1 : vector<4xf32> %0 = spv.FRem %arg0, %arg1 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @iadd(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @iadd(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.IAdd %arg0, %arg1 : vector<4xi32> %0 = spv.IAdd %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @isub(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @isub(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.ISub {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.ISub {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.ISub %arg0, %arg1 : vector<4xi32> %0 = spv.ISub %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @imul(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @imul(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.IMul {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.IMul {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.IMul %arg0, %arg1 : vector<4xi32> %0 = spv.IMul %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @udiv(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @udiv(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.UDiv {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.UDiv {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.UDiv %arg0, %arg1 : vector<4xi32> %0 = spv.UDiv %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @umod(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @umod(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.UMod {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.UMod {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.UMod %arg0, %arg1 : vector<4xi32> %0 = spv.UMod %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @sdiv(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @sdiv(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.SDiv {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.SDiv {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.SDiv %arg0, %arg1 : vector<4xi32> %0 = spv.SDiv %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @smod(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @smod(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.SMod {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.SMod {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.SMod %arg0, %arg1 : vector<4xi32> %0 = spv.SMod %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @snegate(%arg0 : vector<4xi32>) "None" { spv.func @snegate(%arg0 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.SNegate {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.SNegate {{%.*}} : vector<4xi32>
%0 = spv.SNegate %arg0 : vector<4xi32> %0 = spv.SNegate %arg0 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @srem(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" { spv.func @srem(%arg0 : vector<4xi32>, %arg1 : vector<4xi32>) "None" {
// CHECK: {{%.*}} = spv.SRem {{%.*}}, {{%.*}} : vector<4xi32> // CHECK: {{%.*}} = spv.SRem {{%.*}}, {{%.*}} : vector<4xi32>
%0 = spv.SRem %arg0, %arg1 : vector<4xi32> %0 = spv.SRem %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/array.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/array.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
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @array_stride(%arg0 : !spv.ptr<!spv.array<4x!spv.array<4xf32, stride=4>, stride=128>, StorageBuffer>, %arg1 : i32, %arg2 : i32) "None" { spv.func @array_stride(%arg0 : !spv.ptr<!spv.array<4x!spv.array<4xf32, stride=4>, stride=128>, StorageBuffer>, %arg1 : i32, %arg2 : i32) "None" {
// CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32, stride=4>, stride=128>, StorageBuffer>, i32, i32 // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32, stride=4>, stride=128>, StorageBuffer>, i32, i32
%2 = spv.AccessChain %arg0[%arg1, %arg2] : !spv.ptr<!spv.array<4x!spv.array<4xf32, stride=4>, stride=128>, StorageBuffer>, i32, i32 %2 = spv.AccessChain %arg0[%arg1, %arg2] : !spv.ptr<!spv.array<4x!spv.array<4xf32, stride=4>, stride=128>, StorageBuffer>, i32, 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.globalVariable {{@.*}} : !spv.ptr<!spv.rtarray<f32, stride=4>, StorageBuffer> // CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.rtarray<f32, stride=4>, StorageBuffer>
spv.globalVariable @var0 : !spv.ptr<!spv.rtarray<f32, stride=4>, StorageBuffer> spv.globalVariable @var0 : !spv.ptr<!spv.rtarray<f32, stride=4>, StorageBuffer>
// CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.rtarray<vector<4xf16>>, Input> // CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.rtarray<vector<4xf16>>, Input>
spv.globalVariable @var1 : !spv.ptr<!spv.rtarray<vector<4xf16>>, Input> spv.globalVariable @var1 : !spv.ptr<!spv.rtarray<vector<4xf16>>, Input>
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/atomic-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: @atomic_compare_exchange_weak // CHECK-LABEL: @atomic_compare_exchange_weak
spv.func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 "None" { spv.func @atomic_compare_exchange_weak(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) -> i32 "None" {
// CHECK: spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %{{.*}}, %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %{{.*}}, %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup> %0 = spv.AtomicCompareExchangeWeak "Workgroup" "Release" "Acquire" %ptr, %value, %comparator: !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicAnd "Device" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicAnd "Device" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%1 = spv.AtomicAnd "Device" "None" %ptr, %value : !spv.ptr<i32, Workgroup> %1 = spv.AtomicAnd "Device" "None" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicIAdd "Workgroup" "Acquire" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicIAdd "Workgroup" "Acquire" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%2 = spv.AtomicIAdd "Workgroup" "Acquire" %ptr, %value : !spv.ptr<i32, Workgroup> %2 = spv.AtomicIAdd "Workgroup" "Acquire" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicIDecrement "Workgroup" "Acquire" %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicIDecrement "Workgroup" "Acquire" %{{.*}} : !spv.ptr<i32, Workgroup>
%3 = spv.AtomicIDecrement "Workgroup" "Acquire" %ptr : !spv.ptr<i32, Workgroup> %3 = spv.AtomicIDecrement "Workgroup" "Acquire" %ptr : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicIIncrement "Device" "Release" %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicIIncrement "Device" "Release" %{{.*}} : !spv.ptr<i32, Workgroup>
%4 = spv.AtomicIIncrement "Device" "Release" %ptr : !spv.ptr<i32, Workgroup> %4 = spv.AtomicIIncrement "Device" "Release" %ptr : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicISub "Workgroup" "Acquire" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicISub "Workgroup" "Acquire" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%5 = spv.AtomicISub "Workgroup" "Acquire" %ptr, %value : !spv.ptr<i32, Workgroup> %5 = spv.AtomicISub "Workgroup" "Acquire" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicOr "Workgroup" "AcquireRelease" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicOr "Workgroup" "AcquireRelease" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%6 = spv.AtomicOr "Workgroup" "AcquireRelease" %ptr, %value : !spv.ptr<i32, Workgroup> %6 = spv.AtomicOr "Workgroup" "AcquireRelease" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicSMax "Subgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicSMax "Subgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%7 = spv.AtomicSMax "Subgroup" "None" %ptr, %value : !spv.ptr<i32, Workgroup> %7 = spv.AtomicSMax "Subgroup" "None" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicSMin "Device" "Release" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicSMin "Device" "Release" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%8 = spv.AtomicSMin "Device" "Release" %ptr, %value : !spv.ptr<i32, Workgroup> %8 = spv.AtomicSMin "Device" "Release" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicUMax "Subgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicUMax "Subgroup" "None" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%9 = spv.AtomicUMax "Subgroup" "None" %ptr, %value : !spv.ptr<i32, Workgroup> %9 = spv.AtomicUMax "Subgroup" "None" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicUMin "Device" "Release" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicUMin "Device" "Release" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%10 = spv.AtomicUMin "Device" "Release" %ptr, %value : !spv.ptr<i32, Workgroup> %10 = spv.AtomicUMin "Device" "Release" %ptr, %value : !spv.ptr<i32, Workgroup>
// CHECK: spv.AtomicXor "Workgroup" "AcquireRelease" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup> // CHECK: spv.AtomicXor "Workgroup" "AcquireRelease" %{{.*}}, %{{.*}} : !spv.ptr<i32, Workgroup>
%11 = spv.AtomicXor "Workgroup" "AcquireRelease" %ptr, %value : !spv.ptr<i32, Workgroup> %11 = spv.AtomicXor "Workgroup" "AcquireRelease" %ptr, %value : !spv.ptr<i32, Workgroup>
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
} }

mlir/test/Target/SPIRV/barrier.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/barrier.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.func @memory_barrier_0() -> () "None" { spv.func @memory_barrier_0() -> () "None" {
// CHECK: spv.MemoryBarrier "Device", "Release|UniformMemory" // CHECK: spv.MemoryBarrier "Device", "Release|UniformMemory"
spv.MemoryBarrier "Device", "Release|UniformMemory" spv.MemoryBarrier "Device", "Release|UniformMemory"
spv.Return spv.Return
} }
spv.func @memory_barrier_1() -> () "None" { spv.func @memory_barrier_1() -> () "None" {
// CHECK: spv.MemoryBarrier "Subgroup", "AcquireRelease|SubgroupMemory" // CHECK: spv.MemoryBarrier "Subgroup", "AcquireRelease|SubgroupMemory"
spv.MemoryBarrier "Subgroup", "AcquireRelease|SubgroupMemory" spv.MemoryBarrier "Subgroup", "AcquireRelease|SubgroupMemory"
spv.Return spv.Return
} }
spv.func @control_barrier_0() -> () "None" { spv.func @control_barrier_0() -> () "None" {
// CHECK: spv.ControlBarrier "Device", "Workgroup", "Release|UniformMemory" // CHECK: spv.ControlBarrier "Device", "Workgroup", "Release|UniformMemory"
spv.ControlBarrier "Device", "Workgroup", "Release|UniformMemory" spv.ControlBarrier "Device", "Workgroup", "Release|UniformMemory"
spv.Return spv.Return
} }
spv.func @control_barrier_1() -> () "None" { spv.func @control_barrier_1() -> () "None" {
// CHECK: spv.ControlBarrier "Workgroup", "Invocation", "AcquireRelease|UniformMemory" // CHECK: spv.ControlBarrier "Workgroup", "Invocation", "AcquireRelease|UniformMemory"
spv.ControlBarrier "Workgroup", "Invocation", "AcquireRelease|UniformMemory" spv.ControlBarrier "Workgroup", "Invocation", "AcquireRelease|UniformMemory"
spv.Return spv.Return
} }
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/bit-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], []> {
spv.func @bitcount(%arg: i32) -> i32 "None" { spv.func @bitcount(%arg: i32) -> i32 "None" {
// CHECK: spv.BitCount {{%.*}} : i32 // CHECK: spv.BitCount {{%.*}} : i32
%0 = spv.BitCount %arg : i32 %0 = spv.BitCount %arg : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @bit_field_insert(%base: vector<3xi32>, %insert: vector<3xi32>, %offset: i32, %count: i16) -> vector<3xi32> "None" { spv.func @bit_field_insert(%base: vector<3xi32>, %insert: vector<3xi32>, %offset: i32, %count: i16) -> vector<3xi32> "None" {
// CHECK: {{%.*}} = spv.BitFieldInsert {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i32, i16 // CHECK: {{%.*}} = spv.BitFieldInsert {{%.*}}, {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i32, i16
%0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<3xi32>, i32, i16 %0 = spv.BitFieldInsert %base, %insert, %offset, %count : vector<3xi32>, i32, i16
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
spv.func @bit_field_s_extract(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> "None" { spv.func @bit_field_s_extract(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> "None" {
// CHECK: {{%.*}} = spv.BitFieldSExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8 // CHECK: {{%.*}} = spv.BitFieldSExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8
%0 = spv.BitFieldSExtract %base, %offset, %count : vector<3xi32>, i8, i8 %0 = spv.BitFieldSExtract %base, %offset, %count : vector<3xi32>, i8, i8
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
spv.func @bit_field_u_extract(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> "None" { spv.func @bit_field_u_extract(%base: vector<3xi32>, %offset: i8, %count: i8) -> vector<3xi32> "None" {
// CHECK: {{%.*}} = spv.BitFieldUExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8 // CHECK: {{%.*}} = spv.BitFieldUExtract {{%.*}}, {{%.*}}, {{%.*}} : vector<3xi32>, i8, i8
%0 = spv.BitFieldUExtract %base, %offset, %count : vector<3xi32>, i8, i8 %0 = spv.BitFieldUExtract %base, %offset, %count : vector<3xi32>, i8, i8
spv.ReturnValue %0 : vector<3xi32> spv.ReturnValue %0 : vector<3xi32>
} }
spv.func @bitreverse(%arg: i32) -> i32 "None" { spv.func @bitreverse(%arg: i32) -> i32 "None" {
// CHECK: spv.BitReverse {{%.*}} : i32 // CHECK: spv.BitReverse {{%.*}} : i32
%0 = spv.BitReverse %arg : i32 %0 = spv.BitReverse %arg : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @not(%arg: i32) -> i32 "None" { spv.func @not(%arg: i32) -> i32 "None" {
// CHECK: spv.Not {{%.*}} : i32 // CHECK: spv.Not {{%.*}} : i32
%0 = spv.Not %arg : i32 %0 = spv.Not %arg : i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @bitwise_scalar(%arg0 : i32, %arg1 : i32) "None" { spv.func @bitwise_scalar(%arg0 : i32, %arg1 : i32) "None" {
// CHECK: spv.BitwiseAnd // CHECK: spv.BitwiseAnd
%0 = spv.BitwiseAnd %arg0, %arg1 : i32 %0 = spv.BitwiseAnd %arg0, %arg1 : i32
// CHECK: spv.BitwiseOr // CHECK: spv.BitwiseOr
%1 = spv.BitwiseOr %arg0, %arg1 : i32 %1 = spv.BitwiseOr %arg0, %arg1 : i32
// CHECK: spv.BitwiseXor // CHECK: spv.BitwiseXor
%2 = spv.BitwiseXor %arg0, %arg1 : i32 %2 = spv.BitwiseXor %arg0, %arg1 : i32
spv.Return spv.Return
} }
spv.func @shift_left_logical(%arg0: i32, %arg1 : i16) -> i32 "None" { spv.func @shift_left_logical(%arg0: i32, %arg1 : i16) -> i32 "None" {
// CHECK: {{%.*}} = spv.ShiftLeftLogical {{%.*}}, {{%.*}} : i32, i16 // CHECK: {{%.*}} = spv.ShiftLeftLogical {{%.*}}, {{%.*}} : i32, i16
%0 = spv.ShiftLeftLogical %arg0, %arg1: i32, i16 %0 = spv.ShiftLeftLogical %arg0, %arg1: i32, i16
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @shift_right_arithmetic(%arg0: vector<4xi32>, %arg1 : vector<4xi8>) -> vector<4xi32> "None" { spv.func @shift_right_arithmetic(%arg0: vector<4xi32>, %arg1 : vector<4xi8>) -> vector<4xi32> "None" {
// CHECK: {{%.*}} = spv.ShiftRightArithmetic {{%.*}}, {{%.*}} : vector<4xi32>, vector<4xi8> // CHECK: {{%.*}} = spv.ShiftRightArithmetic {{%.*}}, {{%.*}} : vector<4xi32>, vector<4xi8>
%0 = spv.ShiftRightArithmetic %arg0, %arg1: vector<4xi32>, vector<4xi8> %0 = spv.ShiftRightArithmetic %arg0, %arg1: vector<4xi32>, vector<4xi8>
spv.ReturnValue %0 : vector<4xi32> spv.ReturnValue %0 : vector<4xi32>
} }
spv.func @shift_right_logical(%arg0: vector<2xi32>, %arg1 : vector<2xi8>) -> vector<2xi32> "None" { spv.func @shift_right_logical(%arg0: vector<2xi32>, %arg1 : vector<2xi8>) -> vector<2xi32> "None" {
// CHECK: {{%.*}} = spv.ShiftRightLogical {{%.*}}, {{%.*}} : vector<2xi32>, vector<2xi8> // CHECK: {{%.*}} = spv.ShiftRightLogical {{%.*}}, {{%.*}} : vector<2xi32>, vector<2xi8>
%0 = spv.ShiftRightLogical %arg0, %arg1: vector<2xi32>, vector<2xi8> %0 = spv.ShiftRightLogical %arg0, %arg1: vector<2xi32>, vector<2xi8>
spv.ReturnValue %0 : vector<2xi32> spv.ReturnValue %0 : vector<2xi32>
} }
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/cast-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], []> {
spv.func @bit_cast(%arg0 : f32) "None" { spv.func @bit_cast(%arg0 : f32) "None" {
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : f32 to i32 // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : f32 to i32
%0 = spv.Bitcast %arg0 : f32 to i32 %0 = spv.Bitcast %arg0 : f32 to i32
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : i32 to si32 // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : i32 to si32
%1 = spv.Bitcast %0 : i32 to si32 %1 = spv.Bitcast %0 : i32 to si32
// CHECK: {{%.*}} = spv.Bitcast {{%.*}} : si32 to i32 // CHECK: {{%.*}} = spv.Bitcast {{%.*}} : si32 to i32
%2 = spv.Bitcast %1 : si32 to ui32 %2 = spv.Bitcast %1 : si32 to ui32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @convert_f_to_s(%arg0 : f32) -> i32 "None" { spv.func @convert_f_to_s(%arg0 : f32) -> i32 "None" {
// CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f32 to i32 // CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f32 to i32
%0 = spv.ConvertFToS %arg0 : f32 to i32 %0 = spv.ConvertFToS %arg0 : f32 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @convert_f64_to_s32(%arg0 : f64) -> i32 "None" { spv.func @convert_f64_to_s32(%arg0 : f64) -> i32 "None" {
// CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f64 to i32 // CHECK: {{%.*}} = spv.ConvertFToS {{%.*}} : f64 to i32
%0 = spv.ConvertFToS %arg0 : f64 to i32 %0 = spv.ConvertFToS %arg0 : f64 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @convert_f_to_u(%arg0 : f32) -> i32 "None" { spv.func @convert_f_to_u(%arg0 : f32) -> i32 "None" {
// CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f32 to i32 // CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f32 to i32
%0 = spv.ConvertFToU %arg0 : f32 to i32 %0 = spv.ConvertFToU %arg0 : f32 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @convert_f64_to_u32(%arg0 : f64) -> i32 "None" { spv.func @convert_f64_to_u32(%arg0 : f64) -> i32 "None" {
// CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f64 to i32 // CHECK: {{%.*}} = spv.ConvertFToU {{%.*}} : f64 to i32
%0 = spv.ConvertFToU %arg0 : f64 to i32 %0 = spv.ConvertFToU %arg0 : f64 to i32
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
spv.func @convert_s_to_f(%arg0 : i32) -> f32 "None" { spv.func @convert_s_to_f(%arg0 : i32) -> f32 "None" {
// CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i32 to f32 // CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i32 to f32
%0 = spv.ConvertSToF %arg0 : i32 to f32 %0 = spv.ConvertSToF %arg0 : i32 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
spv.func @convert_s64_to_f32(%arg0 : i64) -> f32 "None" { spv.func @convert_s64_to_f32(%arg0 : i64) -> f32 "None" {
// CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i64 to f32 // CHECK: {{%.*}} = spv.ConvertSToF {{%.*}} : i64 to f32
%0 = spv.ConvertSToF %arg0 : i64 to f32 %0 = spv.ConvertSToF %arg0 : i64 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
spv.func @convert_u_to_f(%arg0 : i32) -> f32 "None" { spv.func @convert_u_to_f(%arg0 : i32) -> f32 "None" {
// CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i32 to f32 // CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i32 to f32
%0 = spv.ConvertUToF %arg0 : i32 to f32 %0 = spv.ConvertUToF %arg0 : i32 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
spv.func @convert_u64_to_f32(%arg0 : i64) -> f32 "None" { spv.func @convert_u64_to_f32(%arg0 : i64) -> f32 "None" {
// CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i64 to f32 // CHECK: {{%.*}} = spv.ConvertUToF {{%.*}} : i64 to f32
%0 = spv.ConvertUToF %arg0 : i64 to f32 %0 = spv.ConvertUToF %arg0 : i64 to f32
spv.ReturnValue %0 : f32 spv.ReturnValue %0 : f32
} }
spv.func @f_convert(%arg0 : f32) -> f64 "None" { spv.func @f_convert(%arg0 : f32) -> f64 "None" {
// CHECK: {{%.*}} = spv.FConvert {{%.*}} : f32 to f64 // CHECK: {{%.*}} = spv.FConvert {{%.*}} : f32 to f64
%0 = spv.FConvert %arg0 : f32 to f64 %0 = spv.FConvert %arg0 : f32 to f64
spv.ReturnValue %0 : f64 spv.ReturnValue %0 : f64
} }
spv.func @s_convert(%arg0 : i32) -> i64 "None" { spv.func @s_convert(%arg0 : i32) -> i64 "None" {
// CHECK: {{%.*}} = spv.SConvert {{%.*}} : i32 to i64 // CHECK: {{%.*}} = spv.SConvert {{%.*}} : i32 to i64
%0 = spv.SConvert %arg0 : i32 to i64 %0 = spv.SConvert %arg0 : i32 to i64
spv.ReturnValue %0 : i64 spv.ReturnValue %0 : i64
} }
spv.func @u_convert(%arg0 : i32) -> i64 "None" { spv.func @u_convert(%arg0 : i32) -> i64 "None" {
// CHECK: {{%.*}} = spv.UConvert {{%.*}} : i32 to i64 // CHECK: {{%.*}} = spv.UConvert {{%.*}} : i32 to i64
%0 = spv.UConvert %arg0 : i32 to i64 %0 = spv.UConvert %arg0 : i32 to i64
spv.ReturnValue %0 : i64 spv.ReturnValue %0 : i64
} }
} }

mlir/test/Target/SPIRV/composite-op.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/composite-op.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
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @composite_insert(%arg0 : !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>, %arg1: !spv.array<4xf32>) -> !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)> "None" { spv.func @composite_insert(%arg0 : !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>, %arg1: !spv.array<4xf32>) -> !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)> "None" {
// CHECK: spv.CompositeInsert {{%.*}}, {{%.*}}[1 : i32, 0 : i32] : !spv.array<4 x f32> into !spv.struct<(f32, !spv.struct<(!spv.array<4 x f32>, f32)>)> // CHECK: spv.CompositeInsert {{%.*}}, {{%.*}}[1 : i32, 0 : i32] : !spv.array<4 x f32> into !spv.struct<(f32, !spv.struct<(!spv.array<4 x f32>, f32)>)>
%0 = spv.CompositeInsert %arg1, %arg0[1 : i32, 0 : i32] : !spv.array<4xf32> into !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)> %0 = spv.CompositeInsert %arg1, %arg0[1 : i32, 0 : i32] : !spv.array<4xf32> into !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>
spv.ReturnValue %0: !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)> spv.ReturnValue %0: !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>
} }
spv.func @composite_construct_vector(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xf32> "None" { spv.func @composite_construct_vector(%arg0: f32, %arg1: f32, %arg2 : f32) -> vector<3xf32> "None" {
// CHECK: spv.CompositeConstruct {{%.*}}, {{%.*}}, {{%.*}} : vector<3xf32> // CHECK: spv.CompositeConstruct {{%.*}}, {{%.*}}, {{%.*}} : vector<3xf32>
%0 = spv.CompositeConstruct %arg0, %arg1, %arg2 : vector<3xf32> %0 = spv.CompositeConstruct %arg0, %arg1, %arg2 : vector<3xf32>
spv.ReturnValue %0: vector<3xf32> spv.ReturnValue %0: vector<3xf32>
} }
spv.func @vector_dynamic_extract(%vec: vector<4xf32>, %id : i32) -> f32 "None" { spv.func @vector_dynamic_extract(%vec: vector<4xf32>, %id : i32) -> f32 "None" {
// CHECK: spv.VectorExtractDynamic %{{.*}}[%{{.*}}] : vector<4xf32>, i32 // CHECK: spv.VectorExtractDynamic %{{.*}}[%{{.*}}] : vector<4xf32>, i32
%0 = spv.VectorExtractDynamic %vec[%id] : vector<4xf32>, i32 %0 = spv.VectorExtractDynamic %vec[%id] : vector<4xf32>, i32
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
spv.func @vector_dynamic_insert(%val: f32, %vec: vector<4xf32>, %id : i32) -> vector<4xf32> "None" { spv.func @vector_dynamic_insert(%val: f32, %vec: vector<4xf32>, %id : i32) -> vector<4xf32> "None" {
// CHECK: spv.VectorInsertDynamic %{{.*}}, %{{.*}}[%{{.*}}] : vector<4xf32>, i32 // CHECK: spv.VectorInsertDynamic %{{.*}}, %{{.*}}[%{{.*}}] : vector<4xf32>, i32
%0 = spv.VectorInsertDynamic %val, %vec[%id] : vector<4xf32>, i32 %0 = spv.VectorInsertDynamic %val, %vec[%id] : vector<4xf32>, i32
spv.ReturnValue %0: vector<4xf32> spv.ReturnValue %0: vector<4xf32>
} }
} }

mlir/test/Target/SPIRV/constant.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/cooperative-matrix.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, [CooperativeMatrixNV], [SPV_NV_cooperative_matrix]> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [CooperativeMatrixNV], [SPV_NV_cooperative_matrix]> {
// CHECK-LABEL: @cooperative_matrix_load // CHECK-LABEL: @cooperative_matrix_load
spv.func @cooperative_matrix_load(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<16x8xi32, Workgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_load_memaccess // CHECK-LABEL: @cooperative_matrix_load_memaccess
spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_load_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %b : i1) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLoadNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLoadNV %ptr, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer> as !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_store // CHECK-LABEL: @cooperative_matrix_store
spv.func @cooperative_matrix_store(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %m : !spv.coopmatrix<16x8xi32, Workgroup>, %b : i1) "None" { spv.func @cooperative_matrix_store(%ptr : !spv.ptr<i32, StorageBuffer>, %stride : i32, %m : !spv.coopmatrix<16x8xi32, Workgroup>, %b : i1) "None" {
// CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup> // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup>
spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup> spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<16x8xi32, Workgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_store_memaccess // CHECK-LABEL: @cooperative_matrix_store_memaccess
spv.func @cooperative_matrix_store_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %m : !spv.coopmatrix<8x16xi32, Subgroup>, %stride : i32, %b : i1) "None" { spv.func @cooperative_matrix_store_memaccess(%ptr : !spv.ptr<i32, StorageBuffer>, %m : !spv.coopmatrix<8x16xi32, Subgroup>, %stride : i32, %b : i1) "None" {
// CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: spv.CooperativeMatrixStoreNV {{%.*}}, {{%.*}}, {{%.*}} ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup> spv.CooperativeMatrixStoreNV %ptr, %m, %stride, %b ["Volatile"] : !spv.ptr<i32, StorageBuffer>, !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_length // CHECK-LABEL: @cooperative_matrix_length
spv.func @cooperative_matrix_length() -> i32 "None" { spv.func @cooperative_matrix_length() -> i32 "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
%0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup> %0 = spv.CooperativeMatrixLengthNV : !spv.coopmatrix<8x16xi32, Subgroup>
spv.ReturnValue %0 : i32 spv.ReturnValue %0 : i32
} }
// CHECK-LABEL: @cooperative_matrix_muladd // CHECK-LABEL: @cooperative_matrix_muladd
spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" { spv.func @cooperative_matrix_muladd(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<16x8xi32, Subgroup>, %c : !spv.coopmatrix<8x8xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.CooperativeMatrixMulAddNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> // CHECK: {{%.*}} = spv.CooperativeMatrixMulAddNV {{%.*}}, {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
%r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup> %r = spv.CooperativeMatrixMulAddNV %a, %b, %c : !spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<16x8xi32, Subgroup> -> !spv.coopmatrix<8x8xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_add // CHECK-LABEL: @cooperative_matrix_add
spv.func @cooperative_matrix_add(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_add(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.IAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.IAdd %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.IAdd %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_sub // CHECK-LABEL: @cooperative_matrix_sub
spv.func @cooperative_matrix_sub(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_sub(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.ISub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.ISub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.ISub %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.ISub %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_sdiv // CHECK-LABEL: @cooperative_matrix_sdiv
spv.func @cooperative_matrix_sdiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_sdiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.SDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.SDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.SDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.SDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_udiv // CHECK-LABEL: @cooperative_matrix_udiv
spv.func @cooperative_matrix_udiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" { spv.func @cooperative_matrix_udiv(%a : !spv.coopmatrix<8x16xi32, Subgroup>, %b : !spv.coopmatrix<8x16xi32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.UDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup> // CHECK: {{%.*}} = spv.UDiv {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xi32, Subgroup>
%r = spv.UDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup> %r = spv.UDiv %a, %b : !spv.coopmatrix<8x16xi32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_fadd // CHECK-LABEL: @cooperative_matrix_fadd
spv.func @cooperative_matrix_fadd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" { spv.func @cooperative_matrix_fadd(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.FAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: {{%.*}} = spv.FAdd {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup>
%r = spv.FAdd %a, %b : !spv.coopmatrix<8x16xf32, Subgroup> %r = spv.FAdd %a, %b : !spv.coopmatrix<8x16xf32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_fsub // CHECK-LABEL: @cooperative_matrix_fsub
spv.func @cooperative_matrix_fsub(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" { spv.func @cooperative_matrix_fsub(%a : !spv.coopmatrix<8x16xf32, Subgroup>, %b : !spv.coopmatrix<8x16xf32, Subgroup>) "None" {
// CHECK: {{%.*}} = spv.FSub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup> // CHECK: {{%.*}} = spv.FSub {{%.*}}, {{%.*}} : !spv.coopmatrix<8x16xf32, Subgroup>
%r = spv.FSub %a, %b : !spv.coopmatrix<8x16xf32, Subgroup> %r = spv.FSub %a, %b : !spv.coopmatrix<8x16xf32, Subgroup>
spv.Return spv.Return
} }
// CHECK-LABEL: @cooperative_matrix_fdiv // CHECK-LABEL: @cooperative_matrix_fdiv
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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/debug.mlir.
// RUN: mlir-translate -test-spirv-roundtrip-debug -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s // RUN: mlir-translate -test-spirv-roundtrip-debug -mlir-print-debuginfo -mlir-print-local-scope %s | FileCheck %s
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: loc({{".*debug.mlir"}}:5:3) // CHECK: loc({{".*debug.mlir"}}:5:3)
spv.globalVariable @var0 bind(0, 1) : !spv.ptr<f32, Input> spv.globalVariable @var0 bind(0, 1) : !spv.ptr<f32, Input>
spv.func @arithmetic(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" { spv.func @arithmetic(%arg0 : vector<4xf32>, %arg1 : vector<4xf32>) "None" {
// CHECK: loc({{".*debug.mlir"}}:8:10) // CHECK: loc({{".*debug.mlir"}}:8:10)
%0 = spv.FAdd %arg0, %arg1 : vector<4xf32> %0 = spv.FAdd %arg0, %arg1 : vector<4xf32>
// CHECK: loc({{".*debug.mlir"}}:10:10) // CHECK: loc({{".*debug.mlir"}}:10:10)
%1 = spv.FNegate %arg0 : vector<4xf32> %1 = spv.FNegate %arg0 : vector<4xf32>
spv.Return spv.Return
} }
spv.func @atomic(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) "None" { spv.func @atomic(%ptr: !spv.ptr<i32, Workgroup>, %value: i32, %comparator: i32) "None" {
// CHECK: loc({{".*debug.mlir"}}:16:10) // CHECK: loc({{".*debug.mlir"}}:16:10)
%1 = spv.AtomicAnd "Device" "None" %ptr, %value : !spv.ptr<i32, Workgroup> %1 = spv.AtomicAnd "Device" "None" %ptr, %value : !spv.ptr<i32, Workgroup>
spv.Return spv.Return
} }
spv.func @bitwiser(%arg0 : i32, %arg1 : i32) "None" { spv.func @bitwiser(%arg0 : i32, %arg1 : i32) "None" {
// CHECK: loc({{".*debug.mlir"}}:22:10) // CHECK: loc({{".*debug.mlir"}}:22:10)
%0 = spv.BitwiseAnd %arg0, %arg1 : i32 %0 = spv.BitwiseAnd %arg0, %arg1 : i32
spv.Return spv.Return
} }
spv.func @convert(%arg0 : f32) "None" { spv.func @convert(%arg0 : f32) "None" {
// CHECK: loc({{".*debug.mlir"}}:28:10) // CHECK: loc({{".*debug.mlir"}}:28:10)
%0 = spv.ConvertFToU %arg0 : f32 to i32 %0 = spv.ConvertFToU %arg0 : f32 to i32
spv.Return spv.Return
} }
spv.func @composite(%arg0 : !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>, %arg1: !spv.array<4xf32>, %arg2 : f32, %arg3 : f32) "None" { spv.func @composite(%arg0 : !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>, %arg1: !spv.array<4xf32>, %arg2 : f32, %arg3 : f32) "None" {
// CHECK: loc({{".*debug.mlir"}}:34:10) // CHECK: loc({{".*debug.mlir"}}:34:10)
%0 = spv.CompositeInsert %arg1, %arg0[1 : i32, 0 : i32] : !spv.array<4xf32> into !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)> %0 = spv.CompositeInsert %arg1, %arg0[1 : i32, 0 : i32] : !spv.array<4xf32> into !spv.struct<(f32, !spv.struct<(!spv.array<4xf32>, f32)>)>
// CHECK: loc({{".*debug.mlir"}}:36:10) // CHECK: loc({{".*debug.mlir"}}:36:10)
%1 = spv.CompositeConstruct %arg2, %arg3 : vector<2xf32> %1 = spv.CompositeConstruct %arg2, %arg3 : vector<2xf32>
spv.Return spv.Return
} }
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
// CHECK: loc({{".*debug.mlir"}}:75:5) // CHECK: loc({{".*debug.mlir"}}:75:5)
spv.BranchConditional %icmp, ^body, ^merge spv.BranchConditional %icmp, ^body, ^merge
^body: ^body:
spv.Store "Function" %jvar, %zero : i32 spv.Store "Function" %jvar, %zero : i32
spv.loop { spv.loop {
// CHECK: loc({{".*debug.mlir"}}:85:7) // CHECK: loc({{".*debug.mlir"}}:85:7)
spv.Branch ^header spv.Branch ^header
^header: ^header:
%jval0 = spv.Load "Function" %jvar : i32 %jval0 = spv.Load "Function" %jvar : i32
%jcmp = spv.SLessThan %jval0, %count : i32 %jcmp = spv.SLessThan %jval0, %count : i32
// CHECK: loc({{".*debug.mlir"}}:85:7) // CHECK: loc({{".*debug.mlir"}}:85:7)
spv.BranchConditional %jcmp, ^body, ^merge spv.BranchConditional %jcmp, ^body, ^merge
^body: ^body:
// CHECK: loc({{".*debug.mlir"}}:95:9) // CHECK: loc({{".*debug.mlir"}}:95:9)
spv.Branch ^continue spv.Branch ^continue
^continue: ^continue:
%jval1 = spv.Load "Function" %jvar : i32 %jval1 = spv.Load "Function" %jvar : i32
%add = spv.IAdd %jval1, %one : i32 %add = spv.IAdd %jval1, %one : i32
spv.Store "Function" %jvar, %add : i32 spv.Store "Function" %jvar, %add : i32
// CHECK: loc({{".*debug.mlir"}}:101:9) // CHECK: loc({{".*debug.mlir"}}:101:9)
spv.Branch ^header spv.Branch ^header
^merge: ^merge:
// CHECK: loc({{".*debug.mlir"}}:85:7) // CHECK: loc({{".*debug.mlir"}}:85:7)
spv.mlir.merge spv.mlir.merge
// CHECK: loc({{".*debug.mlir"}}:85:7) // CHECK: loc({{".*debug.mlir"}}:85:7)
} }
// CHECK: loc({{".*debug.mlir"}}:108:7) // CHECK: loc({{".*debug.mlir"}}:108:7)
spv.Branch ^continue spv.Branch ^continue
^continue: ^continue:
%ival1 = spv.Load "Function" %ivar : i32 %ival1 = spv.Load "Function" %ivar : i32
%add = spv.IAdd %ival1, %one : i32 %add = spv.IAdd %ival1, %one : i32
spv.Store "Function" %ivar, %add : i32 spv.Store "Function" %ivar, %add : i32
// CHECK: loc({{".*debug.mlir"}}:114:7) // CHECK: loc({{".*debug.mlir"}}:114:7)
spv.Branch ^header spv.Branch ^header
^merge: ^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
^else: ^else:
spv.Store "Function" %var, %two : i32 spv.Store "Function" %var, %two : i32
// CHECK: loc({{".*debug.mlir"}}:138:7) // CHECK: loc({{".*debug.mlir"}}:138:7)
spv.Branch ^merge spv.Branch ^merge
^merge: ^merge:
// CHECK: loc({{".*debug.mlir"}}:128:5) // CHECK: loc({{".*debug.mlir"}}:128:5)
spv.mlir.merge spv.mlir.merge
// CHECK: loc({{".*debug.mlir"}}:128:5) // CHECK: loc({{".*debug.mlir"}}:128:5)
} }
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/decorations.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/decorations.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
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: location = 0 : i32 // CHECK: location = 0 : i32
spv.globalVariable @var {location = 0 : i32} : !spv.ptr<vector<4xf32>, Input> spv.globalVariable @var {location = 0 : i32} : !spv.ptr<vector<4xf32>, Input>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: no_perspective // CHECK: no_perspective
spv.globalVariable @var {no_perspective} : !spv.ptr<vector<4xf32>, Input> spv.globalVariable @var {no_perspective} : !spv.ptr<vector<4xf32>, Input>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: flat // CHECK: flat
spv.globalVariable @var {flat} : !spv.ptr<si32, Input> spv.globalVariable @var {flat} : !spv.ptr<si32, Input>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: aliased // CHECK: aliased
// CHECK: aliased // CHECK: aliased
spv.globalVariable @var1 bind(0, 0) {aliased} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer> spv.globalVariable @var1 bind(0, 0) {aliased} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer>
spv.globalVariable @var2 bind(0, 0) {aliased} : !spv.ptr<!spv.struct<(vector<4xf32>[0])>, StorageBuffer> spv.globalVariable @var2 bind(0, 0) {aliased} : !spv.ptr<!spv.struct<(vector<4xf32>[0])>, StorageBuffer>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: non_readable // CHECK: non_readable
spv.globalVariable @var bind(0, 0) {non_readable} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer> spv.globalVariable @var bind(0, 0) {non_readable} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: non_writable // CHECK: non_writable
spv.globalVariable @var bind(0, 0) {non_writable} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer> spv.globalVariable @var bind(0, 0) {non_writable} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: restrict // CHECK: restrict
spv.globalVariable @var bind(0, 0) {restrict} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer> spv.globalVariable @var bind(0, 0) {restrict} : !spv.ptr<!spv.struct<(!spv.array<4xf32, stride=4>[0])>, StorageBuffer>
} }

mlir/test/Target/SPIRV/entry-point.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/entry-point.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], []> {
spv.func @noop() -> () "None" { spv.func @noop() -> () "None" {
spv.Return spv.Return
} }
// CHECK: spv.EntryPoint "GLCompute" @noop // CHECK: spv.EntryPoint "GLCompute" @noop
// CHECK-NEXT: spv.ExecutionMode @noop "ContractionOff" // CHECK-NEXT: spv.ExecutionMode @noop "ContractionOff"
spv.EntryPoint "GLCompute" @noop spv.EntryPoint "GLCompute" @noop
spv.ExecutionMode @noop "ContractionOff" spv.ExecutionMode @noop "ContractionOff"
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: spv.globalVariable @var2 : !spv.ptr<f32, Input> // CHECK: spv.globalVariable @var2 : !spv.ptr<f32, Input>
// CHECK-NEXT: spv.globalVariable @var3 : !spv.ptr<f32, Output> // CHECK-NEXT: spv.globalVariable @var3 : !spv.ptr<f32, Output>
// CHECK-NEXT: spv.func @noop({{%.*}}: !spv.ptr<f32, Input>, {{%.*}}: !spv.ptr<f32, Output>) "None" // CHECK-NEXT: spv.func @noop({{%.*}}: !spv.ptr<f32, Input>, {{%.*}}: !spv.ptr<f32, Output>) "None"
// CHECK: spv.EntryPoint "GLCompute" @noop, @var2, @var3 // CHECK: spv.EntryPoint "GLCompute" @noop, @var2, @var3
spv.globalVariable @var2 : !spv.ptr<f32, Input> spv.globalVariable @var2 : !spv.ptr<f32, Input>
spv.globalVariable @var3 : !spv.ptr<f32, Output> spv.globalVariable @var3 : !spv.ptr<f32, Output>
spv.func @noop(%arg0 : !spv.ptr<f32, Input>, %arg1 : !spv.ptr<f32, Output>) -> () "None" { spv.func @noop(%arg0 : !spv.ptr<f32, Input>, %arg1 : !spv.ptr<f32, Output>) -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @noop, @var2, @var3 spv.EntryPoint "GLCompute" @noop, @var2, @var3
spv.ExecutionMode @noop "ContractionOff" spv.ExecutionMode @noop "ContractionOff"
} }

mlir/test/Target/SPIRV/execution-mode.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/execution-mode.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.func @foo() -> () "None" { spv.func @foo() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @foo spv.EntryPoint "GLCompute" @foo
// CHECK: spv.ExecutionMode @foo "LocalSizeHint", 3, 4, 5 // CHECK: spv.ExecutionMode @foo "LocalSizeHint", 3, 4, 5
spv.ExecutionMode @foo "LocalSizeHint", 3, 4, 5 spv.ExecutionMode @foo "LocalSizeHint", 3, 4, 5
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/global-variable.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
// CHECK: spv.globalVariable @var0 bind(1, 0) : !spv.ptr<f32, Input> // CHECK: spv.globalVariable @var0 bind(1, 0) : !spv.ptr<f32, Input>
// CHECK-NEXT: spv.globalVariable @var1 bind(0, 1) : !spv.ptr<f32, Output> // CHECK-NEXT: spv.globalVariable @var1 bind(0, 1) : !spv.ptr<f32, Output>
// CHECK-NEXT: spv.globalVariable @var2 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> // CHECK-NEXT: spv.globalVariable @var2 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
// CHECK-NEXT: spv.globalVariable @var3 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> // CHECK-NEXT: spv.globalVariable @var3 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.globalVariable @var0 bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @var0 bind(1, 0) : !spv.ptr<f32, Input>
spv.globalVariable @var1 bind(0, 1) : !spv.ptr<f32, Output> spv.globalVariable @var1 bind(0, 1) : !spv.ptr<f32, Output>
spv.globalVariable @var2 {built_in = "GlobalInvocationId"} : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @var2 {built_in = "GlobalInvocationId"} : !spv.ptr<vector<3xi32>, Input>
spv.globalVariable @var3 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input> spv.globalVariable @var3 built_in("GlobalInvocationId") : !spv.ptr<vector<3xi32>, Input>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: spv.globalVariable @var1 : !spv.ptr<f32, Input> // CHECK: spv.globalVariable @var1 : !spv.ptr<f32, Input>
// CHECK-NEXT: spv.globalVariable @var2 initializer(@var1) bind(1, 0) : !spv.ptr<f32, Input> // CHECK-NEXT: spv.globalVariable @var2 initializer(@var1) bind(1, 0) : !spv.ptr<f32, Input>
spv.globalVariable @var1 : !spv.ptr<f32, Input> spv.globalVariable @var1 : !spv.ptr<f32, Input>
spv.globalVariable @var2 initializer(@var1) bind(1, 0) : !spv.ptr<f32, Input> spv.globalVariable @var2 initializer(@var1) bind(1, 0) : !spv.ptr<f32, Input>
} }
// ----- // -----
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/glsl-ops.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/glsl-ops.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.func @fmul(%arg0 : f32, %arg1 : f32) "None" { spv.func @fmul(%arg0 : f32, %arg1 : f32) "None" {
// CHECK: {{%.*}} = spv.GLSL.Exp {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Exp {{%.*}} : f32
%0 = spv.GLSL.Exp %arg0 : f32 %0 = spv.GLSL.Exp %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.FMax {{%.*}}, {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.FMax {{%.*}}, {{%.*}} : f32
%1 = spv.GLSL.FMax %arg0, %arg1 : f32 %1 = spv.GLSL.FMax %arg0, %arg1 : f32
// CHECK: {{%.*}} = spv.GLSL.Sqrt {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Sqrt {{%.*}} : f32
%2 = spv.GLSL.Sqrt %arg0 : f32 %2 = spv.GLSL.Sqrt %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Cos {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Cos {{%.*}} : f32
%3 = spv.GLSL.Cos %arg0 : f32 %3 = spv.GLSL.Cos %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Sin {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Sin {{%.*}} : f32
%4 = spv.GLSL.Sin %arg0 : f32 %4 = spv.GLSL.Sin %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Tan {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Tan {{%.*}} : f32
%5 = spv.GLSL.Tan %arg0 : f32 %5 = spv.GLSL.Tan %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Acos {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Acos {{%.*}} : f32
%6 = spv.GLSL.Acos %arg0 : f32 %6 = spv.GLSL.Acos %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Asin {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Asin {{%.*}} : f32
%7 = spv.GLSL.Asin %arg0 : f32 %7 = spv.GLSL.Asin %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Atan {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Atan {{%.*}} : f32
%8 = spv.GLSL.Atan %arg0 : f32 %8 = spv.GLSL.Atan %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Sinh {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Sinh {{%.*}} : f32
%9 = spv.GLSL.Sinh %arg0 : f32 %9 = spv.GLSL.Sinh %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Cosh {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Cosh {{%.*}} : f32
%10 = spv.GLSL.Cosh %arg0 : f32 %10 = spv.GLSL.Cosh %arg0 : f32
// CHECK: {{%.*}} = spv.GLSL.Pow {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Pow {{%.*}} : f32
%11 = spv.GLSL.Pow %arg0, %arg1 : f32 %11 = spv.GLSL.Pow %arg0, %arg1 : f32
// CHECK: {{%.*}} = spv.GLSL.Round {{%.*}} : f32 // CHECK: {{%.*}} = spv.GLSL.Round {{%.*}} : f32
%12 = spv.GLSL.Round %arg0 : f32 %12 = spv.GLSL.Round %arg0 : f32
spv.Return spv.Return
} }
spv.func @fclamp(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" { spv.func @fclamp(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" {
// CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32 // CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
%13 = spv.GLSL.FClamp %arg0, %arg1, %arg2 : f32 %13 = spv.GLSL.FClamp %arg0, %arg1, %arg2 : f32
spv.Return spv.Return
} }
spv.func @uclamp(%arg0 : ui32, %arg1 : ui32, %arg2 : ui32) "None" { spv.func @uclamp(%arg0 : ui32, %arg1 : ui32, %arg2 : ui32) "None" {
// CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : i32 // CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : i32
%13 = spv.GLSL.UClamp %arg0, %arg1, %arg2 : ui32 %13 = spv.GLSL.UClamp %arg0, %arg1, %arg2 : ui32
spv.Return spv.Return
} }
spv.func @sclamp(%arg0 : si32, %arg1 : si32, %arg2 : si32) "None" { spv.func @sclamp(%arg0 : si32, %arg1 : si32, %arg2 : si32) "None" {
// CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32 // CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
%13 = spv.GLSL.SClamp %arg0, %arg1, %arg2 : si32 %13 = spv.GLSL.SClamp %arg0, %arg1, %arg2 : si32
spv.Return spv.Return
} }
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/group-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: @subgroup_ballot // CHECK-LABEL: @subgroup_ballot
spv.func @subgroup_ballot(%predicate: i1) -> vector<4xi32> "None" { spv.func @subgroup_ballot(%predicate: i1) -> vector<4xi32> "None" {
// CHECK: %{{.*}} = spv.SubgroupBallotKHR %{{.*}}: vector<4xi32> // CHECK: %{{.*}} = spv.SubgroupBallotKHR %{{.*}}: vector<4xi32>
%0 = spv.SubgroupBallotKHR %predicate: vector<4xi32> %0 = spv.SubgroupBallotKHR %predicate: vector<4xi32>
spv.ReturnValue %0: vector<4xi32> spv.ReturnValue %0: vector<4xi32>
} }
// CHECK-LABEL: @group_broadcast_1 // CHECK-LABEL: @group_broadcast_1
spv.func @group_broadcast_1(%value: f32, %localid: i32 ) -> f32 "None" { spv.func @group_broadcast_1(%value: f32, %localid: i32 ) -> f32 "None" {
// CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, i32 // CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, i32
%0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, i32 %0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, i32
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @group_broadcast_2 // CHECK-LABEL: @group_broadcast_2
spv.func @group_broadcast_2(%value: f32, %localid: vector<3xi32> ) -> f32 "None" { spv.func @group_broadcast_2(%value: f32, %localid: vector<3xi32> ) -> f32 "None" {
// CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, vector<3xi32> // CHECK: spv.GroupBroadcast "Workgroup" %{{.*}}, %{{.*}} : f32, vector<3xi32>
%0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, vector<3xi32> %0 = spv.GroupBroadcast "Workgroup" %value, %localid : f32, vector<3xi32>
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @subgroup_block_read_intel // CHECK-LABEL: @subgroup_block_read_intel
spv.func @subgroup_block_read_intel(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 "None" { spv.func @subgroup_block_read_intel(%ptr : !spv.ptr<i32, StorageBuffer>) -> i32 "None" {
// CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : i32 // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : i32
%0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32 %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
// CHECK-LABEL: @subgroup_block_read_intel_vector // CHECK-LABEL: @subgroup_block_read_intel_vector
spv.func @subgroup_block_read_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>) -> vector<3xi32> "None" { spv.func @subgroup_block_read_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>) -> vector<3xi32> "None" {
// CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : vector<3xi32> // CHECK: spv.SubgroupBlockReadINTEL %{{.*}} : vector<3xi32>
%0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : vector<3xi32> %0 = spv.SubgroupBlockReadINTEL "StorageBuffer" %ptr : vector<3xi32>
spv.ReturnValue %0: vector<3xi32> spv.ReturnValue %0: vector<3xi32>
} }
// CHECK-LABEL: @subgroup_block_write_intel // CHECK-LABEL: @subgroup_block_write_intel
spv.func @subgroup_block_write_intel(%ptr : !spv.ptr<i32, StorageBuffer>, %value: i32) -> () "None" { spv.func @subgroup_block_write_intel(%ptr : !spv.ptr<i32, StorageBuffer>, %value: i32) -> () "None" {
// CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : i32 // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : i32
spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32 spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : i32
spv.Return spv.Return
} }
// CHECK-LABEL: @subgroup_block_write_intel_vector // CHECK-LABEL: @subgroup_block_write_intel_vector
spv.func @subgroup_block_write_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>, %value: vector<3xi32>) -> () "None" { spv.func @subgroup_block_write_intel_vector(%ptr : !spv.ptr<i32, StorageBuffer>, %value: vector<3xi32>) -> () "None" {
// CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : vector<3xi32> // CHECK: spv.SubgroupBlockWriteINTEL %{{.*}}, %{{.*}} : vector<3xi32>
spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : vector<3xi32> spv.SubgroupBlockWriteINTEL "StorageBuffer" %ptr, %value : vector<3xi32>
spv.Return spv.Return
} }
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/logical-ops.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
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @iequal_scalar(%arg0: i32, %arg1: i32) "None" { spv.func @iequal_scalar(%arg0: i32, %arg1: i32) "None" {
// CHECK: {{.*}} = spv.IEqual {{.*}}, {{.*}} : i32 // CHECK: {{.*}} = spv.IEqual {{.*}}, {{.*}} : i32
%0 = spv.IEqual %arg0, %arg1 : i32 %0 = spv.IEqual %arg0, %arg1 : i32
spv.Return spv.Return
} }
spv.func @inotequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @inotequal_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.INotEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.INotEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.INotEqual %arg0, %arg1 : vector<4xi32> %0 = spv.INotEqual %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @sgt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @sgt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.SGreaterThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.SGreaterThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SGreaterThan %arg0, %arg1 : vector<4xi32> %0 = spv.SGreaterThan %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @sge_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @sge_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.SGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.SGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.SGreaterThanEqual %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @slt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @slt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.SLessThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.SLessThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SLessThan %arg0, %arg1 : vector<4xi32> %0 = spv.SLessThan %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @slte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @slte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.SLessThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.SLessThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.SLessThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.SLessThanEqual %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @ugt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @ugt_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.UGreaterThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.UGreaterThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.UGreaterThan %arg0, %arg1 : vector<4xi32> %0 = spv.UGreaterThan %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @ugte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @ugte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.UGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.UGreaterThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.UGreaterThanEqual %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @ult_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @ult_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.ULessThan {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.ULessThan {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.ULessThan %arg0, %arg1 : vector<4xi32> %0 = spv.ULessThan %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @ulte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" { spv.func @ulte_vector(%arg0: vector<4xi32>, %arg1: vector<4xi32>) "None" {
// CHECK: {{.*}} = spv.ULessThanEqual {{.*}}, {{.*}} : vector<4xi32> // CHECK: {{.*}} = spv.ULessThanEqual {{.*}}, {{.*}} : vector<4xi32>
%0 = spv.ULessThanEqual %arg0, %arg1 : vector<4xi32> %0 = spv.ULessThanEqual %arg0, %arg1 : vector<4xi32>
spv.Return spv.Return
} }
spv.func @cmpf(%arg0 : f32, %arg1 : f32) "None" { spv.func @cmpf(%arg0 : f32, %arg1 : f32) "None" {
// CHECK: spv.FOrdEqual // CHECK: spv.FOrdEqual
%1 = spv.FOrdEqual %arg0, %arg1 : f32 %1 = spv.FOrdEqual %arg0, %arg1 : f32
// CHECK: spv.FOrdGreaterThan // CHECK: spv.FOrdGreaterThan
%2 = spv.FOrdGreaterThan %arg0, %arg1 : f32 %2 = spv.FOrdGreaterThan %arg0, %arg1 : f32
// CHECK: spv.FOrdGreaterThanEqual // CHECK: spv.FOrdGreaterThanEqual
%3 = spv.FOrdGreaterThanEqual %arg0, %arg1 : f32 %3 = spv.FOrdGreaterThanEqual %arg0, %arg1 : f32
// CHECK: spv.FOrdLessThan // CHECK: spv.FOrdLessThan
%4 = spv.FOrdLessThan %arg0, %arg1 : f32 %4 = spv.FOrdLessThan %arg0, %arg1 : f32
// CHECK: spv.FOrdLessThanEqual // CHECK: spv.FOrdLessThanEqual
%5 = spv.FOrdLessThanEqual %arg0, %arg1 : f32 %5 = spv.FOrdLessThanEqual %arg0, %arg1 : f32
// CHECK: spv.FOrdNotEqual // CHECK: spv.FOrdNotEqual
%6 = spv.FOrdNotEqual %arg0, %arg1 : f32 %6 = spv.FOrdNotEqual %arg0, %arg1 : f32
// CHECK: spv.FUnordEqual // CHECK: spv.FUnordEqual
%7 = spv.FUnordEqual %arg0, %arg1 : f32 %7 = spv.FUnordEqual %arg0, %arg1 : f32
// CHECK: spv.FUnordGreaterThan // CHECK: spv.FUnordGreaterThan
%8 = spv.FUnordGreaterThan %arg0, %arg1 : f32 %8 = spv.FUnordGreaterThan %arg0, %arg1 : f32
// CHECK: spv.FUnordGreaterThanEqual // CHECK: spv.FUnordGreaterThanEqual
%9 = spv.FUnordGreaterThanEqual %arg0, %arg1 : f32 %9 = spv.FUnordGreaterThanEqual %arg0, %arg1 : f32
// CHECK: spv.FUnordLessThan // CHECK: spv.FUnordLessThan
%10 = spv.FUnordLessThan %arg0, %arg1 : f32 %10 = spv.FUnordLessThan %arg0, %arg1 : f32
// CHECK: spv.FUnordLessThanEqual // CHECK: spv.FUnordLessThanEqual
%11 = spv.FUnordLessThanEqual %arg0, %arg1 : f32 %11 = spv.FUnordLessThanEqual %arg0, %arg1 : f32
// CHECK: spv.FUnordNotEqual // CHECK: spv.FUnordNotEqual
%12 = spv.FUnordNotEqual %arg0, %arg1 : f32 %12 = spv.FUnordNotEqual %arg0, %arg1 : f32
spv.Return spv.Return
} }
} }
// ----- // -----
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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/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
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
^header: ^header:
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
%val0 = spv.Load "Function" %var : i32 %val0 = spv.Load "Function" %var : i32
// CHECK-NEXT: spv.SLessThan // CHECK-NEXT: spv.SLessThan
%cmp = spv.SLessThan %val0, %count : i32 %cmp = spv.SLessThan %val0, %count : i32
// CHECK-NEXT: spv.BranchConditional %{{.*}} [1, 1], ^bb2, ^bb4 // CHECK-NEXT: spv.BranchConditional %{{.*}} [1, 1], ^bb2, ^bb4
spv.BranchConditional %cmp [1, 1], ^body, ^merge spv.BranchConditional %cmp [1, 1], ^body, ^merge
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^body: ^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:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
} }
// ----- // -----
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):
%10 = spv.SLessThan %9, %7 : i32 %10 = spv.SLessThan %9, %7 : i32
// CHECK: spv.BranchConditional %{{.*}}, ^bb2, ^bb3 // CHECK: spv.BranchConditional %{{.*}}, ^bb2, ^bb3
spv.BranchConditional %10, ^body, ^merge spv.BranchConditional %10, ^body, ^merge
// CHECK-NEXT: ^bb2: // pred: ^bb1 // CHECK-NEXT: ^bb2: // pred: ^bb1
^body: ^body:
%11 = spv.AccessChain %2[%9] : !spv.ptr<!spv.array<10 x f32, stride=4>, StorageBuffer>, i32 %11 = spv.AccessChain %2[%9] : !spv.ptr<!spv.array<10 x f32, stride=4>, StorageBuffer>, i32
%12 = spv.Load "StorageBuffer" %11 : f32 %12 = spv.Load "StorageBuffer" %11 : f32
%13 = spv.AccessChain %5[%9] : !spv.ptr<!spv.array<10 x f32, stride=4>, StorageBuffer>, i32 %13 = spv.AccessChain %5[%9] : !spv.ptr<!spv.array<10 x f32, stride=4>, StorageBuffer>, i32
spv.Store "StorageBuffer" %13, %12 : f32 spv.Store "StorageBuffer" %13, %12 : f32
// CHECK: %[[ADD:.*]] = spv.IAdd // CHECK: %[[ADD:.*]] = spv.IAdd
%14 = spv.IAdd %9, %8 : i32 %14 = spv.IAdd %9, %8 : i32
// CHECK-NEXT: spv.Branch ^bb1(%[[ADD]] : i32) // CHECK-NEXT: spv.Branch ^bb1(%[[ADD]] : i32)
spv.Branch ^header(%14 : i32) spv.Branch ^header(%14 : i32)
// CHECK-NEXT: ^bb3: // CHECK-NEXT: ^bb3:
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @loop_kernel spv.EntryPoint "GLCompute" @loop_kernel
spv.ExecutionMode @loop_kernel "LocalSize", 1, 1, 1 spv.ExecutionMode @loop_kernel "LocalSize", 1, 1, 1
} }
// ----- // -----
// 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
// CHECK-NEXT: ^bb1: // CHECK-NEXT: ^bb1:
^header: ^header:
// CHECK-NEXT: spv.Load // CHECK-NEXT: spv.Load
%jval0 = spv.Load "Function" %jvar : i32 %jval0 = spv.Load "Function" %jvar : i32
// CHECK-NEXT: spv.SLessThan // CHECK-NEXT: spv.SLessThan
%jcmp = spv.SLessThan %jval0, %count : i32 %jcmp = spv.SLessThan %jval0, %count : i32
// CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb2, ^bb4 // CHECK-NEXT: spv.BranchConditional %{{.*}}, ^bb2, ^bb4
spv.BranchConditional %jcmp, ^body, ^merge spv.BranchConditional %jcmp, ^body, ^merge
// CHECK-NEXT: ^bb2: // CHECK-NEXT: ^bb2:
^body: ^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
%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:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
^merge: ^merge:
spv.mlir.merge spv.mlir.merge
} // end outer loop } // end outer loop
spv.Return spv.Return
} }
spv.func @main() -> () "None" { spv.func @main() -> () "None" {
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @main spv.EntryPoint "GLCompute" @main
} }

mlir/test/Target/SPIRV/matrix.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/matrix.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
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK-LABEL: @matrix_access_chain // CHECK-LABEL: @matrix_access_chain
spv.func @matrix_access_chain(%arg0 : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, Function>, %arg1 : i32) -> !spv.ptr<vector<3xf32>, Function> "None" { spv.func @matrix_access_chain(%arg0 : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, Function>, %arg1 : i32) -> !spv.ptr<vector<3xf32>, Function> "None" {
// CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, Function> // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, Function>
%0 = spv.AccessChain %arg0[%arg1] : !spv.ptr<!spv.matrix<3 x vector<3xf32>>,Function>, i32 %0 = spv.AccessChain %arg0[%arg1] : !spv.ptr<!spv.matrix<3 x vector<3xf32>>,Function>, i32
spv.ReturnValue %0 : !spv.ptr<vector<3xf32>, Function> spv.ReturnValue %0 : !spv.ptr<vector<3xf32>, Function>
} }
// CHECK-LABEL: @matrix_times_scalar_1 // CHECK-LABEL: @matrix_times_scalar_1
spv.func @matrix_times_scalar_1(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> !spv.matrix<3 x vector<3xf32>> "None" { spv.func @matrix_times_scalar_1(%arg0 : !spv.matrix<3 x vector<3xf32>>, %arg1 : f32) -> !spv.matrix<3 x vector<3xf32>> "None" {
// CHECK: {{%.*}} = spv.MatrixTimesScalar {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>> // CHECK: {{%.*}} = spv.MatrixTimesScalar {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>>
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, f32 -> !spv.matrix<3 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_times_scalar_2 // CHECK-LABEL: @matrix_times_scalar_2
spv.func @matrix_times_scalar_2(%arg0 : !spv.matrix<3 x vector<3xf16>>, %arg1 : f16) -> !spv.matrix<3 x vector<3xf16>> "None" { spv.func @matrix_times_scalar_2(%arg0 : !spv.matrix<3 x vector<3xf16>>, %arg1 : f16) -> !spv.matrix<3 x vector<3xf16>> "None" {
// CHECK: {{%.*}} = spv.MatrixTimesScalar {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf16>>, f16 -> !spv.matrix<3 x vector<3xf16>> // CHECK: {{%.*}} = spv.MatrixTimesScalar {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf16>>, f16 -> !spv.matrix<3 x vector<3xf16>>
%result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf16>>, f16 -> !spv.matrix<3 x vector<3xf16>> %result = spv.MatrixTimesScalar %arg0, %arg1 : !spv.matrix<3 x vector<3xf16>>, f16 -> !spv.matrix<3 x vector<3xf16>>
spv.ReturnValue %result : !spv.matrix<3 x vector<3xf16>> spv.ReturnValue %result : !spv.matrix<3 x vector<3xf16>>
} }
// CHECK-LABEL: @matrix_transpose_1 // CHECK-LABEL: @matrix_transpose_1
spv.func @matrix_transpose_1(%arg0 : !spv.matrix<3 x vector<2xf32>>) -> !spv.matrix<2 x vector<3xf32>> "None" { spv.func @matrix_transpose_1(%arg0 : !spv.matrix<3 x vector<2xf32>>) -> !spv.matrix<2 x vector<3xf32>> "None" {
// CHECK: {{%.*}} = spv.Transpose {{%.*}} : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>> // CHECK: {{%.*}} = spv.Transpose {{%.*}} : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>>
%result = spv.Transpose %arg0 : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>> %result = spv.Transpose %arg0 : !spv.matrix<3 x vector<2xf32>> -> !spv.matrix<2 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<2 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<2 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_times_matrix_1 // CHECK-LABEL: @matrix_times_matrix_1
spv.func @matrix_times_matrix_1(%arg0: !spv.matrix<3 x vector<3xf32>>, %arg1: !spv.matrix<3 x vector<3xf32>>) -> !spv.matrix<3 x vector<3xf32>> "None"{ spv.func @matrix_times_matrix_1(%arg0: !spv.matrix<3 x vector<3xf32>>, %arg1: !spv.matrix<3 x vector<3xf32>>) -> !spv.matrix<3 x vector<3xf32>> "None"{
// CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> // CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<3xf32>>, !spv.matrix<3 x vector<3xf32>> -> !spv.matrix<3 x vector<3xf32>>
spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>> spv.ReturnValue %result : !spv.matrix<3 x vector<3xf32>>
} }
// CHECK-LABEL: @matrix_times_matrix_2 // CHECK-LABEL: @matrix_times_matrix_2
spv.func @matrix_times_matrix_2(%arg0: !spv.matrix<3 x vector<2xf32>>, %arg1: !spv.matrix<2 x vector<3xf32>>) -> !spv.matrix<2 x vector<2xf32>> "None"{ spv.func @matrix_times_matrix_2(%arg0: !spv.matrix<3 x vector<2xf32>>, %arg1: !spv.matrix<2 x vector<3xf32>>) -> !spv.matrix<2 x vector<2xf32>> "None"{
// CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>> // CHECK: {{%.*}} = spv.MatrixTimesMatrix {{%.*}}, {{%.*}} : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>>
%result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>> %result = spv.MatrixTimesMatrix %arg0, %arg1 : !spv.matrix<3 x vector<2xf32>>, !spv.matrix<2 x vector<3xf32>> -> !spv.matrix<2 x vector<2xf32>>
spv.ReturnValue %result : !spv.matrix<2 x vector<2xf32>> spv.ReturnValue %result : !spv.matrix<2 x vector<2xf32>>
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, StorageBuffer> // CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, StorageBuffer>
spv.globalVariable @var0 : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, StorageBuffer> spv.globalVariable @var0 : !spv.ptr<!spv.matrix<3 x vector<3xf32>>, StorageBuffer>
// CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.matrix<2 x vector<3xf32>>, StorageBuffer> // CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.matrix<2 x vector<3xf32>>, StorageBuffer>
spv.globalVariable @var1 : !spv.ptr<!spv.matrix<2 x vector<3xf32>>, StorageBuffer> spv.globalVariable @var1 : !spv.ptr<!spv.matrix<2 x vector<3xf32>>, StorageBuffer>
// CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.matrix<4 x vector<4xf16>>, StorageBuffer> // CHECK: spv.globalVariable {{@.*}} : !spv.ptr<!spv.matrix<4 x vector<4xf16>>, StorageBuffer>
spv.globalVariable @var2 : !spv.ptr<!spv.matrix<4 x vector<4xf16>>, StorageBuffer> spv.globalVariable @var2 : !spv.ptr<!spv.matrix<4 x vector<4xf16>>, StorageBuffer>
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/memory-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
// CHECK: spv.func {{@.*}}([[ARG1:%.*]]: !spv.ptr<f32, Input>, [[ARG2:%.*]]: !spv.ptr<f32, Output>) "None" { // CHECK: spv.func {{@.*}}([[ARG1:%.*]]: !spv.ptr<f32, Input>, [[ARG2:%.*]]: !spv.ptr<f32, Output>) "None" {
// CHECK-NEXT: [[VALUE:%.*]] = spv.Load "Input" [[ARG1]] : f32 // CHECK-NEXT: [[VALUE:%.*]] = spv.Load "Input" [[ARG1]] : f32
// CHECK-NEXT: spv.Store "Output" [[ARG2]], [[VALUE]] : f32 // CHECK-NEXT: spv.Store "Output" [[ARG2]], [[VALUE]] : f32
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @load_store(%arg0 : !spv.ptr<f32, Input>, %arg1 : !spv.ptr<f32, Output>) "None" { spv.func @load_store(%arg0 : !spv.ptr<f32, Input>, %arg1 : !spv.ptr<f32, Output>) "None" {
%1 = spv.Load "Input" %arg0 : f32 %1 = spv.Load "Input" %arg0 : f32
spv.Store "Output" %arg1, %1 : f32 spv.Store "Output" %arg1, %1 : f32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @access_chain(%arg0 : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, %arg1 : i32, %arg2 : i32) "None" { spv.func @access_chain(%arg0 : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, %arg1 : i32, %arg2 : i32) "None" {
// CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function> // CHECK: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function>
// CHECK-NEXT: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function> // CHECK-NEXT: {{%.*}} = spv.AccessChain {{%.*}}[{{%.*}}, {{%.*}}] : !spv.ptr<!spv.array<4 x !spv.array<4 x f32>>, Function>
%1 = spv.AccessChain %arg0[%arg1] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32 %1 = spv.AccessChain %arg0[%arg1] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32
%2 = spv.AccessChain %arg0[%arg1, %arg2] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, i32 %2 = spv.AccessChain %arg0[%arg1, %arg2] : !spv.ptr<!spv.array<4x!spv.array<4xf32>>, Function>, i32, 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], []> {
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
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @copy_memory_simple() "None" { spv.func @copy_memory_simple() "None" {
%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.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} : f32
spv.CopyMemory "Function" %0, "Function" %1 : f32 spv.CopyMemory "Function" %0, "Function" %1 : f32
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @copy_memory_different_storage_classes(%in : !spv.ptr<!spv.array<4xf32>, Input>, %out : !spv.ptr<!spv.array<4xf32>, Output>) "None" { spv.func @copy_memory_different_storage_classes(%in : !spv.ptr<!spv.array<4xf32>, Input>, %out : !spv.ptr<!spv.array<4xf32>, Output>) "None" {
// CHECK: spv.CopyMemory "Output" %{{.*}}, "Input" %{{.*}} : !spv.array<4 x f32> // CHECK: spv.CopyMemory "Output" %{{.*}}, "Input" %{{.*}} : !spv.array<4 x f32>
spv.CopyMemory "Output" %out, "Input" %in : !spv.array<4xf32> spv.CopyMemory "Output" %out, "Input" %in : !spv.array<4xf32>
spv.Return spv.Return
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @copy_memory_with_access_operands() "None" { spv.func @copy_memory_with_access_operands() "None" {
%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.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4] : f32
spv.CopyMemory "Function" %0, "Function" %1 ["Aligned", 4] : f32 spv.CopyMemory "Function" %0, "Function" %1 ["Aligned", 4] : f32
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"] : f32
spv.CopyMemory "Function" %0, "Function" %1 ["Volatile"] : f32 spv.CopyMemory "Function" %0, "Function" %1 ["Volatile"] : f32
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"], ["Volatile"] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"], ["Volatile"] : f32
spv.CopyMemory "Function" %0, "Function" %1 ["Volatile"], ["Volatile"] : f32 spv.CopyMemory "Function" %0, "Function" %1 ["Volatile"], ["Volatile"] : f32
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4], ["Volatile"] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 4], ["Volatile"] : f32
spv.CopyMemory "Function" %0, "Function" %1 ["Aligned", 4], ["Volatile"] : f32 spv.CopyMemory "Function" %0, "Function" %1 ["Aligned", 4], ["Volatile"] : f32
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"], ["Aligned", 4] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Volatile"], ["Aligned", 4] : f32
spv.CopyMemory "Function" %0, "Function" %1 ["Volatile"], ["Aligned", 4] : f32 spv.CopyMemory "Function" %0, "Function" %1 ["Volatile"], ["Aligned", 4] : f32
// CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 8], ["Aligned", 4] : f32 // CHECK: spv.CopyMemory "Function" %{{.*}}, "Function" %{{.*}} ["Aligned", 8], ["Aligned", 4] : f32
spv.CopyMemory "Function" %0, "Function" %1 ["Aligned", 8], ["Aligned", 4] : f32 spv.CopyMemory "Function" %0, "Function" %1 ["Aligned", 8], ["Aligned", 4] : f32
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/module.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/module.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
// CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { // CHECK: spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK-NEXT: spv.func @foo() "Inline" { // CHECK-NEXT: spv.func @foo() "Inline" {
// CHECK-NEXT: spv.Return // CHECK-NEXT: spv.Return
// CHECK-NEXT: } // CHECK-NEXT: }
// CHECK-NEXT: } // CHECK-NEXT: }
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.func @foo() -> () "Inline" { spv.func @foo() -> () "Inline" {
spv.Return spv.Return
} }
} }
// ----- // -----
// CHECK: v1.5 // CHECK: v1.5
spv.module Logical GLSL450 requires #spv.vce<v1.5, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.5, [Shader], []> {
} }
// ----- // -----
// CHECK: [Shader, Float16] // CHECK: [Shader, Float16]
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader, Float16], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader, Float16], []> {
} }
// ----- // -----
// CHECK: [SPV_KHR_float_controls, SPV_KHR_subgroup_vote] // CHECK: [SPV_KHR_float_controls, SPV_KHR_subgroup_vote]
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_float_controls, SPV_KHR_subgroup_vote]> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], [SPV_KHR_float_controls, SPV_KHR_subgroup_vote]> {
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/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
%0 = spv.GroupNonUniformElect "Workgroup" : i1 %0 = spv.GroupNonUniformElect "Workgroup" : i1
spv.ReturnValue %0: i1 spv.ReturnValue %0: i1
} }
// CHECK-LABEL: @group_non_uniform_fadd_reduce // CHECK-LABEL: @group_non_uniform_fadd_reduce
spv.func @group_non_uniform_fadd_reduce(%val: f32) -> f32 "None" { spv.func @group_non_uniform_fadd_reduce(%val: f32) -> f32 "None" {
// 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
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @group_non_uniform_fmax_reduce // CHECK-LABEL: @group_non_uniform_fmax_reduce
spv.func @group_non_uniform_fmax_reduce(%val: f32) -> f32 "None" { spv.func @group_non_uniform_fmax_reduce(%val: f32) -> f32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformFMax "Workgroup" "Reduce" %{{.+}} : f32 // CHECK: %{{.+}} = spv.GroupNonUniformFMax "Workgroup" "Reduce" %{{.+}} : f32
%0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFMax "Workgroup" "Reduce" %val : f32
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @group_non_uniform_fmin_reduce // CHECK-LABEL: @group_non_uniform_fmin_reduce
spv.func @group_non_uniform_fmin_reduce(%val: f32) -> f32 "None" { spv.func @group_non_uniform_fmin_reduce(%val: f32) -> f32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformFMin "Workgroup" "Reduce" %{{.+}} : f32 // CHECK: %{{.+}} = spv.GroupNonUniformFMin "Workgroup" "Reduce" %{{.+}} : f32
%0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %val : f32 %0 = spv.GroupNonUniformFMin "Workgroup" "Reduce" %val : f32
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @group_non_uniform_fmul_reduce // CHECK-LABEL: @group_non_uniform_fmul_reduce
spv.func @group_non_uniform_fmul_reduce(%val: f32) -> f32 "None" { spv.func @group_non_uniform_fmul_reduce(%val: f32) -> f32 "None" {
// 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
spv.ReturnValue %0: f32 spv.ReturnValue %0: f32
} }
// CHECK-LABEL: @group_non_uniform_iadd_reduce // CHECK-LABEL: @group_non_uniform_iadd_reduce
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
%0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformIMul "Workgroup" "Reduce" %val : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
// CHECK-LABEL: @group_non_uniform_smax_reduce // CHECK-LABEL: @group_non_uniform_smax_reduce
spv.func @group_non_uniform_smax_reduce(%val: i32) -> i32 "None" { spv.func @group_non_uniform_smax_reduce(%val: i32) -> i32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformSMax "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformSMax "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformSMax "Workgroup" "Reduce" %val : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
// CHECK-LABEL: @group_non_uniform_smin_reduce // CHECK-LABEL: @group_non_uniform_smin_reduce
spv.func @group_non_uniform_smin_reduce(%val: i32) -> i32 "None" { spv.func @group_non_uniform_smin_reduce(%val: i32) -> i32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformSMin "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformSMin "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformSMin "Workgroup" "Reduce" %val : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
// CHECK-LABEL: @group_non_uniform_umax_reduce // CHECK-LABEL: @group_non_uniform_umax_reduce
spv.func @group_non_uniform_umax_reduce(%val: i32) -> i32 "None" { spv.func @group_non_uniform_umax_reduce(%val: i32) -> i32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformUMax "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformUMax "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformUMax "Workgroup" "Reduce" %val : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
// CHECK-LABEL: @group_non_uniform_umin_reduce // CHECK-LABEL: @group_non_uniform_umin_reduce
spv.func @group_non_uniform_umin_reduce(%val: i32) -> i32 "None" { spv.func @group_non_uniform_umin_reduce(%val: i32) -> i32 "None" {
// CHECK: %{{.+}} = spv.GroupNonUniformUMin "Workgroup" "Reduce" %{{.+}} : i32 // CHECK: %{{.+}} = spv.GroupNonUniformUMin "Workgroup" "Reduce" %{{.+}} : i32
%0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %val : i32 %0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %val : i32
spv.ReturnValue %0: i32 spv.ReturnValue %0: i32
} }
} }

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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/ocl-ops.mlir.
// RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s // RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
spv.module Physical64 OpenCL requires #spv.vce<v1.0, [Kernel, Addresses], []> { spv.module Physical64 OpenCL requires #spv.vce<v1.0, [Kernel, Addresses], []> {
spv.func @float_insts(%arg0 : f32) "None" { spv.func @float_insts(%arg0 : f32) "None" {
// CHECK: {{%.*}} = spv.OCL.exp {{%.*}} : f32 // CHECK: {{%.*}} = spv.OCL.exp {{%.*}} : f32
%0 = spv.OCL.exp %arg0 : f32 %0 = spv.OCL.exp %arg0 : f32
// CHECK: {{%.*}} = spv.OCL.fabs {{%.*}} : f32 // CHECK: {{%.*}} = spv.OCL.fabs {{%.*}} : f32
%1 = spv.OCL.fabs %arg0 : f32 %1 = spv.OCL.fabs %arg0 : f32
spv.Return spv.Return
} }
spv.func @integer_insts(%arg0 : i32) "None" { spv.func @integer_insts(%arg0 : i32) "None" {
// CHECK: {{%.*}} = spv.OCL.s_abs {{%.*}} : i32 // CHECK: {{%.*}} = spv.OCL.s_abs {{%.*}} : i32
%0 = spv.OCL.s_abs %arg0 : i32 %0 = spv.OCL.s_abs %arg0 : i32
spv.Return spv.Return
} }
spv.func @vector_size16(%arg0 : vector<16xf32>) "None" { spv.func @vector_size16(%arg0 : vector<16xf32>) "None" {
// CHECK: {{%.*}} = spv.OCL.fabs {{%.*}} : vector<16xf32> // CHECK: {{%.*}} = spv.OCL.fabs {{%.*}} : vector<16xf32>
%0 = spv.OCL.fabs %arg0 : vector<16xf32> %0 = spv.OCL.fabs %arg0 : vector<16xf32>
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/phi.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/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
spv.Return spv.Return
// CHECK-NEXT: ^bb4: // CHECK-NEXT: ^bb4:
^merge: ^merge:
// CHECK-NEXT: spv.mlir.merge // CHECK-NEXT: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
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 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>
%20 = spv.CompositeExtract %19[0 : i32] : vector<3xi32> %20 = spv.CompositeExtract %19[0 : i32] : vector<3xi32>
%21 = spv.mlir.addressof @__builtin_var_NumWorkgroups__ : !spv.ptr<vector<3xi32>, Input> %21 = spv.mlir.addressof @__builtin_var_NumWorkgroups__ : !spv.ptr<vector<3xi32>, Input>
%22 = spv.Load "Input" %21 : vector<3xi32> %22 = spv.Load "Input" %21 : vector<3xi32>
%23 = spv.CompositeExtract %22[1 : i32] : vector<3xi32> %23 = spv.CompositeExtract %22[1 : i32] : vector<3xi32>
%30 = spv.IMul %11, %4 : i32 %30 = spv.IMul %11, %4 : i32
%31 = spv.IMul %23, %4 : i32 %31 = spv.IMul %23, %4 : i32
// CHECK: spv.Branch ^[[FN_BB:.*]](%{{.*}} : i32) // CHECK: spv.Branch ^[[FN_BB:.*]](%{{.*}} : i32)
// CHECK: ^[[FN_BB]](%[[FN_BB_ARG:.*]]: i32): // CHECK: ^[[FN_BB]](%[[FN_BB_ARG:.*]]: i32):
// CHECK: spv.loop { // CHECK: spv.loop {
spv.loop { spv.loop {
// CHECK: spv.Branch ^bb1(%[[FN_BB_ARG]] : i32) // CHECK: spv.Branch ^bb1(%[[FN_BB_ARG]] : i32)
spv.Branch ^bb1(%30 : i32) spv.Branch ^bb1(%30 : i32)
// CHECK: ^[[LP1_HDR:.*]](%[[LP1_HDR_ARG:.*]]: i32): // CHECK: ^[[LP1_HDR:.*]](%[[LP1_HDR_ARG:.*]]: i32):
^bb1(%32: i32): ^bb1(%32: i32):
// CHECK: spv.SLessThan // CHECK: spv.SLessThan
%33 = spv.SLessThan %32, %3 : i32 %33 = spv.SLessThan %32, %3 : i32
// CHECK: spv.BranchConditional %{{.*}}, ^[[LP1_BDY:.*]], ^[[LP1_MG:.*]] // CHECK: spv.BranchConditional %{{.*}}, ^[[LP1_BDY:.*]], ^[[LP1_MG:.*]]
spv.BranchConditional %33, ^bb2, ^bb3 spv.BranchConditional %33, ^bb2, ^bb3
// CHECK: ^[[LP1_BDY]]: // CHECK: ^[[LP1_BDY]]:
^bb2: ^bb2:
// CHECK: %[[MUL:.*]] = spv.IMul // CHECK: %[[MUL:.*]] = spv.IMul
%34 = spv.IMul %8, %5 : i32 %34 = spv.IMul %8, %5 : i32
// CHECK: spv.IMul // CHECK: spv.IMul
%35 = spv.IMul %20, %5 : i32 %35 = spv.IMul %20, %5 : i32
// CHECK: spv.Branch ^[[LP1_CNT:.*]](%[[MUL]] : i32) // CHECK: spv.Branch ^[[LP1_CNT:.*]](%[[MUL]] : i32)
// CHECK: ^[[LP1_CNT]](%[[LP1_CNT_ARG:.*]]: i32): // CHECK: ^[[LP1_CNT]](%[[LP1_CNT_ARG:.*]]: i32):
// CHECK: spv.loop { // CHECK: spv.loop {
spv.loop { spv.loop {
// CHECK: spv.Branch ^[[LP2_HDR:.*]](%[[LP1_CNT_ARG]] : i32) // CHECK: spv.Branch ^[[LP2_HDR:.*]](%[[LP1_CNT_ARG]] : i32)
spv.Branch ^bb1(%34 : i32) spv.Branch ^bb1(%34 : i32)
// CHECK: ^[[LP2_HDR]](%[[LP2_HDR_ARG:.*]]: i32): // CHECK: ^[[LP2_HDR]](%[[LP2_HDR_ARG:.*]]: i32):
^bb1(%37: i32): ^bb1(%37: i32):
// CHECK: spv.SLessThan %[[LP2_HDR_ARG]] // CHECK: spv.SLessThan %[[LP2_HDR_ARG]]
%38 = spv.SLessThan %37, %5 : i32 %38 = spv.SLessThan %37, %5 : i32
// CHECK: spv.BranchConditional %{{.*}}, ^[[LP2_BDY:.*]], ^[[LP2_MG:.*]] // CHECK: spv.BranchConditional %{{.*}}, ^[[LP2_BDY:.*]], ^[[LP2_MG:.*]]
spv.BranchConditional %38, ^bb2, ^bb3 spv.BranchConditional %38, ^bb2, ^bb3
// CHECK: ^[[LP2_BDY]]: // CHECK: ^[[LP2_BDY]]:
^bb2: ^bb2:
// CHECK: %[[ADD1:.*]] = spv.IAdd // CHECK: %[[ADD1:.*]] = spv.IAdd
%48 = spv.IAdd %37, %35 : i32 %48 = spv.IAdd %37, %35 : i32
// CHECK: spv.Branch ^[[LP2_HDR]](%[[ADD1]] : i32) // CHECK: spv.Branch ^[[LP2_HDR]](%[[ADD1]] : i32)
spv.Branch ^bb1(%48 : i32) spv.Branch ^bb1(%48 : i32)
// CHECK: ^[[LP2_MG]]: // CHECK: ^[[LP2_MG]]:
^bb3: ^bb3:
// CHECK: spv.mlir.merge // CHECK: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
// CHECK: %[[ADD2:.*]] = spv.IAdd %[[LP1_HDR_ARG]] // CHECK: %[[ADD2:.*]] = spv.IAdd %[[LP1_HDR_ARG]]
%36 = spv.IAdd %32, %31 : i32 %36 = spv.IAdd %32, %31 : i32
// CHECK: spv.Branch ^[[LP1_HDR]](%[[ADD2]] : i32) // CHECK: spv.Branch ^[[LP1_HDR]](%[[ADD2]] : i32)
spv.Branch ^bb1(%36 : i32) spv.Branch ^bb1(%36 : i32)
// CHECK: ^[[LP1_MG]]: // CHECK: ^[[LP1_MG]]:
^bb3: ^bb3:
// CHECK: spv.mlir.merge // CHECK: spv.mlir.merge
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @fmul_kernel, @__builtin_var_WorkgroupId__, @__builtin_var_NumWorkgroups__ spv.EntryPoint "GLCompute" @fmul_kernel, @__builtin_var_WorkgroupId__, @__builtin_var_NumWorkgroups__
spv.ExecutionMode @fmul_kernel "LocalSize", 32, 1, 1 spv.ExecutionMode @fmul_kernel "LocalSize", 32, 1, 1
} }
// ----- // -----
// 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
^bb2: ^bb2:
%loop2_add = spv.IAdd %loop2_bb_arg, %cst4 : i32 %loop2_add = spv.IAdd %loop2_bb_arg, %cst4 : i32
spv.Branch ^bb1(%loop2_add : i32) spv.Branch ^bb1(%loop2_add : i32)
^bb3: ^bb3:
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
spv.EntryPoint "GLCompute" @fmul_kernel spv.EntryPoint "GLCompute" @fmul_kernel
spv.ExecutionMode @fmul_kernel "LocalSize", 32, 1, 1 spv.ExecutionMode @fmul_kernel "LocalSize", 32, 1, 1
} }

mlir/test/Target/SPIRV/selection.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/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
spv.mlir.merge spv.mlir.merge
} }
spv.Return spv.Return
} }
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
} }
// ----- // -----
// Selection with only then branch // Selection with only then branch
// Selection in function entry block // Selection in function entry block
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
// CHECK: spv.func @selection(%[[ARG:.*]]: i1 // CHECK: spv.func @selection(%[[ARG:.*]]: i1
spv.func @selection(%cond: i1) -> (i32) "None" { spv.func @selection(%cond: i1) -> (i32) "None" {
// CHECK: spv.Branch ^bb1 // CHECK: spv.Branch ^bb1
// 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

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/spec-constant.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: spv.specConstant @sc_true = true // CHECK: spv.specConstant @sc_true = true
spv.specConstant @sc_true = true spv.specConstant @sc_true = true
// CHECK: spv.specConstant @sc_false spec_id(1) = false // CHECK: spv.specConstant @sc_false spec_id(1) = false
spv.specConstant @sc_false spec_id(1) = false spv.specConstant @sc_false spec_id(1) = false
// CHECK: spv.specConstant @sc_int = -5 : i32 // CHECK: spv.specConstant @sc_int = -5 : i32
spv.specConstant @sc_int = -5 : i32 spv.specConstant @sc_int = -5 : i32
// CHECK: spv.specConstant @sc_float spec_id(5) = 1.000000e+00 : f32 // CHECK: spv.specConstant @sc_float spec_id(5) = 1.000000e+00 : f32
spv.specConstant @sc_float spec_id(5) = 1. : f32 spv.specConstant @sc_float spec_id(5) = 1. : f32
// CHECK: spv.specConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32> // CHECK: spv.specConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32>
spv.specConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32> spv.specConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32>
// CHECK-LABEL: @use // CHECK-LABEL: @use
spv.func @use() -> (i32) "None" { spv.func @use() -> (i32) "None" {
// We materialize a `spv.mlir.referenceof` op at every use of a // We materialize a `spv.mlir.referenceof` op at every use of a
// specialization constant in the deserializer. So two ops here. // specialization constant in the deserializer. So two ops here.
// CHECK: %[[USE1:.*]] = spv.mlir.referenceof @sc_int : i32 // CHECK: %[[USE1:.*]] = spv.mlir.referenceof @sc_int : i32
// CHECK: %[[USE2:.*]] = spv.mlir.referenceof @sc_int : i32 // CHECK: %[[USE2:.*]] = spv.mlir.referenceof @sc_int : i32
// CHECK: spv.IAdd %[[USE1]], %[[USE2]] // CHECK: spv.IAdd %[[USE1]], %[[USE2]]
%0 = spv.mlir.referenceof @sc_int : i32 %0 = spv.mlir.referenceof @sc_int : i32
%1 = spv.IAdd %0, %0 : i32 %1 = spv.IAdd %0, %0 : i32
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
// CHECK-LABEL: @use // CHECK-LABEL: @use
spv.func @use_composite() -> (i32) "None" { spv.func @use_composite() -> (i32) "None" {
// We materialize a `spv.mlir.referenceof` op at every use of a // We materialize a `spv.mlir.referenceof` op at every use of a
// specialization constant in the deserializer. So two ops here. // specialization constant in the deserializer. So two ops here.
// CHECK: %[[USE1:.*]] = spv.mlir.referenceof @scc : !spv.array<2 x i32> // CHECK: %[[USE1:.*]] = spv.mlir.referenceof @scc : !spv.array<2 x i32>
// CHECK: %[[ITM0:.*]] = spv.CompositeExtract %[[USE1]][0 : i32] : !spv.array<2 x i32> // CHECK: %[[ITM0:.*]] = spv.CompositeExtract %[[USE1]][0 : i32] : !spv.array<2 x i32>
// CHECK: %[[USE2:.*]] = spv.mlir.referenceof @scc : !spv.array<2 x i32> // CHECK: %[[USE2:.*]] = spv.mlir.referenceof @scc : !spv.array<2 x i32>
// CHECK: %[[ITM1:.*]] = spv.CompositeExtract %[[USE2]][1 : i32] : !spv.array<2 x i32> // CHECK: %[[ITM1:.*]] = spv.CompositeExtract %[[USE2]][1 : i32] : !spv.array<2 x i32>
// CHECK: spv.IAdd %[[ITM0]], %[[ITM1]] // CHECK: spv.IAdd %[[ITM0]], %[[ITM1]]
%0 = spv.mlir.referenceof @scc : !spv.array<2 x i32> %0 = spv.mlir.referenceof @scc : !spv.array<2 x i32>
%1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32> %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
%2 = spv.CompositeExtract %0[1 : i32] : !spv.array<2 x i32> %2 = spv.CompositeExtract %0[1 : i32] : !spv.array<2 x i32>
%3 = spv.IAdd %1, %2 : i32 %3 = spv.IAdd %1, %2 : i32
spv.ReturnValue %3 : i32 spv.ReturnValue %3 : i32
} }
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.specConstant @sc_f32_1 = 1.5 : f32 spv.specConstant @sc_f32_1 = 1.5 : f32
spv.specConstant @sc_f32_2 = 2.5 : f32 spv.specConstant @sc_f32_2 = 2.5 : f32
spv.specConstant @sc_f32_3 = 3.5 : f32 spv.specConstant @sc_f32_3 = 3.5 : f32
spv.specConstant @sc_i32_1 = 1 : i32 spv.specConstant @sc_i32_1 = 1 : i32
// CHECK: spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32> // CHECK: spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32> spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
// CHECK: spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)> // CHECK: spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)> spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
// CHECK: spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32> // CHECK: spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32>
spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32> spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32>
} }
// ----- // -----
spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> { spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
spv.specConstant @sc_f32_1 = 1.5 : f32 spv.specConstant @sc_f32_1 = 1.5 : f32
spv.specConstant @sc_f32_2 = 2.5 : f32 spv.specConstant @sc_f32_2 = 2.5 : f32
spv.specConstant @sc_f32_3 = 3.5 : f32 spv.specConstant @sc_f32_3 = 3.5 : f32
spv.specConstant @sc_i32_1 = 1 : i32 spv.specConstant @sc_i32_1 = 1 : i32
// CHECK: spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32> // CHECK: spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32> spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
// CHECK: spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)> // CHECK: spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)> spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
// CHECK: spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32> // CHECK: spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32>
spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32> spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32>
} }

mlir/test/Target/SPIRV/struct.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/struct.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: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input> // CHECK: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input>
spv.globalVariable @var0 bind(0, 1) : !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input> spv.globalVariable @var0 bind(0, 1) : !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input>
// CHECK: !spv.ptr<!spv.struct<(f32 [0], !spv.struct<(f32 [0], !spv.array<16 x f32, stride=4> [4])> [4])>, Input> // CHECK: !spv.ptr<!spv.struct<(f32 [0], !spv.struct<(f32 [0], !spv.array<16 x f32, stride=4> [4])> [4])>, Input>
spv.globalVariable @var1 bind(0, 2) : !spv.ptr<!spv.struct<(f32 [0], !spv.struct<(f32 [0], !spv.array<16 x f32, stride=4> [4])> [4])>, Input> spv.globalVariable @var1 bind(0, 2) : !spv.ptr<!spv.struct<(f32 [0], !spv.struct<(f32 [0], !spv.array<16 x f32, stride=4> [4])> [4])>, Input>
// CHECK: !spv.ptr<!spv.struct<(f32 [0], i32 [4], f64 [8], i64 [16], f32 [24], i32 [30], f32 [34], i32 [38])>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<(f32 [0], i32 [4], f64 [8], i64 [16], f32 [24], i32 [30], f32 [34], i32 [38])>, StorageBuffer>
spv.globalVariable @var2 : !spv.ptr<!spv.struct<(f32 [0], i32 [4], f64 [8], i64 [16], f32 [24], i32 [30], f32 [34], i32 [38])>, StorageBuffer> spv.globalVariable @var2 : !spv.ptr<!spv.struct<(f32 [0], i32 [4], f64 [8], i64 [16], f32 [24], i32 [30], f32 [34], i32 [38])>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<(!spv.array<128 x !spv.struct<(!spv.array<128 x f32, stride=4> [0])>, stride=512> [0])>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<(!spv.array<128 x !spv.struct<(!spv.array<128 x f32, stride=4> [0])>, stride=512> [0])>, StorageBuffer>
spv.globalVariable @var3 : !spv.ptr<!spv.struct<(!spv.array<128 x !spv.struct<(!spv.array<128 x f32, stride=4> [0])>, stride=512> [0])>, StorageBuffer> spv.globalVariable @var3 : !spv.ptr<!spv.struct<(!spv.array<128 x !spv.struct<(!spv.array<128 x f32, stride=4> [0])>, stride=512> [0])>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4])>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4])>, StorageBuffer>
spv.globalVariable @var4 : !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4])>, StorageBuffer> spv.globalVariable @var4 : !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4])>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<(f32 [NonWritable], i32 [NonWritable, NonReadable])>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<(f32 [NonWritable], i32 [NonWritable, NonReadable])>, StorageBuffer>
spv.globalVariable @var5 : !spv.ptr<!spv.struct<(f32 [NonWritable], i32 [NonWritable, NonReadable])>, StorageBuffer> spv.globalVariable @var5 : !spv.ptr<!spv.struct<(f32 [NonWritable], i32 [NonWritable, NonReadable])>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4, NonWritable, NonReadable])>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4, NonWritable, NonReadable])>, StorageBuffer>
spv.globalVariable @var6 : !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4, NonWritable, NonReadable])>, StorageBuffer> spv.globalVariable @var6 : !spv.ptr<!spv.struct<(f32 [0, NonWritable], i32 [4, NonWritable, NonReadable])>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>, StorageBuffer>
spv.globalVariable @var7 : !spv.ptr<!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>, StorageBuffer> spv.globalVariable @var7 : !spv.ptr<!spv.struct<(!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16])>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<()>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<()>, StorageBuffer>
spv.globalVariable @empty : !spv.ptr<!spv.struct<()>, StorageBuffer> spv.globalVariable @empty : !spv.ptr<!spv.struct<()>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<empty_struct, ()>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<empty_struct, ()>, StorageBuffer>
spv.globalVariable @id_empty : !spv.ptr<!spv.struct<empty_struct, ()>, StorageBuffer> spv.globalVariable @id_empty : !spv.ptr<!spv.struct<empty_struct, ()>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<test_id, (!spv.array<128 x f32, stride=4> [0])>, Input> // CHECK: !spv.ptr<!spv.struct<test_id, (!spv.array<128 x f32, stride=4> [0])>, Input>
spv.globalVariable @id_var0 : !spv.ptr<!spv.struct<test_id, (!spv.array<128 x f32, stride=4> [0])>, Input> spv.globalVariable @id_var0 : !spv.ptr<!spv.struct<test_id, (!spv.array<128 x f32, stride=4> [0])>, Input>
// CHECK: !spv.ptr<!spv.struct<rec, (!spv.ptr<!spv.struct<rec>, StorageBuffer>)>, StorageBuffer> // CHECK: !spv.ptr<!spv.struct<rec, (!spv.ptr<!spv.struct<rec>, StorageBuffer>)>, StorageBuffer>
spv.globalVariable @recursive_simple : !spv.ptr<!spv.struct<rec, (!spv.ptr<!spv.struct<rec>, StorageBuffer>)>, StorageBuffer> spv.globalVariable @recursive_simple : !spv.ptr<!spv.struct<rec, (!spv.ptr<!spv.struct<rec>, StorageBuffer>)>, StorageBuffer>
// CHECK: !spv.ptr<!spv.struct<a, (!spv.ptr<!spv.struct<b, (!spv.ptr<!spv.struct<a>, Uniform>)>, Uniform>)>, Uniform> // CHECK: !spv.ptr<!spv.struct<a, (!spv.ptr<!spv.struct<b, (!spv.ptr<!spv.struct<a>, Uniform>)>, Uniform>)>, Uniform>
spv.globalVariable @recursive_2 : !spv.ptr<!spv.struct<a, (!spv.ptr<!spv.struct<b, (!spv.ptr<!spv.struct<a>, Uniform>)>, Uniform>)>, Uniform> spv.globalVariable @recursive_2 : !spv.ptr<!spv.struct<a, (!spv.ptr<!spv.struct<b, (!spv.ptr<!spv.struct<a>, Uniform>)>, Uniform>)>, Uniform>
// CHECK: !spv.ptr<!spv.struct<axx, (!spv.ptr<!spv.struct<bxx, (!spv.ptr<!spv.struct<axx>, Uniform>, !spv.ptr<!spv.struct<bxx>, Uniform>)>, Uniform>)>, Uniform> // CHECK: !spv.ptr<!spv.struct<axx, (!spv.ptr<!spv.struct<bxx, (!spv.ptr<!spv.struct<axx>, Uniform>, !spv.ptr<!spv.struct<bxx>, Uniform>)>, Uniform>)>, Uniform>
spv.globalVariable @recursive_3 : !spv.ptr<!spv.struct<axx, (!spv.ptr<!spv.struct<bxx, (!spv.ptr<!spv.struct<axx>, Uniform>, !spv.ptr<!spv.struct<bxx>, Uniform>)>, Uniform>)>, Uniform> spv.globalVariable @recursive_3 : !spv.ptr<!spv.struct<axx, (!spv.ptr<!spv.struct<bxx, (!spv.ptr<!spv.struct<axx>, Uniform>, !spv.ptr<!spv.struct<bxx>, Uniform>)>, Uniform>)>, Uniform>
// CHECK: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input>, // CHECK: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input>,
// CHECK-SAME: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Output> // CHECK-SAME: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Output>
spv.func @kernel(%arg0: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input>, %arg1: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Output>) -> () "None" { spv.func @kernel(%arg0: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Input>, %arg1: !spv.ptr<!spv.struct<(!spv.array<128 x f32, stride=4> [0])>, Output>) -> () "None" {
spv.Return spv.Return
} }
} }

mlir/test/Target/SPIRV/terminator.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/terminator.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: @ret // CHECK-LABEL: @ret
spv.func @ret() -> () "None" { spv.func @ret() -> () "None" {
// CHECK: spv.Return // CHECK: spv.Return
spv.Return spv.Return
} }
// CHECK-LABEL: @ret_val // CHECK-LABEL: @ret_val
spv.func @ret_val() -> (i32) "None" { spv.func @ret_val() -> (i32) "None" {
%0 = spv.Variable : !spv.ptr<i32, Function> %0 = spv.Variable : !spv.ptr<i32, Function>
%1 = spv.Load "Function" %0 : i32 %1 = spv.Load "Function" %0 : i32
// CHECK: spv.ReturnValue {{.*}} : i32 // CHECK: spv.ReturnValue {{.*}} : i32
spv.ReturnValue %1 : i32 spv.ReturnValue %1 : i32
} }
// CHECK-LABEL: @unreachable // CHECK-LABEL: @unreachable
spv.func @unreachable() "None" { spv.func @unreachable() "None" {
spv.Return spv.Return
// CHECK-NOT: ^bb // CHECK-NOT: ^bb
^bb1: ^bb1:
// Unreachable blocks will be dropped during serialization. // Unreachable blocks will be dropped during serialization.
// CHECK-NOT: spv.Unreachable // CHECK-NOT: spv.Unreachable
spv.Unreachable spv.Unreachable
} }
} }

mlir/test/Target/SPIRV/undef.mlir

  • This file was moved from mlir/test/Dialect/SPIRV/Serialization/undef.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
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.undef : f32 // CHECK: {{%.*}} = spv.undef : f32
// CHECK-NEXT: {{%.*}} = spv.undef : f32 // CHECK-NEXT: {{%.*}} = spv.undef : f32
%0 = spv.undef : f32 %0 = spv.undef : f32
%1 = spv.undef : f32 %1 = spv.undef : f32
%2 = spv.FAdd %0, %1 : f32 %2 = spv.FAdd %0, %1 : f32
// 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
} }
} }

mlir/test/lib/Dialect/SPIRV/CMakeLists.txt

Show All 9 Linesadd_mlir_library(MLIRSPIRVTestPasses
${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
${MLIR_MAIN_INCLUDE_DIR}/mlir/IR ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
LINK_LIBS PUBLIC LINK_LIBS PUBLIC
MLIRGPU MLIRGPU
MLIRIR MLIRIR
MLIRPass MLIRPass
MLIRSPIRV MLIRSPIRV
MLIRSPIRVConversion
MLIRSPIRVModuleCombiner MLIRSPIRVModuleCombiner
MLIRSupport MLIRSupport
) )

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

//===- TestAvailability.cpp - Pass to test SPIR-V op availability ---------===// //===- TestAvailability.cpp - Pass to test SPIR-V op availability ---------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/SPIRVLowering.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Printing op availability pass // Printing op availability pass
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
▲ Show 20 Lines • Show All 212 Lines • Show Last 20 Lines

mlir/test/lib/Dialect/SPIRV/TestEntryPointAbi.cpp

//===- TestAvailability.cpp - Test pass for setting Entry point ABI info --===// //===- TestAvailability.cpp - Test pass for setting Entry point ABI info --===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements a pass that sets the spv.entry_point_abi attribute on // This file implements a pass that sets the spv.entry_point_abi attribute on
// functions that are to be lowered as entry point functions. // functions that are to be lowered as entry point functions.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/TargetAndABI.h" #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// Pass to set the spv.entry_point_abi /// Pass to set the spv.entry_point_abi
class TestSpirvEntryPointABIPass class TestSpirvEntryPointABIPass
: public PassWrapper<TestSpirvEntryPointABIPass, : public PassWrapper<TestSpirvEntryPointABIPass,
Show All 40 Lines

mlir/test/lib/Dialect/SPIRV/TestModuleCombiner.cpp

//===- TestModuleCombiner.cpp - Pass to test SPIR-V module combiner lib ---===// //===- TestModuleCombiner.cpp - Pass to test SPIR-V module combiner lib ---===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/SPIRV/ModuleCombiner.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Linking/ModuleCombiner.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinOps.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
class TestModuleCombinerPass class TestModuleCombinerPass
Show All 28 Lines

mlir/test/lib/Transforms/TestGpuMemoryPromotion.cpp

//===- TestGPUMemoryPromotionPass.cpp - Test pass for GPU promotion -------===// //===- TestGPUMemoryPromotionPass.cpp - Test pass for GPU promotion -------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file implements the pass testing the utilities for moving data across // This file implements the pass testing the utilities for moving data across
// different levels of the GPU memory hierarchy. // different levels of the GPU memory hierarchy.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Dialect/GPU/GPUDialect.h" #include "mlir/Dialect/GPU/GPUDialect.h"
#include "mlir/Dialect/GPU/MemoryPromotion.h" #include "mlir/Dialect/GPU/MemoryPromotion.h"
#include "mlir/Dialect/SCF/SCF.h" #include "mlir/Dialect/SCF/SCF.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/StandardOps/IR/Ops.h" #include "mlir/Dialect/StandardOps/IR/Ops.h"
#include "mlir/IR/Attributes.h" #include "mlir/IR/Attributes.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
using namespace mlir; using namespace mlir;
namespace { namespace {
/// Simple pass for testing the promotion to workgroup memory in GPU functions. /// Simple pass for testing the promotion to workgroup memory in GPU functions.
Show All 27 Lines

mlir/tools/mlir-spirv-cpu-runner/CMakeLists.txt

set(LLVM_OPTIONAL_SOURCES set(LLVM_LINK_COMPONENTS
mlir-spirv-cpu-runner.cpp Linker
) )
if (MLIR_SPIRV_CPU_RUNNER_ENABLED) if (MLIR_SPIRV_CPU_RUNNER_ENABLED)
message(STATUS "Building SPIR-V cpu runner") message(STATUS "Building SPIR-V CPU runner")
add_llvm_tool(mlir-spirv-cpu-runner add_llvm_tool(mlir-spirv-cpu-runner
mlir-spirv-cpu-runner.cpp mlir-spirv-cpu-runner.cpp
) )
llvm_update_compile_flags(mlir-spirv-cpu-runner) llvm_update_compile_flags(mlir-spirv-cpu-runner)
get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS) get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
Show All 18 Lines

mlir/tools/mlir-spirv-cpu-runner/mlir-spirv-cpu-runner.cpp

Show All 10 Lines
// JIT-compiling and executing. // JIT-compiling and executing.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
#include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h" #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/ExecutionEngine/JitRunner.h" #include "mlir/ExecutionEngine/JitRunner.h"
#include "mlir/ExecutionEngine/OptUtils.h" #include "mlir/ExecutionEngine/OptUtils.h"
#include "mlir/InitAllDialects.h" #include "mlir/InitAllDialects.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "mlir/Target/LLVMIR.h" #include "mlir/Target/LLVMIR.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

Show First 20 Lines • Show All 1,149 Lines • ▼ Show 20 Lines os << formatv("template <> inline StringRef attributeName<{0}>() {{\n",
enumName); enumName);
os << " " os << " "
<< formatv("static constexpr const char attrName[] = \"{0}\";\n", << formatv("static constexpr const char attrName[] = \"{0}\";\n",
llvm::convertToSnakeFromCamelCase(enumName)); llvm::convertToSnakeFromCamelCase(enumName));
os << " return attrName;\n"; os << " return attrName;\n";
os << "}\n"; os << "}\n";
} }
static bool emitOpUtils(const RecordKeeper &recordKeeper, raw_ostream &os) { static bool emitAttrUtils(const RecordKeeper &recordKeeper, raw_ostream &os) {
llvm::emitSourceFileHeader("SPIR-V Op Utilities", os); llvm::emitSourceFileHeader("SPIR-V Attribute Utilities", os);
auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo"); auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
os << "#ifndef SPIRV_OP_UTILS_H_\n"; os << "#ifndef MLIR_DIALECT_SPIRV_IR_ATTR_UTILS_H_\n";
os << "#define SPIRV_OP_UTILS_H_\n"; os << "#define MLIR_DIALECT_SPIRV_IR_ATTR_UTILS_H_\n";
emitEnumGetAttrNameFnDecl(os); emitEnumGetAttrNameFnDecl(os);
for (const auto *def : defs) { for (const auto *def : defs) {
EnumAttr enumAttr(*def); EnumAttr enumAttr(*def);
emitEnumGetAttrNameFnDefn(enumAttr, os); emitEnumGetAttrNameFnDefn(enumAttr, os);
} }
os << "#endif // SPIRV_OP_UTILS_H\n"; os << "#endif // MLIR_DIALECT_SPIRV_IR_ATTR_UTILS_H\n";
return false; return false;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Op Utils Hook Registration // Op Utils Hook Registration
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static mlir::GenRegistration static mlir::GenRegistration
genOpUtils("gen-spirv-op-utils", genOpUtils("gen-spirv-attr-utils",
"Generate SPIR-V operation utility definitions", "Generate SPIR-V attribute utility definitions",
[](const RecordKeeper &records, raw_ostream &os) { [](const RecordKeeper &records, raw_ostream &os) {
return emitOpUtils(records, os); return emitAttrUtils(records, os);
}); });
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// SPIR-V Availability Impl AutoGen // SPIR-V Availability Impl AutoGen
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) { static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) {
mlir::tblgen::FmtContext fctx; mlir::tblgen::FmtContext fctx;
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static bool emitCapabilityImplication(const RecordKeeper &recordKeeper, static bool emitCapabilityImplication(const RecordKeeper &recordKeeper,
raw_ostream &os) { raw_ostream &os) {
llvm::emitSourceFileHeader("SPIR-V Capability Implication", os); llvm::emitSourceFileHeader("SPIR-V Capability Implication", os);
EnumAttr enumAttr(recordKeeper.getDef("SPV_CapabilityAttr")); EnumAttr enumAttr(recordKeeper.getDef("SPV_CapabilityAttr"));
os << "ArrayRef<Capability> " os << "ArrayRef<spirv::Capability> "
"spirv::getDirectImpliedCapabilities(Capability cap) {\n" "spirv::getDirectImpliedCapabilities(spirv::Capability cap) {\n"
<< " switch (cap) {\n" << " switch (cap) {\n"
<< " default: return {};\n"; << " default: return {};\n";
for (const EnumAttrCase &enumerant : enumAttr.getAllCases()) { for (const EnumAttrCase &enumerant : enumAttr.getAllCases()) {
const Record &def = enumerant.getDef(); const Record &def = enumerant.getDef();
if (!def.getValue("implies")) if (!def.getValue("implies"))
continue; continue;
std::vector<Record *> impliedCapsDefs = def.getValueAsListOfDefs("implies"); std::vector<Record *> impliedCapsDefs = def.getValueAsListOfDefs("implies");
os << " case Capability::" << enumerant.getSymbol() os << " case spirv::Capability::" << enumerant.getSymbol()
<< ": {static const Capability implies[" << impliedCapsDefs.size() << ": {static const spirv::Capability implies[" << impliedCapsDefs.size()
<< "] = {"; << "] = {";
llvm::interleaveComma(impliedCapsDefs, os, [&](const Record *capDef) { llvm::interleaveComma(impliedCapsDefs, os, [&](const Record *capDef) {
os << "Capability::" << EnumAttrCase(capDef).getSymbol(); os << "spirv::Capability::" << EnumAttrCase(capDef).getSymbol();
}); });
os << "}; return ArrayRef<Capability>(implies, " << impliedCapsDefs.size() os << "}; return ArrayRef<spirv::Capability>(implies, "
<< "); }\n"; << impliedCapsDefs.size() << "); }\n";
} }
os << " }\n"; os << " }\n";
os << "}\n"; os << "}\n";
return false; return false;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 10 Lines

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

Show All 11 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h" #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
#include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h" #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h" #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
#include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h" #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
#include "mlir/Dialect/GPU/Passes.h" #include "mlir/Dialect/GPU/Passes.h"
#include "mlir/Dialect/SPIRV/Passes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
#include "mlir/ExecutionEngine/JitRunner.h" #include "mlir/ExecutionEngine/JitRunner.h"
#include "mlir/ExecutionEngine/OptUtils.h" #include "mlir/ExecutionEngine/OptUtils.h"
#include "mlir/InitAllDialects.h" #include "mlir/InitAllDialects.h"
#include "mlir/Pass/Pass.h" #include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h" #include "mlir/Pass/PassManager.h"
#include "llvm/Support/InitLLVM.h" #include "llvm/Support/InitLLVM.h"
#include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetSelect.h"
Show All 36 Lines

mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp

//===- DeserializationTest.cpp - SPIR-V Deserialization Tests -------------===// //===- DeserializationTest.cpp - SPIR-V Deserialization Tests -------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// The purpose of this file is to provide negative deserialization tests. // The purpose of this file is to provide negative deserialization tests.
// For positive deserialization tests, please use serialization and // For positive deserialization tests, please use serialization and
// deserialization for roundtripping. // deserialization for roundtripping.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Target/SPIRV/Deserialization.h" #include "mlir/Target/SPIRV/Deserialization.h"
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: #includes are not sorted properly [llvm-include-order]
not useful

Lint: Pre-merge checks: clang-tidy: warning: #includes are not sorted properly [llvm-include-order] [[https://github.
#include "mlir/Dialect/SPIRV/SPIRVModule.h" #include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/IR/Diagnostics.h" #include "mlir/IR/Diagnostics.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/Target/SPIRV/SPIRVBinaryUtils.h" #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include <memory> #include <memory>
using namespace mlir; using namespace mlir;
▲ Show 20 Lines • Show All 265 Lines • Show Last 20 Lines

mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

//===- SerializationTest.cpp - SPIR-V Serialization Tests -----------------===// //===- SerializationTest.cpp - SPIR-V Serialization Tests -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file contains corner case tests for the SPIR-V serializer that are not // This file contains corner case tests for the SPIR-V serializer that are not
// covered by normal serialization and deserialization roundtripping. // covered by normal serialization and deserialization roundtripping.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "mlir/Target/SPIRV/Serialization.h" #include "mlir/Target/SPIRV/Serialization.h"
#include "mlir/Dialect/SPIRV/SPIRVAttributes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: #includes are not sorted properly [llvm-include-order]
not useful

Lint: Pre-merge checks: clang-tidy: warning: #includes are not sorted properly [llvm-include-order] [[https://github.
#include "mlir/Dialect/SPIRV/SPIRVDialect.h" #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
#include "mlir/Dialect/SPIRV/SPIRVModule.h" #include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
#include "mlir/Dialect/SPIRV/SPIRVOps.h" #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
#include "mlir/Dialect/SPIRV/SPIRVTypes.h" #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
#include "mlir/IR/Builders.h" #include "mlir/IR/Builders.h"
#include "mlir/IR/Location.h" #include "mlir/IR/Location.h"
#include "mlir/IR/MLIRContext.h" #include "mlir/IR/MLIRContext.h"
#include "mlir/Target/SPIRV/SPIRVBinaryUtils.h" #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Sequence.h" #include "llvm/ADT/Sequence.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines
mlir/test/Target/SPIRV/selection.mlir