[MLIR][SPIRVToLLVM] Conversion of SPIR-V array, runtime array, and pointer types

[georgemitenkov]

Summary

This patch adds type conversion for 4 SPIR-V types: array, runtime array, pointer and struct. This conversion is integrated using a separate function populateSPIRVToLLVMTypeConversion() that adds new type conversions. At the moment, this is a basic skeleton that allows to perfom conversion from SPIR-V array, runtime array and pointer types to LLVM typesystem. There is no support of array strides or storage classes. These will be supported on the case by case basis.

mlir/include/mlir/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.h

SPIRVToLLVMConversion(MLIRContext *context, LLVMTypeConverter &typeConverter,
                         PatternBenefit benefit = 1)
       : OpConversionPattern<SPIRVOp>(context, benefit),
         typeConverter(typeConverter) {}
 
 protected:
   LLVMTypeConverter &typeConverter;
 };
 
+/// Populates type conversions with additional SPIR-V types.
+void populateSPIRVToLLVMTypeConversion(LLVMTypeConverter &typeConverter);
+
 /// Populates the given list with patterns that convert from SPIR-V to LLVM.
 void populateSPIRVToLLVMConversionPatterns(MLIRContext *context,
                                            LLVMTypeConverter &typeConverter,
                                            OwningRewritePatternList &patterns);
 
 /// Populates the given list with patterns for function conversion from SPIR-V
 /// to LLVM.
 void populateSPIRVToLLVMFunctionConversionPatterns(

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

static Value processCountOrOffset(Location loc, Value value, Type srcType,
                                   Type dstType, LLVMTypeConverter &converter,
                                   ConversionPatternRewriter &rewriter) {
   Value broadcasted =
       optionallyBroadcast(loc, value, srcType, converter, rewriter);
   return optionallyTruncateOrExtend(loc, broadcasted, dstType, rewriter);
 }
 
 //===----------------------------------------------------------------------===//
+// Type conversion
+//===----------------------------------------------------------------------===//
+
+/// Converts SPIR-V array type to LLVM array. There is no modelling of array
+/// stride at the moment.
+static Optional<Type> convertArrayType(spirv::ArrayType type,
+                                       TypeConverter &converter) {
+  if (type.getArrayStride() != 0)
+    return llvm::None;
+  auto elementType =
+      converter.convertType(type.getElementType()).cast<LLVM::LLVMType>();
+  unsigned numElements = type.getNumElements();
+  return LLVM::LLVMType::getArrayTy(elementType, numElements);
+}
+
+/// Converts SPIR-V pointer type to LLVM pointer. Pointer's storage class is not
+/// modelled at the moment.
+static Type convertPointerType(spirv::PointerType type,
+                               TypeConverter &converter) {
+  auto pointeeType =
+      converter.convertType(type.getPointeeType()).cast<LLVM::LLVMType>();
+  return pointeeType.getPointerTo();
+}
+
+/// Converts SPIR-V runtime array to LLVM array. Since LLVM allows indexing over
+/// the bounds, the runtime array is converted to a 0-sized LLVM array. There is
+/// no modelling of array stride at the moment.
+static Optional<Type> convertRuntimeArrayType(spirv::RuntimeArrayType type,
+                                              TypeConverter &converter) {
+  if (type.getArrayStride() != 0)
+    return llvm::None;
+  auto elementType =
+      converter.convertType(type.getElementType()).cast<LLVM::LLVMType>();
+  return LLVM::LLVMType::getArrayTy(elementType, 0);
+}
+
+//===----------------------------------------------------------------------===//
 // Operation conversion
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
 public:
matchAndRewrite(spirv::FuncOp funcOp, ArrayRef<Value> operands,
 
     // Convert function signature. At the moment LLVMType converter is enough
     // for currently supported types.
     auto funcType = funcOp.getType();
     TypeConverter::SignatureConversion signatureConverter(
         funcType.getNumInputs());
     auto llvmType = this->typeConverter.convertFunctionSignature(
         funcOp.getType(), /*isVariadic=*/false, signatureConverter);
+    if (!llvmType)
+      return failure();
 
     // Create a new `LLVMFuncOp`
     Location loc = funcOp.getLoc();
     StringRef name = funcOp.getName();
     auto newFuncOp = rewriter.create<LLVM::LLVMFuncOp>(loc, name, llvmType);
 
     // Convert SPIR-V Function Control to equivalent LLVM function attribute
     MLIRContext *context = funcOp.getContext();

 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
+void mlir::populateSPIRVToLLVMTypeConversion(LLVMTypeConverter &typeConverter) {
+  typeConverter.addConversion([&](spirv::ArrayType type) {
+    return convertArrayType(type, typeConverter);
+  });
+  typeConverter.addConversion([&](spirv::PointerType type) {
+    return convertPointerType(type, typeConverter);
+  });
+  typeConverter.addConversion([&](spirv::RuntimeArrayType type) {
+    return convertRuntimeArrayType(type, typeConverter);
+  });
+}
+
 void mlir::populateSPIRVToLLVMConversionPatterns(
     MLIRContext *context, LLVMTypeConverter &typeConverter,
     OwningRewritePatternList &patterns) {
   patterns.insert<
       // Arithmetic ops
       DirectConversionPattern<spirv::IAddOp, LLVM::AddOp>,
       DirectConversionPattern<spirv::IMulOp, LLVM::MulOp>,
       DirectConversionPattern<spirv::ISubOp, LLVM::SubOp>,

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVMPass.cpp

 } // namespace
 
 void ConvertSPIRVToLLVMPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
   LLVMTypeConverter converter(&getContext());
 
   OwningRewritePatternList patterns;
+
+  populateSPIRVToLLVMTypeConversion(converter);
+
   populateSPIRVToLLVMModuleConversionPatterns(context, converter, patterns);
   populateSPIRVToLLVMConversionPatterns(context, converter, patterns);
   populateSPIRVToLLVMFunctionConversionPatterns(context, converter, patterns);
 
   // Currently pulls in Std to LLVM conversion patterns
   // that help with testing. This allows to convert
   // function arguments to LLVM.
   populateStdToLLVMConversionPatterns(converter, patterns);

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

 }
 
 func @bitcast_vector_to_vector(%arg0 : vector<4xf32>) {
   // CHECK: {{.*}} = llvm.bitcast {{.*}} : !llvm<"<4 x float>"> to !llvm<"<2 x i64>">
   %0 = spv.Bitcast %arg0: vector<4xf32> to vector<2xi64>
   return
 }
 
+func @bitcast_pointer(%arg0: !spv.ptr<f32, Function>) {
+  // CHECK: %{{.*}} = llvm.bitcast %{{.*}} : !llvm<"float*"> to !llvm<"i32*">
+  %0 = spv.Bitcast %arg0 : !spv.ptr<f32, Function> to !spv.ptr<i32, Function>
+  return
+}
+
 //===----------------------------------------------------------------------===//
 // spv.ConvertFToS
 //===----------------------------------------------------------------------===//
 
 func @convert_float_to_signed_scalar(%arg0: f32) {
   // CHECK: %{{.*}} = llvm.fptosi %{{.*}} : !llvm.float to !llvm.i32
     %0 = spv.ConvertFToS %arg0: f32 to i32
   return

mlir/test/Conversion/SPIRVToLLVM/spirv-types-to-llvm.invalid.mlir

+// RUN: mlir-opt %s -convert-spirv-to-llvm -verify-diagnostics -split-input-file
+
+// expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
+spv.func @array_with_stride(%arg: !spv.array<4 x f32, stride=4>) -> () "None" {
+  spv.Return
+}

mlir/test/Conversion/SPIRVToLLVM/spirv-types-to-llvm.mlir

+// RUN: mlir-opt -split-input-file -convert-spirv-to-llvm -verify-diagnostics %s | FileCheck %s
+
+//===----------------------------------------------------------------------===//
+// Array type
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @array(!llvm<"[16 x float]">, !llvm<"[32 x <4 x float>]">)
+func @array(!spv.array<16xf32>, !spv.array< 32 x vector<4xf32> >) -> ()
+
+//===----------------------------------------------------------------------===//
+// Pointer type
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @pointer_scalar(!llvm<"i1*">, !llvm<"float*">)
+func @pointer_scalar(!spv.ptr<i1, Uniform>, !spv.ptr<f32, Private>) -> ()
+
+// CHECK-LABEL: @pointer_vector(!llvm<"<4 x i32>*">)
+func @pointer_vector(!spv.ptr<vector<4xi32>, Function>) -> ()
+
+//===----------------------------------------------------------------------===//
+// Runtime array type
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @runtime_array_vector(!llvm<"[0 x <4 x float>]">)
+func @runtime_array_vector(!spv.rtarray< vector<4xf32> >) -> ()
+
+// CHECK-LABEL: @runtime_array_scalar(!llvm<"[0 x float]">)
+func @runtime_array_scalar(!spv.rtarray<f32>) -> ()