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

[antiagainst]

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.

[mravishankar]

Thanks for doing this!

mlir/docs/Dialects/SPIR-V.md

*   From standard dialect: headers are at
     [include/mlir/Conversion/StandardTOSPIRV][MlirStdToSpirvHeaders]; libraries
     are at [lib/Conversion/StandardToSPIRV][MlirStdToSpirvLibs].
 
 These dialect to dialect conversions have their dedicated libraries,
 `MLIRGPUToSPIRVTransforms` and `MLIRStandardToSPIRVTransforms`, respectively.
 
 There are also common utilities when targeting SPIR-V from any dialect:
 
-*   [include/mlir/Dialect/SPIRV/Passes.h][MlirSpirvPasses] contains SPIR-V
-    specific analyses and transformations.
-*   [include/mlir/Dialect/SPIRV/SPIRVLowering.h][MlirSpirvLowering] contains
-    type converters and other utility functions.
+*   [include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h][MlirSpirvConversion]
+    contains type converters and other utility functions.
+*   [include/mlir/Dialect/SPIRV/Transforms/Passes.h][MlirSpirvPasses] contains
+    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
 
 ### Lowering `memref`s to `!spv.array<..>` and `!spv.rtarray<..>`.
 
 The LLVM dialect lowers `memref` types to a `MemrefDescriptor`:
 
 ```

 [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
 [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
 [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
 [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
-[MlirSpirvDialect]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVDialect.h
-[MlirSpirvTypes]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h
-[MlirSpirvOpsH]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h
-[MlirSpirvSerialization]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/Serialization.h
-[MlirSpirvBase]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td
-[MlirSpirvPasses]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/Passes.h
-[MlirSpirvLowering]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/SPIRVLowering.h
-[MlirSpirvAbi]: https://github.com/llvm/llvm-project/blob/master/mlir/include/mlir/Dialect/SPIRV/TargetAndABI.h
-[MlirSpirvOpsCpp]: https://github.com/llvm/llvm-project/blob/master/mlir/lib/Dialect/SPIRV/SPIRVOps.cpp
+[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/IR/SPIRVTypes.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/Target/SPIRV/Serialization.h
+[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/Transforms/Passes.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/IR/TargetAndABI.h
+[MlirSpirvOpsCpp]: https://github.com/llvm/llvm-project/blob/master/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp
 [GitHubDialectTracking]: https://github.com/tensorflow/mlir/issues/302
 [GitHubLoweringTracking]: https://github.com/tensorflow/mlir/issues/303
 [GenSpirvUtilsPy]: https://github.com/llvm/llvm-project/blob/master/mlir/utils/spirv/gen_spirv_dialect.py
 [CustomTypeAttrTutorial]: ../Tutorials/DefiningAttributesAndTypes.md
 [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
 [VulkanSpirv]: https://renderdoc.org/vkspec_chunked/chap40.html#spirvenv
 [VulkanShaderInterface]: https://renderdoc.org/vkspec_chunked/chap14.html#interfaces-resources
 [VulkanShaderInterfaceStorageClass]: https://renderdoc.org/vkspec_chunked/chap15.html#interfaces
 [VulkanResourceLimits]: https://renderdoc.org/vkspec_chunked/chap36.html#limits
 [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

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

-add_mlir_dialect(SPIRVOps spv)
-add_mlir_doc(SPIRVOps -gen-op-doc SPIRVOps Dialects/)
-
-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 ./)
+add_subdirectory(IR)
+add_subdirectory(Transforms)

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

 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)
+mlir_tablegen(SPIRVAttrUtils.inc -gen-spirv-attr-utils)
+add_public_tablegen_target(MLIRSPIRVAttrUtilsGen)
+add_dependencies(mlir-headers MLIRSPIRVAttrUtilsGen)
 
 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/ParserUtils.h

 //===------------ ParserUtils.h - Parse text to SPIR-V ops ----------------===//
 //
 // 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 utilities used for parsing types and ops for SPIR-V
 // 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/OpImplementation.h"
 
 namespace mlir {
+
 /// Parses the next keyword in `parser` as an enumerant of the given
 /// `EnumClass`.
 template <typename EnumClass, typename ParserType>
 static ParseResult
 parseEnumKeywordAttr(EnumClass &value, ParserType &parser,
                      StringRef attrName = spirv::attributeName<EnumClass>()) {
   StringRef keyword;
   SmallVector<NamedAttribute, 1> attr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&keyword))
     return failure();
   if (Optional<EnumClass> attr = spirv::symbolizeEnum<EnumClass>(keyword)) {
     value = attr.getValue();
     return success();
   }
   return parser.emitError(loc, "invalid ")
          << attrName << " attribute specification: " << keyword;
 }
+
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_PARSERUTILS_H_
+#endif // MLIR_DIALECT_SPIRV_IR_PARSERUTILS_H_

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

 //===-- SPIRVArithmeticOps.td - MLIR SPIR-V Arithmetic Ops -*- tablegen -*-===//
 //
 // 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 contains arithmetic ops for the SPIR-V dialect. It corresponds
 // to "3.32.13. Arithmetic Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_ARITHMETIC_OPS
-#define SPIRV_ARITHMETIC_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 class SPV_ArithmeticBinaryOp<string mnemonic, Type type,
                        list<OpTrait> traits = []> :
       // Operands type same as result type.
       SPV_BinaryOp<mnemonic, type, type,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])> {
let description = [{
     ```mlir
     %4 = spv.UMod %0, %1 : i32
     %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

 //===-- SPIRVAtomicOps.td - MLIR SPIR-V Atomic Ops ---------*- tablegen -*-===//
 //
 // 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 contains atomic ops for the SPIR-V dialect. It corresponds to
 // "3.32.18. Atomic Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_ATOMIC_OPS
