[MLIR][SPIRVToLLVM] Conversion of SPIR-V struct type without offset

[georgemitenkov]

Summary

This patch introduces type conversion for SPIR-V structs. Since handling offset case requires thorough testing, it was left out (for the next patch). Hence, only structs with no offset are currently supported.

[antiagainst]

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

41

Should this also be marked as not supported at the moment? We might lose information by just ignoring decorations. We can getMemberDecorations and make sure it's empty at the moment.

[antiagainst]

Feel free to submit after fixing the above issue.

[georgemitenkov]

Added a check if struct member decorations are empty. In this case conversion fails.

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);
 }
 
+/// Converts SPIR-V struct with no offset to packed LLVM struct.
+static Type convertStructTypePacked(spirv::StructType type,
+                                    LLVMTypeConverter &converter) {
+  auto elementsVector = llvm::to_vector<8>(
+      llvm::map_range(type.getElementTypes(), [&](Type elementType) {
+        return converter.convertType(elementType).cast<LLVM::LLVMType>();
+      }));
+  return LLVM::LLVMType::getStructTy(converter.getDialect(), elementsVector,
+                                     /*isPacked=*/true);
+}
+
 //===----------------------------------------------------------------------===//
 // 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) {
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);
 }
 
+/// Converts SPIR-V struct to LLVM struct. There is no support of structs with
+/// member decorations or with offset.
+static Optional<Type> convertStructType(spirv::StructType type,
+                                        LLVMTypeConverter &converter) {
+  SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
+  type.getMemberDecorations(memberDecorations);
+  if (type.hasOffset() || !memberDecorations.empty())
+    return llvm::None;
+  return convertStructTypePacked(type, converter);
+}
+
 //===----------------------------------------------------------------------===//
 // Operation conversion
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
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);
   });
+  typeConverter.addConversion([&](spirv::StructType type) {
+    return convertStructType(type, typeConverter);
+  });
 }
 
 void mlir::populateSPIRVToLLVMConversionPatterns(
     MLIRContext *context, LLVMTypeConverter &typeConverter,
     OwningRewritePatternList &patterns) {
   patterns.insert<
       // Arithmetic ops
       DirectConversionPattern<spirv::IAddOp, LLVM::AddOp>,

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
 }
+
+// -----
+
+// expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
+spv.func @struct_with_offset1(%arg: !spv.struct<i32[0], i32[4]>) -> () "None" {
+  spv.Return
+}
+
+// -----
+
+// expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
+spv.func @struct_with_offset2(%arg: !spv.struct<i32[0], i32[8]>) -> () "None" {
+  spv.Return
+}
+
+// -----
+
+// expected-error@+1 {{failed to legalize operation 'spv.func' that was explicitly marked illegal}}
+spv.func @struct_with_decorations(%arg: !spv.struct<f32 [RelaxedPrecision]>) -> () "None" {
+  spv.Return
+}

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

 // 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>) -> ()
+
+//===----------------------------------------------------------------------===//
+// Struct type
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @struct(!llvm<"<{ double }>">)
+func @struct(!spv.struct<f64>) -> ()
+
+// CHECK-LABEL: @struct_nested(!llvm<"<{ i32, <{ i64, i32 }> }>">)
+func @struct_nested(!spv.struct<i32, !spv.struct<i64, i32>>)