[CIR][Dialect] Introduce StdInitializerListOp to represent high-level semantics of C++ initializer list (#1121)

I don't finish all work about `cir.initlist`. But I want to get some
feedback about the cir design to make sure I am in correct way.

Fixed: #777

Author: HerrCai0907

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -5292,4 +5292,38 @@ def SignBitOp : CIR_Op<"signbit", [Pure]> {
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// StdInitializerListOp
+//===----------------------------------------------------------------------===//
+
+def StdInitializerListOp : CIR_Op<"std.initializer_list"> {
+  let summary = "Initialize std::initializer_list";
+  let description = [{
+    The `std.initializer_list` operation will initialize
+    `std::initializer_list<T>` with given arguments list.
+
+    ```cpp
+    initializer_list<int> v{1,2,3}; // initialize v with 1, 2, 3
+    ```
+
+    The code above will generate CIR similar as:
+
+    ```mlir
+    %0 = cir.alloca INITLIST_TYPE, !cir.ptr<INITLIST_TYPE>
+    %1 = cir.const #cir.int<1>
+    ...
+    cir.std.initializer_list %0 (%1 %2 %3)
+    ``` 
+
+    The type of each argument should be the same as template parameter of
+    `std::initializer_list` (aka `T` in `std::initializer_list<T>`).
+  }];
+  let arguments = (ins StructPtr:$initList, Variadic<CIR_AnyType>:$args);
+  let assemblyFormat = [{
+    $initList ` ` `(` ($args^ `:` type($args))? `)` `:` type($initList) attr-dict
+  }];
+
+  let hasVerifier = 1;
+}
+
 #endif // LLVM_CLANG_CIR_DIALECT_IR_CIROPS

clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp

@@ -18,11 +18,15 @@
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
+#include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/MissingFeatures.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -297,62 +301,25 @@ class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
   void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
   void VisitLambdaExpr(LambdaExpr *E);
   void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
-    ASTContext &Ctx = CGF.getContext();
-    CIRGenFunction::SourceLocRAIIObject locRAIIObject{
-        CGF, CGF.getLoc(E->getSourceRange())};
-    // Emit an array containing the elements.  The array is externally
-    // destructed if the std::initializer_list object is.
-    LValue Array = CGF.emitLValue(E->getSubExpr());
-    assert(Array.isSimple() && "initializer_list array not a simple lvalue");
-    Address ArrayPtr = Array.getAddress();
-
-    const ConstantArrayType *ArrayType =
-        Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
-    assert(ArrayType && "std::initializer_list constructed from non-array");
-
-    RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
-    RecordDecl::field_iterator Field = Record->field_begin();
-    assert(Field != Record->field_end() &&
-           Ctx.hasSameType(Field->getType()->getPointeeType(),
-                           ArrayType->getElementType()) &&
-           "Expected std::initializer_list first field to be const E *");
-    // Start pointer.
     auto loc = CGF.getLoc(E->getSourceRange());
-    AggValueSlot Dest = EnsureSlot(loc, E->getType());
-    LValue DestLV = CGF.makeAddrLValue(Dest.getAddress(), E->getType());
-    LValue Start =
-        CGF.emitLValueForFieldInitialization(DestLV, *Field, Field->getName());
-    mlir::Value ArrayStart = ArrayPtr.emitRawPointer();
-    CGF.emitStoreThroughLValue(RValue::get(ArrayStart), Start);
-    ++Field;
-    assert(Field != Record->field_end() &&
-           "Expected std::initializer_list to have two fields");
-
-    auto Builder = CGF.getBuilder();
-
-    auto sizeOp = Builder.getConstInt(loc, ArrayType->getSize());
-
-    mlir::Value Size = sizeOp.getRes();
-    Builder.getUIntNTy(ArrayType->getSizeBitWidth());
-    LValue EndOrLength =
-        CGF.emitLValueForFieldInitialization(DestLV, *Field, Field->getName());
-    if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) {
-      // Length.
-      CGF.emitStoreThroughLValue(RValue::get(Size), EndOrLength);
-    } else {
-      // End pointer.
-      assert(Field->getType()->isPointerType() &&
-             Ctx.hasSameType(Field->getType()->getPointeeType(),
-                             ArrayType->getElementType()) &&
-             "Expected std::initializer_list second field to be const E *");
-
-      auto ArrayEnd =
-          Builder.getArrayElement(loc, loc, ArrayPtr.getPointer(),
-                                  ArrayPtr.getElementType(), Size, false);
-      CGF.emitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
+    auto builder = CGF.getBuilder();
+    auto *subExpr =
+        llvm::cast<MaterializeTemporaryExpr>(E->getSubExpr())->getSubExpr();
+    llvm::SmallVector<mlir::Value> inits{};
+    for (auto *init : llvm::cast<InitListExpr>(subExpr)->inits()) {
+      RValue tmpInit = CGF.emitAnyExprToTemp(init);
+      if (tmpInit.isScalar()) {
+        inits.push_back(tmpInit.getScalarVal());
+      } else if (tmpInit.isComplex()) {
+        inits.push_back(tmpInit.getComplexVal());
+      } else if (tmpInit.isAggregate()) {
+        inits.push_back(tmpInit.getAggregatePointer());
+      } else {
+        llvm_unreachable("invalid temp expr type");
+      }
     }
-    assert(++Field == Record->field_end() &&
-           "Expected std::initializer_list to only have two fields");
+    mlir::Value dest = EnsureSlot(loc, E->getType()).getPointer();
+    builder.create<cir::StdInitializerListOp>(loc, dest, inits);
   }
 
   void VisitExprWithCleanups(ExprWithCleanups *E);

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -3867,6 +3867,29 @@ LogicalResult cir::CatchParamOp::verify() {
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// StdInitializerListOp Definitions
+//===----------------------------------------------------------------------===//
+
+LogicalResult cir::StdInitializerListOp::verify() {
+  auto resultType = mlir::cast<cir::StructType>(
+      mlir::cast<cir::PointerType>(getInitList().getType()).getPointee());
+  if (resultType.getMembers().size() != 2)
+    return emitOpError(
+        "std::initializer_list must be '!cir.struct' with two fields");
+  auto memberPtr = mlir::dyn_cast<cir::PointerType>(resultType.getMembers()[0]);
+  if (memberPtr == nullptr)
+    return emitOpError("first member type of std::initializer_list must be "
+                       "'!cir.ptr', but provided ")
+           << resultType.getMembers()[0];
+  auto expectedType = memberPtr.getPointee();
+  for (const mlir::Value &arg : getArgs())
+    if (expectedType != arg.getType())
+      return emitOpError("arg type must be ")
+             << expectedType << ", but provided " << arg.getType();
+  return mlir::success();
+}
+
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//

clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp

@@ -12,15 +12,19 @@
 #include "mlir/IR/Region.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CharUnits.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/Mangle.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h"
 #include "clang/CIR/Dialect/IR/CIRDataLayout.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
+#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include "clang/CIR/Dialect/Passes.h"
 #include "clang/CIR/Interfaces/ASTAttrInterfaces.h"
 #include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
@@ -85,6 +89,7 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> {
   void lowerToMemCpy(StoreOp op);
   void lowerArrayDtor(ArrayDtor op);
   void lowerArrayCtor(ArrayCtor op);
+  void lowerStdInitializerListOp(StdInitializerListOp op);
 
   /// Collect annotations of global values in the module
   void addGlobalAnnotations(mlir::Operation *op, mlir::ArrayAttr annotations);
@@ -1120,6 +1125,79 @@ void LoweringPreparePass::lowerIterEndOp(IterEndOp op) {
   op.erase();
 }
 
+/// lowering construction of std::initializer_list.
+/// 1. alloca array for arg list.
+/// 2. copy arg list to array.
+/// 3. construct std::initializer_list from array.
+void LoweringPreparePass::lowerStdInitializerListOp(StdInitializerListOp op) {
+  auto loc = op.getLoc();
+  cir::CIRDataLayout dataLayout(theModule);
+  auto args = op.getArgs();
+
+  auto stdInitializerListType = mlir::cast<cir::StructType>(
+      mlir::cast<cir::PointerType>(op.getInitList().getType()).getPointee());
+  clang::RecordDecl::field_range stdInitializerListFields =
+      stdInitializerListType.getAst().getRawDecl()->fields();
+
+  mlir::Type elementType =
+      mlir::cast<cir::PointerType>(stdInitializerListType.getMembers()[0])
+          .getPointee();
+  auto tempArrayType =
+      cir::ArrayType::get(&getContext(), elementType, args.size());
+
+  CIRBaseBuilderTy builder(getContext());
+  builder.setInsertionPointAfter(op);
+
+  IntegerAttr alignment = builder.getI64IntegerAttr(
+      dataLayout.getPrefTypeAlign(tempArrayType).value());
+  assert(!cir::MissingFeatures::addressSpace());
+  mlir::Value arrayPtr = builder.createAlloca(
+      loc, cir::PointerType::get(tempArrayType), tempArrayType, "", alignment);
+  mlir::Value arrayStartPtr =
+      builder.createCast(cir::CastKind::array_to_ptrdecay, arrayPtr,
+                         cir::PointerType::get(elementType));
+  for (unsigned i = 0; i < args.size(); i++) {
+    if (i == 0) {
+      builder.createStore(loc, args[i], arrayStartPtr);
+    } else {
+      mlir::Value offset = builder.getUnsignedInt(loc, i, 64);
+      mlir::Value dest = builder.create<cir::PtrStrideOp>(
+          loc, arrayStartPtr.getType(), arrayStartPtr, offset);
+      builder.createStore(loc, args[i], dest);
+    }
+  }
+
+  // FIXME(cir): better handling according to different field type. [ptr ptr],
+  // [ptr size], [size ptr].
+
+  clang::RecordDecl::field_iterator it = stdInitializerListFields.begin();
+  const clang::RecordDecl::field_iterator startField = it;
+  const unsigned startIdx = 0U;
+  const clang::RecordDecl::field_iterator endOrSizeField = ++it;
+  const unsigned endOrSizeIdx = 1U;
+  assert(llvm::range_size(stdInitializerListFields) == 2U);
+
+  mlir::Value startMemberPtr = builder.createGetMemberOp(
+      loc, op.getInitList(), startField->getName().data(), startIdx);
+  builder.createStore(loc, arrayStartPtr, startMemberPtr);
+
+  mlir::Value size = builder.getUnsignedInt(loc, args.size(), 64);
+  if (endOrSizeField->getType()->isPointerType()) {
+    mlir::Value arrayEndPtr = builder.create<cir::PtrStrideOp>(
+        loc, arrayStartPtr.getType(), arrayStartPtr, size);
+    mlir::Value endMemberPtr = builder.createGetMemberOp(
+        loc, op.getInitList(), endOrSizeField->getName().data(), endOrSizeIdx);
+    builder.createStore(loc, arrayEndPtr, endMemberPtr);
+  } else {
+    assert(endOrSizeField->getType()->isIntegerType());
+    mlir::Value sizeMemberPtr = builder.createGetMemberOp(
+        loc, op.getInitList(), endOrSizeField->getName().data(), endOrSizeIdx);
+    builder.createStore(loc, size, sizeMemberPtr);
+  }
+
+  op.erase();
+}
+
 void LoweringPreparePass::addGlobalAnnotations(mlir::Operation *op,
                                                mlir::ArrayAttr annotations) {
   auto globalValue = cast<mlir::SymbolOpInterface>(op);
@@ -1180,6 +1258,8 @@ void LoweringPreparePass::runOnOp(Operation *op) {
     }
     if (std::optional<mlir::ArrayAttr> annotations = fnOp.getAnnotations())
       addGlobalAnnotations(fnOp, annotations.value());
+  } else if (auto stdInitializerListOp = dyn_cast<StdInitializerListOp>(op)) {
+    lowerStdInitializerListOp(stdInitializerListOp);
   }
 }
 
@@ -1195,7 +1275,8 @@ void LoweringPreparePass::runOnOperation() {
   op->walk([&](Operation *op) {
     if (isa<UnaryOp, BinOp, CastOp, ComplexBinOp, CmpThreeWayOp, VAArgOp,
             GlobalOp, DynamicCastOp, StdFindOp, IterEndOp, IterBeginOp,
-            ArrayCtor, ArrayDtor, cir::FuncOp, StoreOp>(op))
+            ArrayCtor, ArrayDtor, cir::FuncOp, StoreOp, StdInitializerListOp>(
+            op))
       opsToTransform.push_back(op);
   });
 

clang/test/CIR/CodeGen/initlist-ptr-ptr.cpp

@@ -1,3 +1,5 @@
+// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-cir %s -o %t.cir -clangir-disable-passes
+// RUN: FileCheck --check-prefix=BEFORE --input-file=%t.cir %s
 // RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-cir %s -o %t.cir
 // RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
 // RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-llvm -fno-clangir-call-conv-lowering %s -o %t.ll
@@ -15,6 +17,16 @@ void test() {
 }
 } // namespace std
 
+// BEFORE: [[INITLIST_TYPE:!.*]] = !cir.struct<class "std::initializer_list<const char *>" {!cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!s8i>>} #cir.record.decl.ast>
+// BEFORE: %0 = cir.alloca [[INITLIST_TYPE]], !cir.ptr<[[INITLIST_TYPE]]>,
+// BEFORE: %1 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
+// BEFORE: %2 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
+// BEFORE: %3 = cir.get_global @".str.1" : !cir.ptr<!cir.array<!s8i x 3>> 
+// BEFORE: %4 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
+// BEFORE: cir.std.initializer_list %0 (%2, %4 : !cir.ptr<!s8i>, !cir.ptr<!s8i>) : !cir.ptr<[[INITLIST_TYPE]]>
+// BEFORE: %5 = cir.load %0 : !cir.ptr<[[INITLIST_TYPE]]>, [[INITLIST_TYPE]]
+// BEFORE: cir.call @_ZSt1fIPKcEvSt16initializer_listIT_E(%5) : ([[INITLIST_TYPE]]) -> ()
+
 // CIR: [[INITLIST_TYPE:!.*]] = !cir.struct<class "std::initializer_list<const char *>" {!cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!s8i>>}>
 // CIR: cir.func linkonce_odr @_ZSt1fIPKcEvSt16initializer_listIT_E(%arg0: [[INITLIST_TYPE]]
 // CIR: [[LOCAL:%.*]] = cir.alloca [[INITLIST_TYPE]], !cir.ptr<[[INITLIST_TYPE]]>,
@@ -27,24 +39,22 @@ void test() {
 // CIR: cir.func @_ZSt4testv()
 // CIR: cir.scope {
 // CIR: [[INITLIST_LOCAL:%.*]] = cir.alloca [[INITLIST_TYPE]], !cir.ptr<[[INITLIST_TYPE]]>,  
-// CIR: [[LOCAL_ELEM_ARRAY:%.*]] = cir.alloca !cir.array<!cir.ptr<!s8i> x 2>, !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>,
-// CIR: [[FIRST_ELEM_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[LOCAL_ELEM_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>), !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[XY_CHAR_ARRAY:%.*]] = cir.get_global [[STR_XY]]  : !cir.ptr<!cir.array<!s8i x 3>>
 // CIR: [[STR_XY_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[XY_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
-// CIR:  cir.store [[STR_XY_PTR]], [[FIRST_ELEM_PTR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
-// CIR: [[ONE:%.*]] = cir.const #cir.int<1>
-// CIR: [[NEXT_ELEM_PTR:%.*]] = cir.ptr_stride([[FIRST_ELEM_PTR]] : !cir.ptr<!cir.ptr<!s8i>>, [[ONE]] : !s64i), !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[UV_CHAR_ARRAY:%.*]] = cir.get_global [[STR_UV]]  : !cir.ptr<!cir.array<!s8i x 3>>
 // CIR: [[STR_UV_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[UV_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
+// CIR: [[LOCAL_ELEM_ARRAY:%.*]] = cir.alloca !cir.array<!cir.ptr<!s8i> x 2>, !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>,
+// CIR: [[ELEM_BEGIN:%.*]] = cir.cast(array_to_ptrdecay, [[LOCAL_ELEM_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>), !cir.ptr<!cir.ptr<!s8i>>
+// CIR:  cir.store [[STR_XY_PTR]], [[ELEM_BEGIN]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
+// CIR: [[ONE:%.*]] = cir.const #cir.int<1>
+// CIR: [[NEXT_ELEM_PTR:%.*]] = cir.ptr_stride([[ELEM_BEGIN]] : !cir.ptr<!cir.ptr<!s8i>>, [[ONE]] : !u64i), !cir.ptr<!cir.ptr<!s8i>>
 // CIR:  cir.store [[STR_UV_PTR]], [[NEXT_ELEM_PTR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[START_FLD_PTR:%.*]] = cir.get_member [[INITLIST_LOCAL]][0] {name = "array_start"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
-// CIR: [[START_FLD_PTR_AS_PTR_2_CHAR_ARRAY:%.*]] = cir.cast(bitcast, [[START_FLD_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>), !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
-// CIR: cir.store [[LOCAL_ELEM_ARRAY]], [[START_FLD_PTR_AS_PTR_2_CHAR_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
+// CIR: cir.store [[ELEM_BEGIN]], [[START_FLD_PTR]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
 // CIR: [[ELEM_ARRAY_LEN:%.*]] = cir.const #cir.int<2>
+// CIR: [[ELEM_END:%.*]] = cir.ptr_stride([[ELEM_BEGIN]] : !cir.ptr<!cir.ptr<!s8i>>, [[ELEM_ARRAY_LEN]] : !u64i), !cir.ptr<!cir.ptr<!s8i>>
 // CIR: [[END_FLD_PTR:%.*]] = cir.get_member [[INITLIST_LOCAL]][1] {name = "array_end"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
-// CIR: [[LOCAL_ELEM_ARRAY_END:%.*]] = cir.ptr_stride([[LOCAL_ELEM_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, [[ELEM_ARRAY_LEN]] : !u64i), !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>
-// CIR: [[END_FLD_PTR_AS_PTR_2_CHAR_ARRAY:%.*]] = cir.cast(bitcast, [[END_FLD_PTR]] : !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>), !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
-// CIR: cir.store [[LOCAL_ELEM_ARRAY_END]], [[END_FLD_PTR_AS_PTR_2_CHAR_ARRAY]] : !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>, !cir.ptr<!cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>>
+// CIR: cir.store [[ELEM_END]], [[END_FLD_PTR]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
 // CIR: [[ARG:%.*]] = cir.load [[INITLIST_LOCAL]] : !cir.ptr<[[INITLIST_TYPE]]>, [[INITLIST_TYPE]]
 // CIR: cir.call @_ZSt1fIPKcEvSt16initializer_listIT_E([[ARG]]) : ([[INITLIST_TYPE]]) -> ()
 // CIR: }
@@ -72,8 +82,9 @@ void test() {
 // LLVM:  [[PTR_SECOND_ELEM:%.*]] = getelementptr ptr, ptr [[PTR_FIRST_ELEM]], i64 1,
 // LLVM:  store ptr @.str.1, ptr [[PTR_SECOND_ELEM]], align 8,
 // LLVM:  [[INIT_START_FLD_PTR:%.*]] = getelementptr %"class.std::initializer_list<const char *>", ptr [[INIT_STRUCT]], i32 0, i32 0,
+// LLVM:  store ptr [[PTR_FIRST_ELEM]], ptr [[INIT_START_FLD_PTR]], align 8,
+// LLVM:  [[ELEM_ARRAY_END:%.*]] = getelementptr ptr, ptr [[PTR_FIRST_ELEM]], i64 2,
 // LLVM:  [[INIT_END_FLD_PTR:%.*]] = getelementptr %"class.std::initializer_list<const char *>", ptr [[INIT_STRUCT]], i32 0, i32 1,
-// LLVM:  [[ELEM_ARRAY_END:%.*]] = getelementptr [2 x ptr], ptr [[ELEM_ARRAY_PTR]], i64 2,
 // LLVM:  store ptr [[ELEM_ARRAY_END]], ptr [[INIT_END_FLD_PTR]], align 8,
 // LLVM:  [[ARG2PASS:%.*]] = load %"class.std::initializer_list<const char *>", ptr [[INIT_STRUCT]], align 8,
 // LLVM:  call void @_ZSt1fIPKcEvSt16initializer_listIT_E(%"class.std::initializer_list<const char *>" [[ARG2PASS]]),