[mlir][llvm] Update insertion point handling in LLVM import.

Insert constants and globals in order by maintaining the position
of the constant and global inserted last. Update the tests
to reflect the updated insertion order. Also make sure functions
are always inserted at the end of the module instead of at
the second last position and delete a spurious function in
the intrinsic.ll that seems to exist to avoid the first
function under test ends up at the end of the module.

Reviewed By: ftynse

Differential Revision: https://reviews.llvm.org/D136679

Author: gysit

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

@@ -412,35 +412,35 @@ class Importer {
   /// Returns the builtin type equivalent to be used in attributes for the given
   /// LLVM IR dialect type.
   Type getStdTypeForAttr(Type type);
-  /// Return `value` as an attribute to attach to a GlobalOp.
+  /// Returns `value` as an attribute to attach to a GlobalOp.
   Attribute getConstantAsAttr(llvm::Constant *value);
-  /// Return `constant` as an MLIR Value. This could either be a ConstantOp, or
-  /// an expanded sequence of ops in the current function's entry block (for
+  /// Converts the LLVM constant to an MLIR value produced by a ConstantOp,
+  /// AddressOfOp, NullOp, or to an expanded sequence of operations (for
   /// ConstantExprs or ConstantGEPs).
-  Value processConstant(llvm::Constant *constant);
+  Value convertConstantInPlace(llvm::Constant *constant);
+  /// Converts the LLVM constant to an MLIR value using the
+  /// `convertConstantInPlace` method and inserts the constant at the start of
+  /// the function entry block.
+  Value convertConstant(llvm::Constant *constant);
+
+  /// Set the constant insertion point to the start of the given block.
+  void setConstantInsertionPointToStart(Block *block) {
+    constantInsertionBlock = block;
+    constantInsertionOp = nullptr;
+  }
 
-  /// Builder pointing at where the next Instruction should be generated.
+  /// Builder pointing at where the next instruction should be generated.
   OpBuilder builder;
+  /// Block to insert the next constant into.
+  Block *constantInsertionBlock = nullptr;
+  /// Operation to insert the next constant after.
+  Operation *constantInsertionOp = nullptr;
+  /// Operation to insert the next global after.
+  Operation *globalInsertionOp = nullptr;
   /// The current context.
   MLIRContext *context;
   /// The current module being created.
   ModuleOp module;
-  /// The entry block of the current function being processed.
-  Block *currentEntryBlock = nullptr;
-
-  /// Globals are inserted before the first function, if any.
-  Block::iterator getGlobalInsertPt() {
-    Block::iterator it = module.getBody()->begin();
-    Block::iterator endIt = module.getBody()->end();
-    while (it != endIt && !isa<LLVMFuncOp>(it))
-      ++it;
-    return it;
-  }
-
-  /// Functions are always inserted before the module terminator.
-  Block::iterator getFuncInsertPt() {
-    return std::prev(module.getBody()->end());
-  }
 
   /// Function-local mapping between original and imported block.
   DenseMap<llvm::BasicBlock *, Block *> blockMapping;
@@ -642,7 +642,14 @@ GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
   if (it != globals.end())
     return it->second;
 
-  OpBuilder b(module.getBody(), getGlobalInsertPt());
+  // Insert the global after the last one or at the start of the module.
+  OpBuilder::InsertionGuard guard(builder);
+  if (!globalInsertionOp) {
+    builder.setInsertionPointToStart(module.getBody());
+  } else {
+    builder.setInsertionPointAfter(globalInsertionOp);
+  }
+
   Attribute valueAttr;
   if (gv->hasInitializer())
     valueAttr = getConstantAsAttr(gv->getInitializer());
@@ -655,20 +662,18 @@ GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
     alignment = align.value();
   }
 
