[MLIR][SPIRVToLLVM] Conversion for global and addressof

[georgemitenkov]

Summary

Inital conversion of spv._address_of and spv.globalVariable.
In SPIR-V, the global returns a pointer, whereas in LLVM dialect the global
holds an actual value. This difference is handled by spv._address_of and
llvm.mlir.addressofops that both return a pointer. Moreover, only current
invocation is in conversion's scope.

[antiagainst]

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

539

considered as

560

I think External is not correct for Private storage class. Private storage class can only be accessed by the current module so it should map to LLVM private linkage?

[georgemitenkov]

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

560

@antiagainst That's right! What about other storage classes?
Based on SPIR-V spec:

By default, functions and global variables are private to a module and cannot be accessed by other modules. However, a module may be written to export or import functions and global (module scope) variables. Imported functions and global variable definitions are resolved at linkage time. A module is considered to be partially linked if it depends on imported values. Within a module, imported or exported values are decorated using the Linkage Attributes Decoration.

This means that Private linkage should be the default for all, and it is the linkage decoration that specifies if the variable is Import/Export?

[georgemitenkov]

Fixed a typo and handled linkage properly.

[mravishankar]

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

527

Comment is misleading. The SPIR-V spec returns an SSA value. In SPIR-V dialect GlobalVariable is a Symbol. Not sure what LLVM dialect holds an actual value means though. AFAIK, the LLVM global variable and SPIR-V global variable are the same and the address of act the same way?

559

I am confused why input is chosen as a constant. I might be missing something here (or maybe just the naming is throwing me off), but Input seems to be more like a Global Variable that is externally defined and used internally (I dont know off the top of my head if there is a further qualifier that makes it externally defined but not modified within an LLVM module). SPIR-V constants map more directly to LLVM constants.

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

13

Please group all the CHECK comments together. Its easier to read that way.

[georgemitenkov]

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

527

spv._address_of acts the same way indeed. What I meant here is that spv.globalVariable's type is a pointer, whereas llvm.mlir.global op's type is the pointee's type.
Hence we need to do this before type conversion

globalOp.type().cast<spirv::PointerType>().getPointeeType()

to later build llvm.mlir.global.

559

It is still a LLVM global but just with a constant flag. Based on LLVM dialect spec, if the global value is a constant, storing into it is not allowed. I think that by "is a constant" it means that it has a constant attribute.
Since Input variables are

read-only, and cannot have initializers

per SPIR-V spec, we add constant attribute to llvm.mlir.global?

[georgemitenkov]

Put CHECK statements in one block.

[mravishankar]

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

559

THanks for the clarification! That makes sense to me.

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

13

THanks. Super Nit, typically I have seen

CHECK-LABEL:
    CHECK:

instead. But this is as good.

[antiagainst]

Sorry for the delay! For future patches, please feel free to land once you've gotten Mahesh's approval; no need to wait for mine.

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Operation conversion
 //===----------------------------------------------------------------------===//
 
 namespace {
 
+class AddressOfPattern : public SPIRVToLLVMConversion<spirv::AddressOfOp> {
+public:
+  using SPIRVToLLVMConversion<spirv::AddressOfOp>::SPIRVToLLVMConversion;
+
+  LogicalResult
+  matchAndRewrite(spirv::AddressOfOp op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    auto dstType = typeConverter.convertType(op.pointer().getType());
+    if (!dstType)
+      return failure();
+    rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(
+        op, dstType.cast<LLVM::LLVMType>(), op.variable());
+    return success();
+  }
+};
+
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldInsertOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(spirv::BitFieldInsertOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
     if (!dstType)
       return failure();
     rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType, operands,
                                                  operation.getAttrs());
     return success();
   }
 };
 