-#define SPIRV_ATOMIC_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS
+#define MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS
 
 class SPV_AtomicUpdateOp<string mnemonic, list<OpTrait> traits = []> :
   SPV_Op<mnemonic, traits> {
   let parser = [{ return ::parseAtomicUpdateOp(parser, result, false); }];
   let printer = [{ return ::printAtomicUpdateOp(getOperation(), p); }];
   let verifier = [{ return ::verifyAtomicUpdateOp(getOperation()); }];
 
   let arguments = (ins
let description = [{
     %0 = spv.AtomicXor "Device" "None" %pointer, %value :
                        !spv.ptr<i32, StorageBuffer>
     ```
   }];
 }
 
 // -----
 
-#endif // SPIRV_ATOMIC_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_ATOMIC_OPS

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

 //===- SPIRVAttributes.h - SPIR-V attribute declarations  -------*- 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 SPIR-V dialect specific attributes.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H
-#define MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H
+#ifndef MLIR_DIALECT_SPIRV_IR_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/Support/LLVM.h"
 
-// Pull in SPIR-V attribute definitions for target and ABI.
-#include "mlir/Dialect/SPIRV/TargetAndABI.h.inc"
+// Pull in TableGen'erated SPIR-V attribute definitions for target and ABI.
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h.inc"
 
 namespace mlir {
 namespace spirv {
 enum class Capability : uint32_t;
 enum class DeviceType;
 enum class Extension;
 enum class Vendor;
 enum class Version : uint32_t;
 
 namespace detail {
 struct InterfaceVarABIAttributeStorage;
 struct TargetEnvAttributeStorage;
 struct VerCapExtAttributeStorage;
 } // 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
 /// variable: descriptor set, binding, storage class.
 class InterfaceVarABIAttr
     : public Attribute::AttrBase<InterfaceVarABIAttr, Attribute,
                                  detail::InterfaceVarABIAttributeStorage> {
 public:
   using Base::Base;
 
public:
   static LogicalResult
   verifyConstructionInvariants(Location loc, VerCapExtAttr triple,
                                Vendor vendorID, DeviceType deviceType,
                                uint32_t deviceID, DictionaryAttr limits);
 };
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H
+#endif // MLIR_DIALECT_SPIRV_IR_SPIRVATTRIBUTES_H

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

 //===- SPIRVAvailability.td - Op Availability Base file ----*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_AVAILABILITY
-#define SPIRV_AVAILABILITY
+#ifndef MLIR_DIALECT_SPIRV_IR_AVAILABILITY
+#define MLIR_DIALECT_SPIRV_IR_AVAILABILITY
 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // Op availability definitions
 //===----------------------------------------------------------------------===//
 
 // The base class for defining op availability dimensions.
let mergeAction = "$overall = static_cast<" # scheme.returnType # ">("
                       "std::min($overall, $instance))";
   let initializer = "static_cast<" # scheme.returnType # ">(~uint32_t(0))";
   let instanceType = scheme.cppNamespace # "::" # scheme.className;
 
   let instance = scheme.cppNamespace # "::" # scheme.className # "::" #
                  max.symbol;
 }
 
-#endif // SPIRV_AVAILABILITY
+#endif // MLIR_DIALECT_SPIRV_IR_AVAILABILITY

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

 //===- SPIRVBase.td - MLIR SPIR-V Op Definitions Base file -*- tablegen -*-===//
 //
 // 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 is the base file for SPIR-V operation definition specification.
 // This file defines the SPIR-V dialect, common SPIR-V types, and utilities
 // for facilitating defining SPIR-V ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_BASE
-#define SPIRV_BASE
+#ifndef MLIR_DIALECT_SPIRV_IR_BASE
+#define MLIR_DIALECT_SPIRV_IR_BASE
 
 include "mlir/IR/OpBase.td"
-include "mlir/Dialect/SPIRV/SPIRVAvailability.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V dialect definitions
 //===----------------------------------------------------------------------===//
 
 def SPIRV_Dialect : Dialect {
   let name = "spv";
 
class SPV_ExtInstOp<string mnemonic, string setPrefix, string setName,
 
   // Opcode within extended instruction set.
   int extendedInstOpcode = opcode;
 
   // Name used to import the extended instruction set.
   string extendedInstSetName = setName;
 }
 
-#endif // SPIRV_BASE
+#endif // MLIR_DIALECT_SPIRV_IR_BASE

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

 //===-- SPIRVBitOps.td - MLIR SPIR-V Bit Ops -*- tablegen -*-===//
 //
 // 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 contains bit ops for the SPIR-V dialect. It corresponds
 // to "3.32.13. Bit Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_BIT_OPS
-#define SPIRV_BIT_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 class SPV_BitBinaryOp<string mnemonic, list<OpTrait> traits = []> :
       // All the operands type used in bit instructions are SPV_Integer.
       SPV_BinaryOp<mnemonic, SPV_Integer, SPV_Integer,
                    !listconcat(traits,
                                [NoSideEffect, SameOperandsAndResultType])>;
 
let description = [{
 
     ```mlir
     %2 = spv.Not %0 : i32
     %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

 //===-- SPIRVCastOps.td - MLIR SPIR-V Cast Ops -------*- tablegen -*-------===//
 //
 // 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 contains cast ops for the SPIR-V dialect. It corresponds
 // to "3.32.11. Conversion Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_CAST_OPS
-#define SPIRV_CAST_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 class SPV_CastOp<string mnemonic, Type resultType, Type operandType,
                  list<OpTrait> traits = []> :
       SPV_Op<mnemonic,
              !listconcat(traits,
                          [NoSideEffect, SameOperandsAndResultShape])> {
   let arguments = (ins
let description = [{
     %1 = spv.UConvertOp %0 : i32 to i64
     %3 = spv.UConvertOp %2 : vector<3xi32> to vector<3xi64>
     ```
   }];
 
   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

 //===-- SPIRVCompositeOps.td - MLIR SPIR-V Composite Ops ---*- tablegen -*-===//
 //
 // 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 contains composite ops for SPIR-V dialect. It corresponds
 // to "3.32.12. Composite Instructions" of the SPIR-V spec.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_COMPOSITE_OPS
-#define SPIRV_COMPOSITE_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 // -----
 
 def SPV_CompositeConstructOp : SPV_Op<"CompositeConstruct", [NoSideEffect]> {
   let summary = [{
     Construct a new composite object from a set of constituent objects that
     will fully form it.
def SPV_VectorInsertDynamicOp : SPV_Op<"VectorInsertDynamic",
   
   let assemblyFormat = [{
     $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

 //===-- SPIRVControlFlowOps.td - SPIR-V Control Flow Ops ---*- tablegen -*-===//
 //
 // 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 contains control flow ops for the SPIR-V dialect. It corresponds
 // to "3.32.17. Control-Flow Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_CONTROLFLOW_OPS
-#define SPIRV_CONTROLFLOW_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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/ControlFlowInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_BranchOp : SPV_Op<"Branch", [
     DeclareOpInterfaceMethods<BranchOpInterface>, InFunctionScope, NoSideEffect,
def SPV_SelectionOp : SPV_Op<"selection", [InFunctionScope]> {
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let hasCanonicalizer = 1;
 }
 
-#endif // SPIRV_CONTROLFLOW_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_CONTROLFLOW_OPS

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

 //===- SPIRVCooperativeMatrixOps.td - cooperative matmul ---*- tablegen -*-===//
 //
 // 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 is the op definition spec of cooperative matrix multiply extension ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_COOPERATIVE_MATRIX_OPS
-#define SPIRV_COOPERATIVE_MATRIX_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
+#define MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS
 
 // -----
 
 def SPV_CooperativeMatrixLengthNVOp : SPV_Op<"CooperativeMatrixLengthNV",
   [NoSideEffect]> {
   let summary = "See extension SPV_NV_cooperative_matrix";
 
   let description = [{
def SPV_CooperativeMatrixStoreNVOp : SPV_Op<"CooperativeMatrixStoreNV", []> {
   let verifier = [{
     return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                           object().getType());
   }];
 }
 
 // -----
 
-#endif // SPIRV_COOPERATIVE_MATRIX_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_COOPERATIVE_MATRIX_OPS

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

 //===- SPIRVDialect.h - MLIR SPIR-V dialect ---------------------*- 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 SPIR-V dialect in MLIR.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_SPIRVDIALECT_H_
-#define MLIR_DIALECT_SPIRV_SPIRVDIALECT_H_
+#ifndef MLIR_DIALECT_SPIRV_IR_SPIRVDIALECT_H_
+#define MLIR_DIALECT_SPIRV_IR_SPIRVDIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 namespace spirv {
 
 enum class Decoration : uint32_t;
 
 } // end namespace spirv
 } // 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

+//===- 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

 //===- SPIRVGLSLOps.td - GLSL extended insts spec file -----*- tablegen -*-===//
 //
 // 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 is the op definition spec of GLSL extension ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_GLSL_OPS
-#define SPIRV_GLSL_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V GLSL 4.50 opcode specification.
 //===----------------------------------------------------------------------===//
 
 // Base class for all GLSL ops.
 class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
let description = [{
 
     ```mlir
     %2 = spv.GLSL.SClamp %x, %min, %max : si32
     %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

 //===-- SPIRVGroupOps.td - MLIR SPIR-V (Sub)Group Ops ------*- tablegen -*-===//
 //
 // 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 contains group and subgroup ops for the SPIR-V dialect. It
 // corresponds to "3.32.21. Group and Subgroup Instructions" of the SPIR-V
 // specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_GROUP_OPS
-#define SPIRV_GROUP_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_GROUP_OPS
+#define MLIR_DIALECT_SPIRV_IR_GROUP_OPS
 
 // -----
 
 def SPV_GroupBroadcastOp : SPV_Op<"GroupBroadcast",
   [NoSideEffect, AllTypesMatch<["value", "result"]>]> {
   let summary = [{
     Return the Value of the invocation identified by the local id LocalId to
     all invocations in the group.
let arguments = (ins
     SPV_Type:$value
   );
 
   let results = (outs);
 }
 
 // -----
 
-#endif // SPIRV_GROUP_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_GROUP_OPS

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

 //===-- SPIRVLogicalOps.td - MLIR SPIR-V Logical Ops -------*- tablegen -*-===//
 //
 // 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 contains arithmetic ops for the SPIR-V dialect. It corresponds
 // to "3.32.15. Relational and Logical Instructions" of the SPIR-V spec.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_LOGICAL_OPS
-#define SPIRV_LOGICAL_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 class SPV_LogicalBinaryOp<string mnemonic, Type operandsType,
                     list<OpTrait> traits = []> :
       // Result type is SPV_Bool.
       SPV_BinaryOp<mnemonic, SPV_Bool, operandsType,
                    !listconcat(traits,
                                [NoSideEffect, SameTypeOperands,
let description = [{
     ```mlir
     %4 = spv.ULessThanEqual %0, %1 : i32
     %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

 //===-- SPIRVMatrixOps.td - MLIR SPIR-V Matrix Ops ---------*- tablegen -*-===//
 //
 // 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 contains matrix operations for the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_MATRIX_OPS
-#define SPIRV_MATRIX_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_MATRIX_OPS
+#define MLIR_DIALECT_SPIRV_IR_MATRIX_OPS
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_MatrixTimesMatrixOp : SPV_Op<"MatrixTimesMatrix", [NoSideEffect]> {
   let summary = "Linear-algebraic multiply of LeftMatrix X RightMatrix.";
 
   let description = [{
let assemblyFormat = [{
     operands attr-dict `:` type($matrix) `->` type($result)
   }];
 
   let verifier = [{ return verifyTranspose(*this); }];
 }
 
 // -----
 
-#endif // SPIRV_MATRIX_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_MATRIX_OPS

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

 //===- SPIRVModule.h - SPIR-V Module Utilities ------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_SPIRVMODULE_H
-#define MLIR_DIALECT_SPIRV_SPIRVMODULE_H
+#ifndef MLIR_DIALECT_SPIRV_IR_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"
 
 namespace mlir {
 namespace spirv {
 
 /// 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
 /// is valid.
 // TODO: Remove this class in favor of using OwningOpRef directly.
 class OwningSPIRVModuleRef : public OwningOpRef<spirv::ModuleOp> {
 public:
   using OwningOpRef<spirv::ModuleOp>::OwningOpRef;
 };
 
 } // end namespace spirv
 } // end namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_SPIRVMODULE_H
+#endif // MLIR_DIALECT_SPIRV_IR_SPIRVMODULE_H

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

 //===-- SPIRVNonUniformOps.td - MLIR SPIR-V NonUniform Ops -*- tablegen -*-===//
 //
 // 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 contains non-uniform ops for the SPIR-V dialect. It corresponds to
 // "3.32.24. Non-Uniform Instructions" of the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_NON_UNIFORM_OPS
-#define SPIRV_NON_UNIFORM_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
+#define MLIR_DIALECT_SPIRV_IR_NON_UNIFORM_OPS
 
 class SPV_GroupNonUniformArithmeticOp<string mnemonic, Type type,
       list<OpTrait> traits = []> : SPV_Op<mnemonic, traits> {
 
   let availability = [
     MinVersion<SPV_V_1_3>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
let description = [{
     %0 = spv.GroupNonUniformUMin "Workgroup" "Reduce" %scalar : i32
     %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

 //===- SPIRVOCLOps.td - OpenCL extended insts spec file ----*- tablegen -*-===//
 //
 // 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 is the op definition spec of OpenCL extension ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_OCL_OPS
-#define SPIRV_OCL_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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.
 //===----------------------------------------------------------------------===//
 
 // Base class for all OpenCL ops.
 class SPV_OCLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
   SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits>;
let description = [{
 
     ```mlir
     %2 = spv.OCL.s_abs %0 : i32
     %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

 //===- SPIRVOps.h - MLIR SPIR-V operations ----------------------*- 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 operations in the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_SPIRVOPS_H_
-#define MLIR_DIALECT_SPIRV_SPIRVOPS_H_
+#ifndef MLIR_DIALECT_SPIRV_IR_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/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace mlir {
 class OpBuilder;
 
 namespace spirv {
 class VerCapExtAttr;
 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
-#include "mlir/Dialect/SPIRV/SPIRVAvailability.h.inc"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.h.inc"
 } // namespace spirv
 } // namespace mlir
 
 // TablenGen'erated operation declarations.
 #define GET_OP_CLASSES
-#include "mlir/Dialect/SPIRV/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
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h.inc"
 
 namespace llvm {
 
 /// spirv::Function ops hash just like pointers.
 template <>
 struct DenseMapInfo<mlir::spirv::FuncOp> {
   static mlir::spirv::FuncOp getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
public:
   static inline mlir::spirv::FuncOp getFromVoidPointer(void *P) {
     return mlir::spirv::FuncOp::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };
 
 } // namespace llvm
 
-#endif // MLIR_DIALECT_SPIRV_SPIRVOPS_H_
+#endif // MLIR_DIALECT_SPIRV_IR_SPIRVOPS_H_

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

 
 // 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
 // definition: basic structure, summary, description. So modifications to these
 // sections will not be respected. Modifications to op traits, arguments,
 // results, and sections after the results are retained. Besides, ops must be
 // separated via the '// -----' marker.
 
-#ifndef SPIRV_OPS
-#define SPIRV_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_OPS
+#define MLIR_DIALECT_SPIRV_IR_OPS
 
-include "mlir/Dialect/SPIRV/SPIRVBase.td"
-include "mlir/Dialect/SPIRV/SPIRVArithmeticOps.td"
-include "mlir/Dialect/SPIRV/SPIRVAtomicOps.td"
-include "mlir/Dialect/SPIRV/SPIRVBitOps.td"
-include "mlir/Dialect/SPIRV/SPIRVCastOps.td"
-include "mlir/Dialect/SPIRV/SPIRVCompositeOps.td"
-include "mlir/Dialect/SPIRV/SPIRVControlFlowOps.td"
-include "mlir/Dialect/SPIRV/SPIRVCooperativeMatrixOps.td"
-include "mlir/Dialect/SPIRV/SPIRVGLSLOps.td"
-include "mlir/Dialect/SPIRV/SPIRVGroupOps.td"
-include "mlir/Dialect/SPIRV/SPIRVLogicalOps.td"
-include "mlir/Dialect/SPIRV/SPIRVMatrixOps.td"
-include "mlir/Dialect/SPIRV/SPIRVNonUniformOps.td"
-include "mlir/Dialect/SPIRV/SPIRVOCLOps.td"
-include "mlir/Dialect/SPIRV/SPIRVStructureOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVArithmeticOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVAtomicOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVBitOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVCastOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVCompositeOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVControlFlowOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVCooperativeMatrixOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVGroupOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVLogicalOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVMatrixOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_AccessChainOp : SPV_Op<"AccessChain", [NoSideEffect]> {
   let summary = [{
     Create a pointer into a composite object that can be used with OpLoad
     and OpStore.
def SPV_VariableOp : SPV_Op<"Variable", []> {
 
   let results = (outs
     SPV_AnyPtr:$pointer
   );
 }
 
 // -----
 
-#endif // SPIRV_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_OPS

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

 //===-- SPIRVStructureOps.td - MLIR SPIR-V Structure Ops ---*- tablegen -*-===//
 //
 // 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 contains ops for defining the SPIR-V structure: module, function,
 // and module-level operations. The representational form of these ops deviate
 // from the SPIR-V binary format in order to utilize MLIR mechanisms.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_STRUCTURE_OPS
-#define SPIRV_STRUCTURE_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_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/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> {
   let summary = "Get the address of a global variable.";
def SPV_SpecConstantOperationOp : SPV_Op<"SpecConstantOperation", [
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
 // -----
 
-#endif // SPIRV_STRUCTURE_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS

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

 //===- SPIRVTypes.h - MLIR SPIR-V Types -------------------------*- 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 types in the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_SPIRVTYPES_H_
-#define MLIR_DIALECT_SPIRV_SPIRVTYPES_H_
+#ifndef MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_
+#define MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_
 
+#include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/TypeSupport.h"
 #include "mlir/IR/Types.h"
 
 #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 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 {
 struct ArrayTypeStorage;
 struct CooperativeMatrixTypeStorage;
 struct ImageTypeStorage;
 struct MatrixTypeStorage;
 struct PointerTypeStorage;
 struct RuntimeArrayTypeStorage;
public:
 
   // Returns in `memberDecorations` the Decorations (apart from Offset)
   // associated with all members of the StructType.
   void getMemberDecorations(SmallVectorImpl<StructType::MemberDecorationInfo>
                                 &memberDecorations) const;
 
   // Returns in `decorationsInfo` all the Decorations (apart from Offset)
   // associated with the `i`-th member of the StructType.
-  void getMemberDecorations(unsigned i,
-                            SmallVectorImpl<StructType::MemberDecorationInfo>
-                                &decorationsInfo) const;
+  void getMemberDecorations(
+      unsigned i,
+      SmallVectorImpl<StructType::MemberDecorationInfo> &decorationsInfo) const;
 
   /// Sets the contents of an incomplete identified StructType. This method must
   /// be called only for identified StructTypes and it must be called only once
   /// per instance. Otherwise, failure() is returned.
   LogicalResult
   trySetBody(ArrayRef<Type> memberTypes, ArrayRef<OffsetInfo> offsetInfo = {},
              ArrayRef<MemberDecorationInfo> memberDecorations = {});
 
void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<StorageClass> storage = llvm::None);
 };
 
 } // end namespace spirv
 } // end namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_SPIRVTYPES_H_
+#endif // MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_

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

 //===- TargetAndABI.h - SPIR-V target and ABI utilities  --------*- 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 utilities for SPIR-V target and shader interface ABI.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_TARGETANDABI_H
-#define MLIR_DIALECT_SPIRV_TARGETANDABI_H
+#ifndef MLIR_DIALECT_SPIRV_IR_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 "llvm/ADT/SmallSet.h"
 
 namespace mlir {
 class Operation;
 
 namespace spirv {
 enum class StorageClass : uint32_t;

 
 /// Returns memory model selected based on target environment.
 /// Returns failure if it cannot be selected.
 FailureOr<MemoryModel> getMemoryModel(TargetEnvAttr targetAttr);
 
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_TARGETANDABI_H
+#endif // MLIR_DIALECT_SPIRV_IR_TARGETANDABI_H

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

 // 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
 // (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
 // attributes to resources and other suitable places.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SPIRV_TARGET_AND_ABI
-#define SPIRV_TARGET_AND_ABI
+#ifndef MLIR_DIALECT_SPIRV_IR_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
 // points in the generated SPIR-V module:
 // 1) WorkGroup Size.
 def SPV_EntryPointABIAttr : StructAttr<"EntryPointABIAttr", SPIRV_Dialect, [
     StructFieldAttr<"local_size", I32ElementsAttr>
 ]>;
 
def SPV_ResourceLimitsAttr : StructAttr<"ResourceLimitsAttr", SPIRV_Dialect, [
 
     // The configurations of cooperative matrix operations
     // supported. Default is an empty list.
     StructFieldAttr<
         "cooperative_matrix_properties_nv",
         DefaultValuedAttr<SPV_CooperativeMatrixPropertiesNVArrayAttr, "{}">>
 ]>;
 
-#endif // SPIRV_TARGET_AND_ABI
+#endif // MLIR_DIALECT_SPIRV_IR_TARGET_AND_ABI

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

 //===- ModuleCombiner.h - MLIR SPIR-V Module Combiner -----------*- 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 entry point to the SPIR-V module combiner library.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_MODULECOMBINER_H_
-#define MLIR_DIALECT_SPIRV_MODULECOMBINER_H_
+#ifndef MLIR_DIALECT_SPIRV_LINKING_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/SmallVector.h"
 
 namespace mlir {
 class OpBuilder;
 
 namespace spirv {
 class ModuleOp;

 OwningSPIRVModuleRef
 combine(llvm::MutableArrayRef<ModuleOp> modules,
         OpBuilder &combinedModuleBuilder,
         llvm::function_ref<void(ModuleOp, StringRef, StringRef)>
             symbRenameListener);
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_MODULECOMBINER_H_
+#endif // MLIR_DIALECT_SPIRV_LINKING_MODULECOMBINER_H_

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

+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

 //===- Passes.h - SPIR-V pass entry points ----------------------*- 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 header file defines prototypes that expose pass constructors.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_PASSES_H_
-#define MLIR_DIALECT_SPIRV_PASSES_H_
+#ifndef MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES_H_
+#define MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace spirv {
 
 class ModuleOp;
+
+//===----------------------------------------------------------------------===//
+// Passes
+//===----------------------------------------------------------------------===//
+
 /// Creates a module pass that converts composite types used by objects in the
 /// StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage
 /// classes with layout information.
 /// Right now this pass only supports Vulkan layout rules.
 std::unique_ptr<OperationPass<mlir::ModuleOp>>
 createDecorateSPIRVCompositeTypeLayoutPass();
 
 /// Creates an operation pass that deduces and attaches the minimal version/

 std::unique_ptr<OperationPass<spirv::ModuleOp>> createRewriteInsertsPass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
-#include "mlir/Dialect/SPIRV/Passes.h.inc"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_PASSES_H_
+#endif // MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES_H_

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

 //===-- Passes.td - SPIRV pass definition file -------------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_PASSES
-#define MLIR_DIALECT_SPIRV_PASSES
+#ifndef MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
+#define MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
 def SPIRVCompositeTypeLayout
     : Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> {
   let summary = "Decorate SPIR-V composite type with layout info";
   let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
 }

 }
 
 def SPIRVUpdateVCE : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
   let summary = "Deduce and attach minimal (version, capabilities, extensions) "
                 "requirements to spv.module ops";
   let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()";
 }
 
-#endif // MLIR_DIALECT_SPIRV_PASSES
+#endif // MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVConversion.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.
 // See https://llvm.org/LICENSE.txt for license information.
 // 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
-#define MLIR_DIALECT_SPIRV_SPIRVLOWERING_H
+#ifndef MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
+#define MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H
 
-#include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
-#include "mlir/Dialect/SPIRV/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/SmallSet.h"
 
 namespace mlir {
 
 /// 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

 /// Sets the InterfaceVarABIAttr and EntryPointABIAttr for a function and its
 /// arguments.
 LogicalResult setABIAttrs(spirv::FuncOp funcOp,
                           EntryPointABIAttr entryPointInfo,
                           ArrayRef<InterfaceVarABIAttr> argABIInfo);
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_SPIRVLOWERING_H
+#endif // MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H

mlir/include/mlir/Dialect/SPIRV/Utils/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.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines utilities used to get alignment and layout information for
 // 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>
 
 namespace mlir {
 class Type;
 class VectorType;
 
 namespace spirv {
static spirv::StructType decorateType(spirv::StructType structType,
                                         Size &size, Size &alignment);
 
   /// Calculates the alignment for the given scalar type.
   static Size getScalarTypeAlignment(Type scalarType);
 };
 
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_LAYOUTUTILS_H_
+#endif // MLIR_DIALECT_SPIRV_UTILS_LAYOUTUTILS_H_

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SCF/SCF.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/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {

mlir/include/mlir/InitAllPasses.h

 #include "mlir/Conversion/Passes.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Async/Passes.h"
 #include "mlir/Dialect/GPU/Passes.h"
 #include "mlir/Dialect/LLVMIR/Transforms/Passes.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Quant/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/StandardOps/Transforms/Passes.h"
 #include "mlir/Dialect/Tensor/Transforms/Passes.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Transforms/Passes.h"
 
 #include <cstdlib>
 

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

 //===- SPIRVBinaryUtils.cpp - SPIR-V Binary Module Utils --------*- 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 common utilities for SPIR-V binary module.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef 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 <cstdint>
 
 namespace mlir {
 namespace spirv {
 
 /// SPIR-V binary header word count

mlir/lib/Conversion/GPUToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRGPUToSPIRVTransforms
   MLIRGPUToSPIRVIncGen
 
   LINK_LIBS PUBLIC
   MLIRGPU
   MLIRIR
   MLIRPass
   MLIRSCFToSPIRV
   MLIRSPIRV
+  MLIRSPIRVConversion
   MLIRStandard
   MLIRStandardToSPIRVTransforms
   MLIRSupport
   MLIRTransforms
   )

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

 //===- ConvertGPUToSPIRV.cpp - Convert GPU ops to SPIR-V dialect ----------===//
 //
 // 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 implements the conversion patterns from GPU ops to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/IR/BuiltinOps.h"
 
 using namespace mlir;
 
 static constexpr const char kSPIRVModule[] = "__spv__";
 
 namespace {
 /// Pattern lowering GPU block/thread size/id to loading SPIR-V invocation

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.cpp

 
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
 #include "../PassDetail.h"
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h"
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
 using namespace mlir;
 
 namespace {
 /// 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
 /// gpu.launch_func ops. For each such function
 ///

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.td

 //===-- GPUToSPIRV.td - GPU to SPIR-V Dialect Lowerings ----*- tablegen -*-===//
 //
 // 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 contains patterns to lower GPU dialect ops to to SPIR-V ops.
 //
 //===----------------------------------------------------------------------===//
 
 
-#ifndef CONVERT_GPU_TO_SPIRV
-#define CONVERT_GPU_TO_SPIRV
+#ifndef MLIR_CONVERSION_GPU_TO_SPIRV
+#define MLIR_CONVERSION_GPU_TO_SPIRV
 
 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)>;
 
-#endif // CONVERT_GPU_TO_SPIRV
+#endif // MLIR_CONVERSION_GPU_TO_SPIRV

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

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

mlir/lib/Conversion/LinalgToSPIRV/CMakeLists.txt

add_mlir_conversion_library(MLIRLinalgToSPIRVTransforms
   MLIRConversionPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRLinalg
   MLIRLinalgUtils
   MLIRPass
   MLIRSPIRV
+  MLIRSPIRVConversion
   MLIRSupport
   )

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

 //===- LinalgToSPIRV.cpp - Linalg to SPIR-V dialect conversion ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Utilities

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

 //===- LinalgToSPIRVPass.cpp - Linalg to SPIR-V conversion pass -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
 #include "../PassDetail.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Linalg ops into SPIR-V ops.
 class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
   void runOnOperation() override;
 };

mlir/lib/Conversion/SCFToSPIRV/CMakeLists.txt

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

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp

 //===- SCFToSPIRV.cpp - Convert SCF ops to SPIR-V dialect -----------------===//
 //
 // 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 implements the conversion patterns from SCF ops to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
 #include "mlir/Dialect/SCF/SCF.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/IR/BuiltinOps.h"
 
 using namespace mlir;
 
 namespace mlir {
 struct ScfToSPIRVContextImpl {
   // Map between the spirv region control flow operation (spv.loop or
   // spv.selection) to the VariableOp created to store the region results. The

mlir/lib/Conversion/SPIRVToLLVM/CMakeLists.txt

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

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
 #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h"
 #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Dialect/GPU/GPUDialect.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/IR/BuiltinOps.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/FormatVariadic.h"
 

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

 //===- ConvertSPIRVToLLVM.cpp - SPIR-V dialect to LLVM dialect conversion -===//
 //
 // 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 implements patterns to convert SPIR-V dialect to LLVM dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/SPIRV/LayoutUtils.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.cpp

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

mlir/lib/Conversion/StandardToSPIRV/CMakeLists.txt

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

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

 //===- ConvertStandardToSPIRV.cpp - Standard to SPIR-V dialect conversion--===//
 //
 // 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 implements patterns to convert standard ops to SPIR-V ops.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/LayoutUtils.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "std-to-spirv-pattern"
 

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.cpp

 //===- ConvertStandardToSPIRVPass.cpp - Convert Std Ops to SPIR-V Ops -----===//
 //
 // 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 implements a pass to convert MLIR standard ops into the SPIR-V
 // ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
 #include "../PassDetail.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Standard operations into the SPIR-V dialect.
 class ConvertStandardToSPIRVPass
     : public ConvertStandardToSPIRVBase<ConvertStandardToSPIRVPass> {
   void runOnOperation() override;

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

 //===- LegalizeStandardForSPIRV.cpp - Legalize ops for SPIR-V lowering ----===//
 //
 // 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 transformation pass legalizes operations before the conversion to SPIR-V
 // dialect to handle ops that cannot be lowered directly.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.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/Vector/VectorOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {

mlir/lib/Conversion/VectorToSPIRV/CMakeLists.txt

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

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

 //===------- VectorToSPIRV.cpp - Vector to SPIRV lowering passes ----------===//
 //
 // 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 implements a pass to generate SPIRV operations for Vector
 // operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../PassDetail.h"
 #include "mlir/Conversion/VectorToSPIRV/ConvertVectorToSPIRV.h"
 #include "mlir/Conversion/VectorToSPIRV/ConvertVectorToSPIRVPass.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
 namespace {
 struct VectorBroadcastConvert final

mlir/lib/Dialect/SPIRV/CMakeLists.txt

-
-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(IR)
 add_subdirectory(Linking)
 add_subdirectory(Transforms)
+add_subdirectory(Utils)

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

-
 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
+  SPIRVEnums.cpp
   SPIRVOps.cpp
-  SPIRVLowering.cpp
   SPIRVTypes.cpp
   TargetAndABI.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
 
   DEPENDS
+  MLIRSPIRVAttrUtilsGen
   MLIRSPIRVAvailabilityIncGen
   MLIRSPIRVCanonicalizationIncGen
   MLIRSPIRVEnumAvailabilityIncGen
   MLIRSPIRVEnumsIncGen
   MLIRSPIRVOpsIncGen
-  MLIRSPIRVOpUtilsGen
   MLIRSPIRVTargetAndABIIncGen
 
   LINK_LIBS PUBLIC
   MLIRControlFlowInterfaces
   MLIRIR
   MLIRParser
   MLIRSideEffectInterfaces
   MLIRSupport
   MLIRTransforms
-  )
-
-add_subdirectory(Linking)
-add_subdirectory(Transforms)

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

 //===- SPIRVAttributes.cpp - SPIR-V attribute definitions -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 
 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
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/TargetAndABI.cpp.inc"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.cpp.inc"
 
 namespace mlir {
 
 //===----------------------------------------------------------------------===//
 // Attribute storage classes
 //===----------------------------------------------------------------------===//
 
 namespace spirv {

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

 //===- SPIRVCanonicalization.cpp - MLIR SPIR-V canonicalization patterns --===//
 //
 // 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 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/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Common utility functions
 //===----------------------------------------------------------------------===//
bool onlyContainsBranchConditionalOp(Block *block) const {
     return std::next(block->begin()) == block->end() &&
            isa<spirv::BranchConditionalOp>(block->front());
   }
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
     return lhs->getAttrDictionary() == rhs->getAttrDictionary();
   }
 
-
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.value();
   }
 
   // Returns a destination value for the given block.
   Value getDstPtr(Block *block) const {

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

 //==- SPIRVCanonicalization.td - Canonicalization Patterns ---*- tablegen -*==//
 
 // 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 SPIR-V canonicalization patterns.
 //
 //===----------------------------------------------------------------------===//
 
-include "mlir/Dialect/SPIRV/SPIRVOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVOps.td"
 
 //===----------------------------------------------------------------------===//
 // spv.Bitcast
 //===----------------------------------------------------------------------===//
 
 def ConvertChainedBitcast : Pat<(SPV_BitcastOp (SPV_BitcastOp $operand)),
                                 (SPV_BitcastOp $operand)>;
 

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

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

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

+//===- 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

 //===- SPIRVOps.cpp - MLIR SPIR-V operations ------------------------------===//
 //
 // 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 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/SPIRVAttributes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
-#include "mlir/Dialect/SPIRV/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/IR/ParserUtils.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/bit.h"
static LogicalResult verify(spirv::SpecConstantOperationOp constOp) {
   return success();
 }
 
 namespace mlir {
 namespace spirv {
 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
-#include "mlir/Dialect/SPIRV/SPIRVAvailability.cpp.inc"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAvailability.cpp.inc"
 } // namespace spirv
 } // namespace mlir
 
 // TablenGen'erated operation definitions.
 #define GET_OP_CLASSES
-#include "mlir/Dialect/SPIRV/SPIRVOps.cpp.inc"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
 
 namespace mlir {
 namespace spirv {
 // TableGen'erated operation availability interface implementations.
-#include "mlir/Dialect/SPIRV/SPIRVOpAvailabilityImpl.inc"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOpAvailabilityImpl.inc"
 
 } // namespace spirv
 } // namespace mlir

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

 //===- SPIRVTypes.cpp - MLIR SPIR-V Types ---------------------------------===//
 //
 // 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 types in the SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Identifier.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"
 
 using namespace mlir;
 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
 //===----------------------------------------------------------------------===//
 
 struct spirv::detail::ArrayTypeStorage : public TypeStorage {
   using KeyTy = std::tuple<Type, unsigned, unsigned>;
 
   static ArrayTypeStorage *construct(TypeStorageAllocator &allocator,
void CooperativeMatrixNVType::getCapabilities(
   ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // ImageType
 //===----------------------------------------------------------------------===//
 
-template <typename T> static constexpr unsigned getNumBits() { return 0; }
-template <> constexpr unsigned getNumBits<Dim>() {
+template <typename T>
+static constexpr unsigned getNumBits() {
+  return 0;
+}
+template <>
+constexpr unsigned getNumBits<Dim>() {
   static_assert((1 << 3) > getMaxEnumValForDim(),
                 "Not enough bits to encode Dim value");
   return 3;
 }
-template <> constexpr unsigned getNumBits<ImageDepthInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageDepthInfo>() {
   static_assert((1 << 2) > getMaxEnumValForImageDepthInfo(),
                 "Not enough bits to encode ImageDepthInfo value");
   return 2;
 }
-template <> constexpr unsigned getNumBits<ImageArrayedInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageArrayedInfo>() {
   static_assert((1 << 1) > getMaxEnumValForImageArrayedInfo(),
                 "Not enough bits to encode ImageArrayedInfo value");
   return 1;
 }
-template <> constexpr unsigned getNumBits<ImageSamplingInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageSamplingInfo>() {
   static_assert((1 << 1) > getMaxEnumValForImageSamplingInfo(),
                 "Not enough bits to encode ImageSamplingInfo value");
   return 1;
 }
-template <> constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
   static_assert((1 << 2) > getMaxEnumValForImageSamplerUseInfo(),
                 "Not enough bits to encode ImageSamplerUseInfo value");
   return 2;
 }
-template <> constexpr unsigned getNumBits<ImageFormat>() {
+template <>
+constexpr unsigned getNumBits<ImageFormat>() {
   static_assert((1 << 6) > getMaxEnumValForImageFormat(),
                 "Not enough bits to encode ImageFormat value");
   return 6;
 }
 
 struct spirv::detail::ImageTypeStorage : public TypeStorage {
 public:
   using KeyTy = std::tuple<Type, Dim, ImageDepthInfo, ImageArrayedInfo,

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

 //===- TargetAndABI.cpp - SPIR-V target and ABI utilities -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/TargetAndABI.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/FunctionSupport.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//

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

 //===- ModuleCombiner.cpp - MLIR SPIR-V Module Combiner ---------*- 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 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/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace mlir;
 

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
-  DecorateSPIRVCompositeTypeLayoutPass.cpp
+  DecorateCompositeTypeLayoutPass.cpp
   LowerABIAttributesPass.cpp
   RewriteInsertsPass.cpp
   UpdateVCEPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
 
   DEPENDS
   MLIRSPIRVPassIncGen
 
   LINK_LIBS PUBLIC
   MLIRPass
-  MLIRSPIRV
-  )
+  MLIRSPIRVConversion
+  MLIRSPIRVUtils

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.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.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to decorate the composite types used by
 // composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and
 // PushConstant storage classes with layout information. See SPIR-V spec
 // "2.16.2. Validation Rules for Shader Capabilities" for more details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
-#include "mlir/Dialect/SPIRV/LayoutUtils.h"
-#include "mlir/Dialect/SPIRV/Passes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
 namespace {
 class SPIRVGlobalVariableOpLayoutInfoDecoration
     : public OpRewritePattern<spirv::GlobalVariableOp> {
 public:

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

 //===- LowerABIAttributesPass.cpp - Decorate composite type ---------------===//
 //
 // 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 implements a pass to lower attributes that specify the shader ABI
 // for the functions in the generated SPIR-V module.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
-#include "mlir/Dialect/SPIRV/LayoutUtils.h"
-#include "mlir/Dialect/SPIRV/Passes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
 /// Creates a global variable for an argument based on the ABI info.
 static spirv::GlobalVariableOp
 createGlobalVarForEntryPointArgument(OpBuilder &builder, spirv::FuncOp funcOp,

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

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

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

 //===- RewriteInsertsPass.cpp - MLIR conversion pass ----------------------===//
 //
 // 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 implements a pass to rewrite sequential chains of
 // `spirv::CompositeInsert` operations into `spirv::CompositeConstruct`
 // operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
-#include "mlir/Dialect/SPIRV/Passes.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 
 using namespace mlir;
 
 namespace {
 
 /// Replaces sequential chains of `spirv::CompositeInsertOp` operation into

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.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.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements utilities used to lower to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/LayoutUtils.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Debug.h"
 
 #include <functional>
 
-#define DEBUG_TYPE "mlir-spirv-lowering"
+#define DEBUG_TYPE "mlir-spirv-conversion"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
 /// Checks that `candidates` extension requirements are possible to be satisfied

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

 //===- DeduceVersionExtensionCapabilityPass.cpp ---------------------------===//
 //
 // 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 implements a pass to deduce minimal version/extension/capability
 // requirements for a spirv::ModuleOp.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
-#include "mlir/Dialect/SPIRV/Passes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
-#include "mlir/Dialect/SPIRV/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Visitors.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 
 using namespace mlir;
 
 namespace {

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

+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

 //===-- LayoutUtils.cpp - Decorate composite type with layout information -===//
 //
 // 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 implements Utilities used to get alignment and layout information
 // for types in SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
-#include "mlir/Dialect/SPIRV/LayoutUtils.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+
+#include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 
 using namespace mlir;
 
 spirv::StructType
 VulkanLayoutUtils::decorateType(spirv::StructType structType) {
   Size size = 0;
   Size alignment = 1;
   return decorateType(structType, size, alignment);

mlir/lib/Target/SPIRV/Deserialization.cpp

 //===- Deserializer.cpp - MLIR SPIR-V Deserialization ---------------------===//
 //
 // 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 SPIR-V binary to MLIR SPIR-V module deserialization.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/SPIRV/Deserialization.h"
 
-#include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
-#include "mlir/Dialect/SPIRV/SPIRVModule.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
Deserializer::processOp<spirv::CopyMemoryOp>(ArrayRef<uint32_t> words) {
   opBuilder.create<spirv::CopyMemoryOp>(loc, resultTypes, operands, attributes);
 
   return success();
 }
 
 // Pull in auto-generated Deserializer::dispatchToAutogenDeserialization() and
 // various Deserializer::processOp<...>() specializations.
 #define GET_DESERIALIZATION_FNS
-#include "mlir/Dialect/SPIRV/SPIRVSerialization.inc"
+#include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
 } // namespace
 
 namespace mlir {
 spirv::OwningSPIRVModuleRef spirv::deserialize(ArrayRef<uint32_t> binary,
                                                MLIRContext *context) {
   Deserializer deserializer(binary, context);
 
   if (failed(deserializer.deserialize()))
     return nullptr;
 
   return deserializer.collect();
 }
 } // namespace mlir

mlir/lib/Target/SPIRV/SPIRVBinaryUtils.cpp

 //===- SPIRVBinaryUtils.cpp - MLIR SPIR-V Binary Module Utilities ---------===//
 //
 // 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 common utilities for SPIR-V binary module.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 
 using namespace mlir;
 
 void spirv::appendModuleHeader(SmallVectorImpl<uint32_t> &header,
                                spirv::Version version, uint32_t idBound) {
   uint32_t majorVersion = 1;
   uint32_t minorVersion = 0;
   switch (version) {

mlir/lib/Target/SPIRV/Serialization.cpp

 //===- Serializer.cpp - MLIR SPIR-V Serialization -------------------------===//
 //
 // 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 MLIR SPIR-V module to SPIR-V binary serialization.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/SPIRV/Serialization.h"
 
-#include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
Serializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
   encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory, operands);
 
   return success();
 }
 
 // Pull in auto-generated Serializer::dispatchToAutogenSerialization() and
 // various Serializer::processOp<...>() specializations.
 #define GET_SERIALIZATION_FNS
-#include "mlir/Dialect/SPIRV/SPIRVSerialization.inc"
+#include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
 } // namespace
 
 LogicalResult Serializer::emitDecoration(uint32_t target,
                                          spirv::Decoration decoration,
                                          ArrayRef<uint32_t> params) {
   uint32_t wordCount = 3 + params.size();
   decorations.push_back(
       spirv::getPrefixedOpcode(wordCount, spirv::Opcode::OpDecorate));

mlir/lib/Target/SPIRV/TranslateRegistration.cpp

 //===- TranslateRegistration.cpp - hooks to mlir-translate ----------------===//
 //
 // 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 implements a translation from SPIR-V binary module to MLIR SPIR-V
 // ModuleOp.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVModule.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Parser.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Target/SPIRV/Deserialization.h"
 #include "mlir/Target/SPIRV/Serialization.h"
 #include "mlir/Translation.h"

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

add_mlir_library(MLIRSPIRVTestPasses
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
 
   LINK_LIBS PUBLIC
   MLIRGPU
   MLIRIR
   MLIRPass
   MLIRSPIRV
+  MLIRSPIRVConversion
   MLIRSPIRVModuleCombiner
   MLIRSupport
   )

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

 //===- TestAvailability.cpp - Pass to test SPIR-V op availability ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/SPIRVLowering.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Printing op availability pass
 //===----------------------------------------------------------------------===//

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

 //===- TestAvailability.cpp - Test pass for setting Entry point ABI info --===//
 //
 // 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 implements a pass that sets the spv.entry_point_abi attribute on
 // functions that are to be lowered as entry point functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/GPU/GPUDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/TargetAndABI.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// Pass to set the spv.entry_point_abi
 class TestSpirvEntryPointABIPass
     : public PassWrapper<TestSpirvEntryPointABIPass,

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

 //===- TestModuleCombiner.cpp - Pass to test SPIR-V module combiner lib ---===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/ModuleCombiner.h"
-
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/Linking/ModuleCombiner.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 class TestModuleCombinerPass

mlir/test/lib/Transforms/TestGpuMemoryPromotion.cpp

 //===- TestGPUMemoryPromotionPass.cpp - Test pass for GPU promotion -------===//
 //
 // 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 implements the pass testing the utilities for moving data across
 // different levels of the GPU memory hierarchy.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/GPU/MemoryPromotion.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/IR/Attributes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 /// Simple pass for testing the promotion to workgroup memory in GPU functions.

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

-set(LLVM_OPTIONAL_SOURCES
-  mlir-spirv-cpu-runner.cpp
-  )
+set(LLVM_LINK_COMPONENTS
+  Linker
 
 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
     mlir-spirv-cpu-runner.cpp
   )
 
   llvm_update_compile_flags(mlir-spirv-cpu-runner)
 
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)

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

 // JIT-compiling and executing.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
 #include "mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/GPU/Passes.h"
-#include "mlir/Dialect/SPIRV/Passes.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/ExecutionEngine/JitRunner.h"
 #include "mlir/ExecutionEngine/OptUtils.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR.h"
 
 #include "llvm/IR/LLVMContext.h"

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

os << formatv("template <> inline StringRef attributeName<{0}>() {{\n",
                 enumName);
   os << "  "
      << formatv("static constexpr const char attrName[] = \"{0}\";\n",
                 llvm::convertToSnakeFromCamelCase(enumName));
   os << "  return attrName;\n";
   os << "}\n";
 }
 
-static bool emitOpUtils(const RecordKeeper &recordKeeper, raw_ostream &os) {
-  llvm::emitSourceFileHeader("SPIR-V Op Utilities", os);
+static bool emitAttrUtils(const RecordKeeper &recordKeeper, raw_ostream &os) {
+  llvm::emitSourceFileHeader("SPIR-V Attribute Utilities", os);
 
   auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");
-  os << "#ifndef SPIRV_OP_UTILS_H_\n";
-  os << "#define SPIRV_OP_UTILS_H_\n";
+  os << "#ifndef MLIR_DIALECT_SPIRV_IR_ATTR_UTILS_H_\n";
+  os << "#define MLIR_DIALECT_SPIRV_IR_ATTR_UTILS_H_\n";
   emitEnumGetAttrNameFnDecl(os);
   for (const auto *def : defs) {
     EnumAttr enumAttr(*def);
     emitEnumGetAttrNameFnDefn(enumAttr, os);
   }
-  os << "#endif // SPIRV_OP_UTILS_H\n";
+  os << "#endif // MLIR_DIALECT_SPIRV_IR_ATTR_UTILS_H\n";
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // Op Utils Hook Registration
 //===----------------------------------------------------------------------===//
 
 static mlir::GenRegistration
-    genOpUtils("gen-spirv-op-utils",
-               "Generate SPIR-V operation utility definitions",
+    genOpUtils("gen-spirv-attr-utils",
+               "Generate SPIR-V attribute utility definitions",
                [](const RecordKeeper &records, raw_ostream &os) {
-                 return emitOpUtils(records, os);
+                 return emitAttrUtils(records, os);
                });
 
 //===----------------------------------------------------------------------===//
 // SPIR-V Availability Impl AutoGen
 //===----------------------------------------------------------------------===//
 
 static void emitAvailabilityImpl(const Operator &srcOp, raw_ostream &os) {
   mlir::tblgen::FmtContext fctx;

 //===----------------------------------------------------------------------===//
 
 static bool emitCapabilityImplication(const RecordKeeper &recordKeeper,
                                       raw_ostream &os) {
   llvm::emitSourceFileHeader("SPIR-V Capability Implication", os);
 
   EnumAttr enumAttr(recordKeeper.getDef("SPV_CapabilityAttr"));
 
-  os << "ArrayRef<Capability> "
-        "spirv::getDirectImpliedCapabilities(Capability cap) {\n"
+  os << "ArrayRef<spirv::Capability> "
+        "spirv::getDirectImpliedCapabilities(spirv::Capability cap) {\n"
      << "  switch (cap) {\n"
      << "  default: return {};\n";
   for (const EnumAttrCase &enumerant : enumAttr.getAllCases()) {
     const Record &def = enumerant.getDef();
     if (!def.getValue("implies"))
       continue;
 
     std::vector<Record *> impliedCapsDefs = def.getValueAsListOfDefs("implies");
-    os << "  case Capability::" << enumerant.getSymbol()
-       << ": {static const Capability implies[" << impliedCapsDefs.size()
+    os << "  case spirv::Capability::" << enumerant.getSymbol()
+       << ": {static const spirv::Capability implies[" << impliedCapsDefs.size()
        << "] = {";
     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()
-       << "); }\n";
+    os << "}; return ArrayRef<spirv::Capability>(implies, "
+       << impliedCapsDefs.size() << "); }\n";
   }
   os << "  }\n";
   os << "}\n";
 
   return false;
 }
 
 //===----------------------------------------------------------------------===//

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

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

mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp

 //===- DeserializationTest.cpp - SPIR-V Deserialization Tests -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // The purpose of this file is to provide negative deserialization tests.
 // For positive deserialization tests, please use serialization and
 // deserialization for roundtripping.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/SPIRV/Deserialization.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVModule.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
 #include "gmock/gmock.h"
 
 #include <memory>
 
 using namespace mlir;

mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

 //===- SerializationTest.cpp - SPIR-V Serialization Tests -----------------===//
 //
 // 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 contains corner case tests for the SPIR-V serializer that are not
 // covered by normal serialization and deserialization roundtripping.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Target/SPIRV/Serialization.h"
-#include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
-#include "mlir/Dialect/SPIRV/SPIRVDialect.h"
-#include "mlir/Dialect/SPIRV/SPIRVModule.h"
-#include "mlir/Dialect/SPIRV/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/SPIRVTypes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVModule.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Target/SPIRV/SPIRVBinaryUtils.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallVector.h"