[mlir][LLVMIR] Add support for importing struct-type ConstantAggregate(Zero)

[myhsu]

Summary

We simply translate struct-type ConstantAggregate(Zero) into a serious of llvm.insertvalue operations against a llvm.undef root. Note that this doesn't affect the original logics on translating vector/array-type ConstantAggregate values.
Related discussion: link.

This patch also moves importer test files from test/Target/LLVMIR into test/Target/LLVMIR/Import.

[ftynse]

Nice, thank you!

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

513

524

I see the code around doesn't do this either, but isn't there a way to get some reasonable location info?

526

Please expand auto unless the type is obvious from RHS (e.g., RHS is a cast) or impractical to write (lambdas, iterators).

[myhsu]

minor fixes

[myhsu]

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

524

I think for ConstantAggregate originating from global variable's initializer (which is the common case), we can use the DebugLoc from the associated GlobalVariable. Thus, one possible solution will be adding an additional DebugLoc type (or mlir::Location type) argument for processConstant, such that caller can supply additional location info if available (from GlobalVariable, for example).
I'm not sure I want to make such change in this patch though.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     return instMap[c] = instMap[i];
   }
   if (auto *ue = dyn_cast<llvm::UndefValue>(c)) {
     Type type = processType(ue->getType());
     if (!type)
       return nullptr;
     return instMap[c] = bEntry.create<UndefOp>(UnknownLoc::get(context), type);
   }
+
+  if (isa<llvm::ConstantAggregate>(c) || isa<llvm::ConstantAggregateZero>(c)) {
+    unsigned numElements = c->getNumOperands();
+    std::function<llvm::Constant *(unsigned)> getElement =
+        [&](unsigned index) -> llvm::Constant * {
+      return c->getAggregateElement(index);
+    };
+    // llvm::ConstantAggregateZero doesn't take any operand
+    // so its getNumOperands is always zero.
+    if (auto *caz = dyn_cast<llvm::ConstantAggregateZero>(c)) {
+      numElements = caz->getElementCount().getFixedValue();
+      // We want to capture the pointer rather than reference
+      // to the pointer since the latter will become dangling upon
+      // exiting the scope.
+      getElement = [=](unsigned index) -> llvm::Constant * {
+        return caz->getElementValue(index);
+      };
+    }
+
+    // Generate a llvm.undef as the root value first.
+    Type rootType = processType(c->getType());
+    if (!rootType)
+      return nullptr;
+    Value root = bEntry.create<UndefOp>(unknownLoc, rootType);
+    for (unsigned i = 0; i < numElements; ++i) {
+      llvm::Constant *element = getElement(i);
+      Value elementValue = processConstant(element);
+      if (!elementValue)
+        return nullptr;
+      ArrayAttr indexAttr = bEntry.getI32ArrayAttr({static_cast<int32_t>(i)});
+      root = bEntry.create<InsertValueOp>(UnknownLoc::get(context), rootType,
+                                          root, elementValue, indexAttr);
+    }
+    return root;
+  }
+
   emitError(unknownLoc) << "unhandled constant: " << diag(*c);
   return nullptr;
 }
 
 Value Importer::processValue(llvm::Value *value) {
   auto it = instMap.find(value);
   if (it != instMap.end())
     return it->second;

mlir/test/Target/LLVMIR/Import/constant-aggregate.ll

+; RUN: mlir-translate --import-llvm %s | FileCheck %s
+
+; CHECK-DAG: %[[C0:.+]] = llvm.mlir.constant(7 : i32) : i32
+; CHECK-DAG: %[[C1:.+]] = llvm.mlir.constant(8 : i16) : i16
+; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(4 : i8) : i8
+; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(9 : i32) : i32
+; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"SimpleAggType", (i32, i8, i16, i32)>
+; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C3]], %[[ROOT]][0 : i32]
+; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1 : i32]
+; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2 : i32]
+; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3 : i32]
+; CHECK: llvm.return %[[CHAIN3]]
+%SimpleAggType = type {i32, i8, i16, i32}
+@simpleAgg = global %SimpleAggType {i32 9, i8 4, i16 8, i32 7}
+
+; CHECK: %[[NP:.+]] = llvm.mlir.null : !llvm.ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>
+; CHECK-DAG: %[[C0:.+]] = llvm.mlir.constant(4 : i32) : i32
+; CHECK-DAG: %[[C1:.+]] = llvm.mlir.constant(3 : i16) : i16
+; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(2 : i8) : i8
+; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(1 : i32) : i32
+; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"SimpleAggType", (i32, i8, i16, i32)>
+; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C3]], %[[ROOT]][0 : i32]
+; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1 : i32]
+; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2 : i32]
+; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3 : i32]
+; CHECK: %[[ROOT2:.+]] = llvm.mlir.undef : !llvm.struct<"NestedAggType", (struct<"SimpleAggType", (i32, i8, i16, i32)>, ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>)>
+; CHECK: %[[CHAIN4:.+]] = llvm.insertvalue %[[CHAIN3]], %[[ROOT2]][0 : i32]
+; CHECK: %[[CHAIN5:.+]] = llvm.insertvalue %[[NP]], %[[CHAIN4]][1 : i32]
+; CHECK: llvm.return %[[CHAIN5]]
+%NestedAggType = type {%SimpleAggType, %SimpleAggType*}
+@nestedAgg = global %NestedAggType { %SimpleAggType{i32 1, i8 2, i16 3, i32 4}, %SimpleAggType* null }
+

mlir/test/Target/LLVMIR/Import/zeroinitializer.ll

+; RUN: mlir-translate --import-llvm %s | FileCheck %s
+
+%Domain = type { %Domain**, %Domain* }
+
+; CHECK: llvm.mlir.global external @D() :
+; CHECK-SAME: !llvm.struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)> 
+; CHECK-DAG: %[[E0:.+]] = llvm.mlir.null : !llvm.ptr<struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>>
+; CHECK-DAG: %[[E1:.+]] = llvm.mlir.null : !llvm.ptr<ptr<struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>>>
+; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"Domain", (ptr<ptr<struct<"Domain">>>, ptr<struct<"Domain">>)>
+; CHECK: %[[CHAIN:.+]] = llvm.insertvalue %[[E1]], %[[ROOT]][0 : i32]
+; CHECK: %[[RES:.+]] = llvm.insertvalue %[[E0]], %[[CHAIN]][1 : i32]
+; CHECK: llvm.return %[[RES]]
+@D = global %Domain zeroinitializer
+