+/// Converts `spv.globalVariable` to `llvm.mlir.global`. Note that SPIR-V global
+/// returns a pointer, whereas in LLVM dialect the global holds an actual value.
+/// This difference is handled by `spv._address_of` and `llvm.mlir.addressof`ops
+/// that both return a pointer.
+class GlobalVariablePattern
+    : public SPIRVToLLVMConversion<spirv::GlobalVariableOp> {
+public:
+  using SPIRVToLLVMConversion<spirv::GlobalVariableOp>::SPIRVToLLVMConversion;
+
+  LogicalResult
+  matchAndRewrite(spirv::GlobalVariableOp op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    // Currently, there is no support of initialization with a constant value in
+    // SPIR-V dialect. Specialization constants are not considered as well.
+    if (op.initializer())
+      return failure();
+
+    auto srcType = op.type().cast<spirv::PointerType>();
+    auto dstType = typeConverter.convertType(srcType.getPointeeType());
+    if (!dstType)
+      return failure();
+
+    // Limit conversion to the current invocation only for now.
+    auto storageClass = srcType.getStorageClass();
+    if (storageClass != spirv::StorageClass::Input &&
+        storageClass != spirv::StorageClass::Private &&
+        storageClass != spirv::StorageClass::Output) {
+      return failure();
+    }
+
+    // LLVM dialect spec: "If the global value is a constant, storing into it is
+    // not allowed.". This corresponds to SPIR-V 'Input' storage class that is
+    // read-only.
+    bool isConstant = storageClass == spirv::StorageClass::Input;
+    // SPIR-V spec: "By default, functions and global variables are private to a
+    // module and cannot be accessed by other modules. However, a module may be
+    // written to export or import functions and global (module scope)
+    // variables.". Therefore, map 'Private' storage class to private linkage,
+    // 'Input' and 'Output' to external linkage.
+    auto linkage = storageClass == spirv::StorageClass::Private
+                       ? LLVM::Linkage::Private
+                       : LLVM::Linkage::External;
+    rewriter.replaceOpWithNewOp<LLVM::GlobalOp>(
+        op, dstType.cast<LLVM::LLVMType>(), isConstant, linkage, op.sym_name(),
+        Attribute());
+    return success();
+  }
+};
+
 /// Converts SPIR-V cast ops that do not have straightforward LLVM
 /// equivalent in LLVM dialect.
 template <typename SPIRVOp, typename LLVMExtOp, typename LLVMTruncOp>
 class IndirectCastPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
patterns.insert<
       // Logical ops
       DirectConversionPattern<spirv::LogicalAndOp, LLVM::AndOp>,
       DirectConversionPattern<spirv::LogicalOrOp, LLVM::OrOp>,
       IComparePattern<spirv::LogicalEqualOp, LLVM::ICmpPredicate::eq>,
       IComparePattern<spirv::LogicalNotEqualOp, LLVM::ICmpPredicate::ne>,
       NotPattern<spirv::LogicalNotOp>,
 
       // Memory ops
-      LoadStorePattern<spirv::LoadOp>, LoadStorePattern<spirv::StoreOp>,
-      VariablePattern,
+      AddressOfPattern, GlobalVariablePattern, LoadStorePattern<spirv::LoadOp>,
+      LoadStorePattern<spirv::StoreOp>, VariablePattern,
 
       // Miscellaneous ops
       DirectConversionPattern<spirv::SelectOp, LLVM::SelectOp>,
       DirectConversionPattern<spirv::UndefOp, LLVM::UndefOp>,
 
       // Shift ops
       ShiftPattern<spirv::ShiftRightArithmeticOp, LLVM::AShrOp>,
       ShiftPattern<spirv::ShiftRightLogicalOp, LLVM::LShrOp>,

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

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
+// spv.globalVariable and spv._address_of
+//===----------------------------------------------------------------------===//
+
+spv.module Logical GLSL450 {
+  // CHECK: llvm.mlir.global external constant @var() : !llvm.float
+  spv.globalVariable @var : !spv.ptr<f32, Input>
+}
+
+spv.module Logical GLSL450 {
+  //       CHECK: llvm.mlir.global private @struct() : !llvm.struct<packed (float, array<10 x float>)>
+  // CHECK-LABEL: @func
+  //       CHECK: llvm.mlir.addressof @struct : !llvm.ptr<struct<packed (float, array<10 x float>)>>
+  spv.globalVariable @struct : !spv.ptr<!spv.struct<f32, !spv.array<10xf32>>, Private>
+  spv.func @func() -> () "None" {
+    %0 = spv._address_of @struct : !spv.ptr<!spv.struct<f32, !spv.array<10xf32>>, Private>
+    spv.Return
+  }
+}
+
+//===----------------------------------------------------------------------===//
 // spv.Load
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @load
 func @load() {
   %0 = spv.Variable : !spv.ptr<f32, Function>
   //  CHECK: llvm.load %{{.*}} : !llvm.ptr<float>
   %1 = spv.Load "Function" %0 : f32