[mlir][LLVMIR] Use insertelement if needed when translating ConstantAggregate

[myhsu]

Summary

When translating from a llvm::ConstantAggregate with vector type, we should lower to insertelement operations (if needed) rather than using insertvalue.

[ftynse]

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

33–34

Why is DAG necessary here? The lines are identical so they will always match in the order of appearance.

[myhsu]

Use CHECK rather than CHECK-DAG in some test directives.

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

if (auto *caz = dyn_cast<llvm::ConstantAggregateZero>(c)) {
         return caz->getElementValue(index);
       };
     }
 
     // Generate a llvm.undef as the root value first.
     Type rootType = processType(c->getType());
     if (!rootType)
       return nullptr;
+    bool useInsertValue = rootType.isa<LLVMArrayType, LLVMStructType>();
+    assert((useInsertValue || LLVM::isCompatibleVectorType(rootType)) &&
+           "unrecognized aggregate type");
     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;
+      if (useInsertValue) {
         ArrayAttr indexAttr = bEntry.getI32ArrayAttr({static_cast<int32_t>(i)});
         root = bEntry.create<InsertValueOp>(UnknownLoc::get(context), rootType,
                                             root, elementValue, indexAttr);
+      } else {
+        Attribute indexAttr = bEntry.getI32IntegerAttr(static_cast<int32_t>(i));
+        Value indexValue = bEntry.create<ConstantOp>(
+            unknownLoc, bEntry.getI32Type(), indexAttr);
+        if (!indexValue)
+          return nullptr;
+        root = bEntry.create<InsertElementOp>(
+            UnknownLoc::get(context), rootType, root, elementValue, indexValue);
+      }
     }
     return root;
   }
 
   emitError(unknownLoc) << "unhandled constant: " << diag(*c);
   return nullptr;
 }
 

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

 ; 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 }
 
+; CHECK: %[[C0:.+]] = llvm.mlir.null : !llvm.ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>
+; CHECK: %[[C1:.+]] = llvm.mlir.null : !llvm.ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>
+; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.vec<2 x ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>>
+; CHECK: %[[P0:.+]] = llvm.mlir.constant(0 : i32) : i32
+; CHECK: %[[CHAIN0:.+]] = llvm.insertelement %[[C1]], %[[ROOT]][%[[P0]] : i32] : !llvm.vec<2 x ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>>
+; CHECK: %[[P1:.+]] = llvm.mlir.constant(1 : i32) : i32
+; CHECK: %[[CHAIN1:.+]] = llvm.insertelement %[[C0]], %[[CHAIN0]][%[[P1]] : i32] : !llvm.vec<2 x ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>>
+; CHECK: llvm.return %[[CHAIN1]] : !llvm.vec<2 x ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>>
+@vectorAgg = global <2 x %SimpleAggType*> <%SimpleAggType* null, %SimpleAggType* null>