-  GlobalOp op = b.create<GlobalOp>(
+  GlobalOp op = builder.create<GlobalOp>(
       UnknownLoc::get(context), type, gv->isConstant(),
       convertLinkageFromLLVM(gv->getLinkage()), gv->getName(), valueAttr,
       alignment, /*addr_space=*/gv->getAddressSpace(),
       /*dso_local=*/gv->isDSOLocal(), /*thread_local=*/gv->isThreadLocal());
+  globalInsertionOp = op;
 
   if (gv->hasInitializer() && !valueAttr) {
-    Region &r = op.getInitializerRegion();
-    currentEntryBlock = b.createBlock(&r);
-    b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
-    Value v = processConstant(gv->getInitializer());
-    if (!v)
-      return nullptr;
-    b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));
+    Block *block = builder.createBlock(&op.getInitializerRegion());
+    setConstantInsertionPointToStart(block);
+    Value value = convertConstant(gv->getInitializer());
+    builder.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({value}));
   }
   if (gv->hasAtLeastLocalUnnamedAddr())
     op.setUnnamedAddr(convertUnnamedAddrFromLLVM(gv->getUnnamedAddr()));
@@ -678,29 +683,25 @@ GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
   return globals[gv] = op;
 }
 
-Value Importer::processConstant(llvm::Constant *constant) {
-  OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
+Value Importer::convertConstantInPlace(llvm::Constant *constant) {
   if (Attribute attr = getConstantAsAttr(constant)) {
     // These constants can be represented as attributes.
-    OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
     Type type = convertType(constant->getType());
     if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
-      return bEntry.create<AddressOfOp>(UnknownLoc::get(context), type,
-                                        symbolRef.getValue());
-    return bEntry.create<ConstantOp>(UnknownLoc::get(context), type, attr);
+      return builder.create<AddressOfOp>(UnknownLoc::get(context), type,
+                                         symbolRef.getValue());
+    return builder.create<ConstantOp>(UnknownLoc::get(context), type, attr);
   }
   if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(constant)) {
     Type type = convertType(cn->getType());
-    return bEntry.create<NullOp>(UnknownLoc::get(context), type);
+    return builder.create<NullOp>(UnknownLoc::get(context), type);
   }
   if (auto *gv = dyn_cast<llvm::GlobalVariable>(constant))
-    return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
-                                      processGlobal(gv));
+    return builder.create<AddressOfOp>(UnknownLoc::get(context),
+                                       processGlobal(gv));
 
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(constant)) {
     llvm::Instruction *i = ce->getAsInstruction();
-    OpBuilder::InsertionGuard guard(builder);
-    builder.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     if (failed(processInstruction(i)))
       return nullptr;
     assert(valueMapping.count(i));
@@ -720,7 +721,7 @@ Value Importer::processConstant(llvm::Constant *constant) {
   }
   if (auto *ue = dyn_cast<llvm::UndefValue>(constant)) {
     Type type = convertType(ue->getType());
-    return bEntry.create<UndefOp>(UnknownLoc::get(context), type);
+    return builder.create<UndefOp>(UnknownLoc::get(context), type);
   }
 
   if (isa<llvm::ConstantAggregate>(constant) ||
@@ -747,41 +748,62 @@ Value Importer::processConstant(llvm::Constant *constant) {
     bool useInsertValue = rootType.isa<LLVMArrayType, LLVMStructType>();
     assert((useInsertValue || LLVM::isCompatibleVectorType(rootType)) &&
            "unrecognized aggregate type");
-    Value root = bEntry.create<UndefOp>(UnknownLoc::get(context), rootType);
+    Value root = builder.create<UndefOp>(UnknownLoc::get(context), rootType);
     for (unsigned i = 0; i < numElements; ++i) {
       llvm::Constant *element = getElement(i);
-      Value elementValue = processConstant(element);
+      Value elementValue = convertConstantInPlace(element);
       if (!elementValue)
         return nullptr;
       if (useInsertValue) {
-        root = bEntry.create<InsertValueOp>(UnknownLoc::get(context), root,
-                                            elementValue, i);
+        root = builder.create<InsertValueOp>(UnknownLoc::get(context), root,
+                                             elementValue, i);
       } else {
-        Attribute indexAttr = bEntry.getI32IntegerAttr(static_cast<int32_t>(i));
-        Value indexValue = bEntry.create<ConstantOp>(
-            UnknownLoc::get(context), bEntry.getI32Type(), indexAttr);
+        Attribute indexAttr =
+            builder.getI32IntegerAttr(static_cast<int32_t>(i));
+        Value indexValue = builder.create<ConstantOp>(
+            UnknownLoc::get(context), builder.getI32Type(), indexAttr);
         if (!indexValue)
           return nullptr;
-        root = bEntry.create<InsertElementOp>(
+        root = builder.create<InsertElementOp>(
             UnknownLoc::get(context), rootType, root, elementValue, indexValue);
       }
     }
     return root;
   }
 
-  emitError(UnknownLoc::get(context))
-      << "unhandled constant: " << diag(*constant);
   return nullptr;
 }
 
+Value Importer::convertConstant(llvm::Constant *constant) {
+  assert(constantInsertionBlock &&
+         "expected the constant insertion block to be non-null");
+
+  // Insert the constant after the last one or at the start or the entry block.
+  OpBuilder::InsertionGuard guard(builder);
+  if (!constantInsertionOp) {
+    builder.setInsertionPointToStart(constantInsertionBlock);
+  } else {
+    builder.setInsertionPointAfter(constantInsertionOp);
+  }
+
+  // Convert the constant in-place and update the insertion point if successful.
+  if (Value result = convertConstantInPlace(constant)) {
+    constantInsertionOp = result.getDefiningOp();
+    return result;
+  }
+
+  llvm::errs() << diag(*constant) << "\n";
+  llvm_unreachable("unhandled constant");
+}
+
 Value Importer::processValue(llvm::Value *value) {
   auto it = valueMapping.find(value);
   if (it != valueMapping.end())
     return it->second;
 
-  // Process constants such as immediate arguments that have no mapping.
+  // Convert constants such as immediate arguments that have no mapping.
   if (auto *c = dyn_cast<llvm::Constant>(value))
-    return processConstant(c);
+    return convertConstant(c);
 
   llvm::errs() << diag(*value) << "\n";
   llvm_unreachable("unhandled value");
@@ -927,7 +949,7 @@ LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
     SmallVector<Value, 4> ops;
 
     for (unsigned i = 0, ie = lpi->getNumClauses(); i < ie; i++)
-      ops.push_back(processConstant(lpi->getClause(i)));
+      ops.push_back(convertConstant(lpi->getClause(i)));
 
     Type ty = convertType(lpi->getType());
     Value res = builder.create<LandingpadOp>(loc, ty, lpi->isCleanup(), ops);
@@ -1034,7 +1056,10 @@ LogicalResult Importer::processFunction(llvm::Function *func) {
   bool dsoLocal = func->hasLocalLinkage();
   CConv cconv = convertCConvFromLLVM(func->getCallingConv());
 
-  builder.setInsertionPoint(module.getBody(), getFuncInsertPt());
+  // Insert the function at the end of the module.
+  OpBuilder::InsertionGuard guard(builder);
+  builder.setInsertionPoint(module.getBody(), module.getBody()->end());
+
   LLVMFuncOp funcOp = builder.create<LLVMFuncOp>(
       UnknownLoc::get(context), func->getName(), functionType,
       convertLinkageFromLLVM(func->getLinkage()), dsoLocal, cconv);
@@ -1090,7 +1115,6 @@ LogicalResult Importer::processFunction(llvm::Function *func) {
         builder.createBlock(&funcOp.getBody(), funcOp.getBody().end());
     mapBlock(&bb, block);
   }
-  currentEntryBlock = &funcOp.getFunctionBody().getBlocks().front();
 
   // Add function arguments to the entry block.
   for (const auto &it : llvm::enumerate(func->args())) {
@@ -1103,6 +1127,7 @@ LogicalResult Importer::processFunction(llvm::Function *func) {
   // operands defined in a dominating block have a valid mapping to an MLIR
   // value once a block is translated.
   SetVector<llvm::BasicBlock *> blocks = getTopologicallySortedBlocks(func);
+  setConstantInsertionPointToStart(lookupBlock(blocks.front()));
   for (llvm::BasicBlock *bb : blocks) {
     if (failed(processBasicBlock(bb, lookupBlock(bb))))
       return failure();

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

@@ -24,8 +24,8 @@
 
 @g4 = external global i32, align 8
 ; CHECK: llvm.mlir.global internal constant @int_gep() {addr_space = 0 : i32, dso_local} : !llvm.ptr<i32> {
-; CHECK-DAG:   %[[addr:[0-9]+]] = llvm.mlir.addressof @g4 : !llvm.ptr<i32>
-; CHECK-DAG:   %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
+; CHECK:       %[[addr:[0-9]+]] = llvm.mlir.addressof @g4 : !llvm.ptr<i32>
+; CHECK:       %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
 ; CHECK-NEXT:  %[[gepinit:[0-9]+]] = llvm.getelementptr %[[addr]][%[[c2]]] : (!llvm.ptr<i32>, i32) -> !llvm.ptr<i32>
 ; CHECK-NEXT:  llvm.return %[[gepinit]] : !llvm.ptr<i32>
 ; CHECK-NEXT: }
@@ -133,10 +133,10 @@ define internal spir_func void @spir_func_internal() {
 ; FIXME: function attributes.
 ; CHECK-LABEL: llvm.func internal @f1(%arg0: i64) -> i32 attributes {dso_local} {
 ; CHECK-DBG: llvm.func internal @f1(%arg0: i64 loc(unknown)) -> i32 attributes {dso_local} {
-; CHECK-DAG: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
-; CHECK-DAG: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32
-; CHECK-DAG: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : i1
-; CHECK-DAG: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : i32
+; CHECK: %[[c2:[0-9]+]] = llvm.mlir.constant(2 : i32) : i32
+; CHECK: %[[c1:[0-9]+]] = llvm.mlir.constant(true) : i1
+; CHECK: %[[c43:[0-9]+]] = llvm.mlir.constant(43 : i32) : i32
+; CHECK: %[[c42:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32
 define internal dso_local i32 @f1(i64 %a) norecurse {
 entry:
 ; CHECK: %{{[0-9]+}} = llvm.inttoptr %arg0 : i64 to !llvm.ptr<i64>
@@ -148,7 +148,7 @@ entry:
 ; %{{[0-9]+}} = llvm.ptrtoint %[[addrof2]] : !llvm.ptr<f64> to i64
 ; %{{[0-9]+}} = llvm.getelementptr %[[addrof]][%3] : (!llvm.ptr<f64>, i32) -> !llvm.ptr<f64>
   %bb = ptrtoint double* @g2 to i64
-  %cc = getelementptr double, double* @g2, i32 2
+  %cc = getelementptr double, double* @g2, i32 3
 ; CHECK: %[[b:[0-9]+]] = llvm.trunc %arg0 : i64 to i32
 ; CHECK-DBG: llvm.trunc %arg0 : i64 to i32 loc(#[[UNKNOWNLOC]])
   %b = trunc i64 %a to i32
@@ -195,18 +195,18 @@ define void @f6(void (i16) *%fn) {
 ; Testing rest of the floating point constant kinds.
 ; CHECK-LABEL: llvm.func @FPConstant(%arg0: f16, %arg1: bf16, %arg2: f128, %arg3: f80)
 define void @FPConstant(half %a, bfloat %b, fp128 %c, x86_fp80 %d) {
-  ; CHECK-DAG: %[[C0:.+]] = llvm.mlir.constant(7.000000e+00 : f80) : f80
-  ; CHECK-DAG: %[[C1:.+]] = llvm.mlir.constant(0.000000e+00 : f128) : f128
-  ; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(1.000000e+00 : bf16) : bf16
-  ; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(1.000000e+00 : f16) : f16
+  ; CHECK: %[[C0:.+]] = llvm.mlir.constant(1.000000e+00 : f16) : f16
+  ; CHECK: %[[C1:.+]] = llvm.mlir.constant(1.000000e+00 : bf16) : bf16
+  ; CHECK: %[[C2:.+]] = llvm.mlir.constant(0.000000e+00 : f128) : f128
+  ; CHECK: %[[C3:.+]] = llvm.mlir.constant(7.000000e+00 : f80) : f80
 
-  ; CHECK: llvm.fadd %[[C3]], %arg0  : f16
+  ; CHECK: llvm.fadd %[[C0]], %arg0  : f16
   %1 = fadd half 1.0, %a
-  ; CHECK: llvm.fadd %[[C2]], %arg1  : bf16
+  ; CHECK: llvm.fadd %[[C1]], %arg1  : bf16
   %2 = fadd bfloat 1.0, %b
-  ; CHECK: llvm.fadd %[[C1]], %arg2  : f128
+  ; CHECK: llvm.fadd %[[C2]], %arg2  : f128
   %3 = fadd fp128 0xL00000000000000000000000000000000, %c
-  ; CHECK: llvm.fadd %[[C0]], %arg3  : f80
+  ; CHECK: llvm.fadd %[[C3]], %arg3  : f80
   %4 = fadd x86_fp80 0xK4001E000000000000000, %d
   ret void
 }

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

@@ -1,41 +1,40 @@
 ; 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]
-; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1]
-; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2]
-; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3]
+; CHECK: %[[C0:.+]] = llvm.mlir.constant(9 : i32) : i32
+; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C0]], %[[ROOT]][0]
+; CHECK: %[[C1:.+]] = llvm.mlir.constant(4 : i8) : i8
+; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN0]][1]
+; CHECK: %[[C2:.+]] = llvm.mlir.constant(8 : i16) : i16
+; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN1]][2]
+; CHECK: %[[C3:.+]] = llvm.mlir.constant(7 : i32) : i32
+; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C3]], %[[CHAIN2]][3]
 ; 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]
+; CHECK: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"NestedAggType", (struct<"SimpleAggType", (i32, i8, i16, i32)>, ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>)>
+; CHECK: %[[NESTED:.+]] = llvm.mlir.undef : !llvm.struct<"SimpleAggType", (i32, i8, i16, i32)>
+; CHECK: %[[C1:.+]] = llvm.mlir.constant(1 : i32) : i32
+; CHECK: %[[CHAIN0:.+]] = llvm.insertvalue %[[C1]], %[[NESTED]][0]
+; CHECK: %[[C2:.+]] = llvm.mlir.constant(2 : i8) : i8
 ; CHECK: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1]
-; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN1]][2]
-; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C0]], %[[CHAIN2]][3]
-; 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]
+; CHECK: %[[C3:.+]] = llvm.mlir.constant(3 : i16) : i16
+; CHECK: %[[CHAIN2:.+]] = llvm.insertvalue %[[C3]], %[[CHAIN1]][2]
+; CHECK: %[[C4:.+]] = llvm.mlir.constant(4 : i32) : i32
+; CHECK: %[[CHAIN3:.+]] = llvm.insertvalue %[[C4]], %[[CHAIN2]][3]
+; CHECK: %[[CHAIN4:.+]] = llvm.insertvalue %[[CHAIN3]], %[[ROOT]][0]
+; CHECK: %[[NP:.+]] = llvm.mlir.null : !llvm.ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>
 ; CHECK: %[[CHAIN5:.+]] = llvm.insertvalue %[[NP]], %[[CHAIN4]][1]
 ; 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: %[[C0:.+]] = llvm.mlir.null : !llvm.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: %[[CHAIN0:.+]] = llvm.insertelement %[[C0]], %[[ROOT]][%[[P0]] : i32] : !llvm.vec<2 x ptr<struct<"SimpleAggType", (i32, i8, i16, i32)>>>
+; CHECK: %[[C1:.+]] = llvm.mlir.null : !llvm.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: %[[CHAIN1:.+]] = llvm.insertelement %[[C1]], %[[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>