Skip to content

Commit 3189c0d

Browse files
HerrCai0907HerrCai0907
authored
[CIR] revert StdInitializerListOp (#1216)
Revert "[CIR][Dialect] Introduce StdInitializerListOp to represent high-level semantics of C++ initializer list (#1121)". This reverts commit 7532e05. First step for #1215.
1 parent 8d507b1 commit 3189c0d

File tree

7 files changed

+71
-272
lines changed

7 files changed

+71
-272
lines changed

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

Lines changed: 0 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -5336,38 +5336,4 @@ def SignBitOp : CIR_Op<"signbit", [Pure]> {
53365336
}];
53375337
}
53385338

5339-
//===----------------------------------------------------------------------===//
5340-
// StdInitializerListOp
5341-
//===----------------------------------------------------------------------===//
5342-
5343-
def StdInitializerListOp : CIR_Op<"std.initializer_list"> {
5344-
let summary = "Initialize std::initializer_list";
5345-
let description = [{
5346-
The `std.initializer_list` operation will initialize
5347-
`std::initializer_list<T>` with given arguments list.
5348-
5349-
```cpp
5350-
initializer_list<int> v{1,2,3}; // initialize v with 1, 2, 3
5351-
```
5352-
5353-
The code above will generate CIR similar as:
5354-
5355-
```mlir
5356-
%0 = cir.alloca INITLIST_TYPE, !cir.ptr<INITLIST_TYPE>
5357-
%1 = cir.const #cir.int<1>
5358-
...
5359-
cir.std.initializer_list %0 (%1 %2 %3)
5360-
```
5361-
5362-
The type of each argument should be the same as template parameter of
5363-
`std::initializer_list` (aka `T` in `std::initializer_list<T>`).
5364-
}];
5365-
let arguments = (ins StructPtr:$initList, Variadic<CIR_AnyType>:$args);
5366-
let assemblyFormat = [{
5367-
$initList ` ` `(` ($args^ `:` type($args))? `)` `:` type($initList) attr-dict
5368-
}];
5369-
5370-
let hasVerifier = 1;
5371-
}
5372-
53735339
#endif // LLVM_CLANG_CIR_DIALECT_IR_CIROPS

‎clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp

Lines changed: 54 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -18,15 +18,11 @@
1818

1919
#include "clang/AST/Decl.h"
2020
#include "clang/AST/Expr.h"
21-
#include "clang/AST/ExprCXX.h"
2221
#include "clang/AST/OperationKinds.h"
2322
#include "clang/AST/RecordLayout.h"
2423
#include "clang/AST/StmtVisitor.h"
2524
#include "clang/CIR/Dialect/IR/CIRAttrs.h"
26-
#include "clang/CIR/Dialect/IR/CIRDialect.h"
2725
#include "clang/CIR/MissingFeatures.h"
28-
#include "llvm/ADT/SmallVector.h"
29-
#include "llvm/Support/Casting.h"
3026
#include "llvm/Support/ErrorHandling.h"
3127
#include "llvm/Support/raw_ostream.h"
3228

@@ -301,25 +297,62 @@ class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
301297
void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
302298
void VisitLambdaExpr(LambdaExpr *E);
303299
void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
300+
ASTContext &Ctx = CGF.getContext();
301+
CIRGenFunction::SourceLocRAIIObject locRAIIObject{
302+
CGF, CGF.getLoc(E->getSourceRange())};
303+
// Emit an array containing the elements. The array is externally
304+
// destructed if the std::initializer_list object is.
305+
LValue Array = CGF.emitLValue(E->getSubExpr());
306+
assert(Array.isSimple() && "initializer_list array not a simple lvalue");
307+
Address ArrayPtr = Array.getAddress();
308+
309+
const ConstantArrayType *ArrayType =
310+
Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
311+
assert(ArrayType && "std::initializer_list constructed from non-array");
312+
313+
RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
314+
RecordDecl::field_iterator Field = Record->field_begin();
315+
assert(Field != Record->field_end() &&
316+
Ctx.hasSameType(Field->getType()->getPointeeType(),
317+
ArrayType->getElementType()) &&
318+
"Expected std::initializer_list first field to be const E *");
319+
// Start pointer.
304320
auto loc = CGF.getLoc(E->getSourceRange());
305-
auto builder = CGF.getBuilder();
306-
auto *subExpr =
307-
llvm::cast<MaterializeTemporaryExpr>(E->getSubExpr())->getSubExpr();
308-
llvm::SmallVector<mlir::Value> inits{};
309-
for (auto *init : llvm::cast<InitListExpr>(subExpr)->inits()) {
310-
RValue tmpInit = CGF.emitAnyExprToTemp(init);
311-
if (tmpInit.isScalar()) {
312-
inits.push_back(tmpInit.getScalarVal());
313-
} else if (tmpInit.isComplex()) {
314-
inits.push_back(tmpInit.getComplexVal());
315-
} else if (tmpInit.isAggregate()) {
316-
inits.push_back(tmpInit.getAggregatePointer());
317-
} else {
318-
llvm_unreachable("invalid temp expr type");
319-
}
321+
AggValueSlot Dest = EnsureSlot(loc, E->getType());
322+
LValue DestLV = CGF.makeAddrLValue(Dest.getAddress(), E->getType());
323+
LValue Start =
324+
CGF.emitLValueForFieldInitialization(DestLV, *Field, Field->getName());
325+
mlir::Value ArrayStart = ArrayPtr.emitRawPointer();
326+
CGF.emitStoreThroughLValue(RValue::get(ArrayStart), Start);
327+
++Field;
328+
assert(Field != Record->field_end() &&
329+
"Expected std::initializer_list to have two fields");
330+
331+
auto Builder = CGF.getBuilder();
332+
333+
auto sizeOp = Builder.getConstInt(loc, ArrayType->getSize());
334+
335+
mlir::Value Size = sizeOp.getRes();
336+
Builder.getUIntNTy(ArrayType->getSizeBitWidth());
337+
LValue EndOrLength =
338+
CGF.emitLValueForFieldInitialization(DestLV, *Field, Field->getName());
339+
if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) {
340+
// Length.
341+
CGF.emitStoreThroughLValue(RValue::get(Size), EndOrLength);
342+
} else {
343+
// End pointer.
344+
assert(Field->getType()->isPointerType() &&
345+
Ctx.hasSameType(Field->getType()->getPointeeType(),
346+
ArrayType->getElementType()) &&
347+
"Expected std::initializer_list second field to be const E *");
348+
349+
auto ArrayEnd =
350+
Builder.getArrayElement(loc, loc, ArrayPtr.getPointer(),
351+
ArrayPtr.getElementType(), Size, false);
352+
CGF.emitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
320353
}
321-
mlir::Value dest = EnsureSlot(loc, E->getType()).getPointer();
322-
builder.create<cir::StdInitializerListOp>(loc, dest, inits);
354+
assert(++Field == Record->field_end() &&
355+
"Expected std::initializer_list to only have two fields");
323356
}
324357

325358
void VisitExprWithCleanups(ExprWithCleanups *E);

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

Lines changed: 0 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -3865,29 +3865,6 @@ LogicalResult cir::CatchParamOp::verify() {
38653865
return success();
38663866
}
38673867

3868-
//===----------------------------------------------------------------------===//
3869-
// StdInitializerListOp Definitions
3870-
//===----------------------------------------------------------------------===//
3871-
3872-
LogicalResult cir::StdInitializerListOp::verify() {
3873-
auto resultType = mlir::cast<cir::StructType>(
3874-
mlir::cast<cir::PointerType>(getInitList().getType()).getPointee());
3875-
if (resultType.getMembers().size() != 2)
3876-
return emitOpError(
3877-
"std::initializer_list must be '!cir.struct' with two fields");
3878-
auto memberPtr = mlir::dyn_cast<cir::PointerType>(resultType.getMembers()[0]);
3879-
if (memberPtr == nullptr)
3880-
return emitOpError("first member type of std::initializer_list must be "
3881-
"'!cir.ptr', but provided ")
3882-
<< resultType.getMembers()[0];
3883-
auto expectedType = memberPtr.getPointee();
3884-
for (const mlir::Value &arg : getArgs())
3885-
if (expectedType != arg.getType())
3886-
return emitOpError("arg type must be ")
3887-
<< expectedType << ", but provided " << arg.getType();
3888-
return mlir::success();
3889-
}
3890-
38913868
//===----------------------------------------------------------------------===//
38923869
// TableGen'd op method definitions
38933870
//===----------------------------------------------------------------------===//

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

Lines changed: 1 addition & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -12,19 +12,15 @@
1212
#include "mlir/IR/Region.h"
1313
#include "clang/AST/ASTContext.h"
1414
#include "clang/AST/CharUnits.h"
15-
#include "clang/AST/Decl.h"
1615
#include "clang/AST/Mangle.h"
1716
#include "clang/Basic/Module.h"
1817
#include "clang/Basic/TargetInfo.h"
1918
#include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h"
2019
#include "clang/CIR/Dialect/IR/CIRDataLayout.h"
2120
#include "clang/CIR/Dialect/IR/CIRDialect.h"
22-
#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
23-
#include "clang/CIR/Dialect/IR/CIRTypes.h"
2421
#include "clang/CIR/Dialect/Passes.h"
2522
#include "clang/CIR/Interfaces/ASTAttrInterfaces.h"
2623
#include "llvm/ADT/APFloat.h"
27-
#include "llvm/ADT/STLExtras.h"
2824
#include "llvm/ADT/SmallVector.h"
2925
#include "llvm/ADT/StringMap.h"
3026
#include "llvm/ADT/StringRef.h"
@@ -89,7 +85,6 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> {
8985
void lowerToMemCpy(StoreOp op);
9086
void lowerArrayDtor(ArrayDtor op);
9187
void lowerArrayCtor(ArrayCtor op);
92-
void lowerStdInitializerListOp(StdInitializerListOp op);
9388

9489
/// Collect annotations of global values in the module
9590
void addGlobalAnnotations(mlir::Operation *op, mlir::ArrayAttr annotations);
@@ -1125,79 +1120,6 @@ void LoweringPreparePass::lowerIterEndOp(IterEndOp op) {
11251120
op.erase();
11261121
}
11271122

1128-
/// lowering construction of std::initializer_list.
1129-
/// 1. alloca array for arg list.
1130-
/// 2. copy arg list to array.
1131-
/// 3. construct std::initializer_list from array.
1132-
void LoweringPreparePass::lowerStdInitializerListOp(StdInitializerListOp op) {
1133-
auto loc = op.getLoc();
1134-
cir::CIRDataLayout dataLayout(theModule);
1135-
auto args = op.getArgs();
1136-
1137-
auto stdInitializerListType = mlir::cast<cir::StructType>(
1138-
mlir::cast<cir::PointerType>(op.getInitList().getType()).getPointee());
1139-
clang::RecordDecl::field_range stdInitializerListFields =
1140-
stdInitializerListType.getAst().getRawDecl()->fields();
1141-
1142-
mlir::Type elementType =
1143-
mlir::cast<cir::PointerType>(stdInitializerListType.getMembers()[0])
1144-
.getPointee();
1145-
auto tempArrayType =
1146-
cir::ArrayType::get(&getContext(), elementType, args.size());
1147-
1148-
CIRBaseBuilderTy builder(getContext());
1149-
builder.setInsertionPointAfter(op);
1150-
1151-
IntegerAttr alignment = builder.getI64IntegerAttr(
1152-
dataLayout.getPrefTypeAlign(tempArrayType).value());
1153-
assert(!cir::MissingFeatures::addressSpace());
1154-
mlir::Value arrayPtr = builder.createAlloca(
1155-
loc, cir::PointerType::get(tempArrayType), tempArrayType, "", alignment);
1156-
mlir::Value arrayStartPtr =
1157-
builder.createCast(cir::CastKind::array_to_ptrdecay, arrayPtr,
1158-
cir::PointerType::get(elementType));
1159-
for (unsigned i = 0; i < args.size(); i++) {
1160-
if (i == 0) {
1161-
builder.createStore(loc, args[i], arrayStartPtr);
1162-
} else {
1163-
mlir::Value offset = builder.getUnsignedInt(loc, i, 64);
1164-
mlir::Value dest = builder.create<cir::PtrStrideOp>(
1165-
loc, arrayStartPtr.getType(), arrayStartPtr, offset);
1166-
builder.createStore(loc, args[i], dest);
1167-
}
1168-
}
1169-
1170-
// FIXME(cir): better handling according to different field type. [ptr ptr],
1171-
// [ptr size], [size ptr].
1172-
1173-
clang::RecordDecl::field_iterator it = stdInitializerListFields.begin();
1174-
const clang::RecordDecl::field_iterator startField = it;
1175-
const unsigned startIdx = 0U;
1176-
const clang::RecordDecl::field_iterator endOrSizeField = ++it;
1177-
const unsigned endOrSizeIdx = 1U;
1178-
assert(llvm::range_size(stdInitializerListFields) == 2U);
1179-
1180-
mlir::Value startMemberPtr = builder.createGetMemberOp(
1181-
loc, op.getInitList(), startField->getName().data(), startIdx);
1182-
builder.createStore(loc, arrayStartPtr, startMemberPtr);
1183-
1184-
mlir::Value size = builder.getUnsignedInt(loc, args.size(), 64);
1185-
if (endOrSizeField->getType()->isPointerType()) {
1186-
mlir::Value arrayEndPtr = builder.create<cir::PtrStrideOp>(
1187-
loc, arrayStartPtr.getType(), arrayStartPtr, size);
1188-
mlir::Value endMemberPtr = builder.createGetMemberOp(
1189-
loc, op.getInitList(), endOrSizeField->getName().data(), endOrSizeIdx);
1190-
builder.createStore(loc, arrayEndPtr, endMemberPtr);
1191-
} else {
1192-
assert(endOrSizeField->getType()->isIntegerType());
1193-
mlir::Value sizeMemberPtr = builder.createGetMemberOp(
1194-
loc, op.getInitList(), endOrSizeField->getName().data(), endOrSizeIdx);
1195-
builder.createStore(loc, size, sizeMemberPtr);
1196-
}
1197-
1198-
op.erase();
1199-
}
1200-
12011123
void LoweringPreparePass::addGlobalAnnotations(mlir::Operation *op,
12021124
mlir::ArrayAttr annotations) {
12031125
auto globalValue = cast<mlir::SymbolOpInterface>(op);
@@ -1258,8 +1180,6 @@ void LoweringPreparePass::runOnOp(Operation *op) {
12581180
}
12591181
if (std::optional<mlir::ArrayAttr> annotations = fnOp.getAnnotations())
12601182
addGlobalAnnotations(fnOp, annotations.value());
1261-
} else if (auto stdInitializerListOp = dyn_cast<StdInitializerListOp>(op)) {
1262-
lowerStdInitializerListOp(stdInitializerListOp);
12631183
}
12641184
}
12651185

@@ -1275,8 +1195,7 @@ void LoweringPreparePass::runOnOperation() {
12751195
op->walk([&](Operation *op) {
12761196
if (isa<UnaryOp, BinOp, CastOp, ComplexBinOp, CmpThreeWayOp, VAArgOp,
12771197
GlobalOp, DynamicCastOp, StdFindOp, IterEndOp, IterBeginOp,
1278-
ArrayCtor, ArrayDtor, cir::FuncOp, StoreOp, StdInitializerListOp>(
1279-
op))
1198+
ArrayCtor, ArrayDtor, cir::FuncOp, StoreOp>(op))
12801199
opsToTransform.push_back(op);
12811200
});
12821201

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

Lines changed: 12 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,3 @@
1-
// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-cir %s -o %t.cir -clangir-disable-passes
2-
// RUN: FileCheck --check-prefix=BEFORE --input-file=%t.cir %s
31
// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-cir %s -o %t.cir
42
// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
53
// RUN: %clang_cc1 -triple aarch64-none-linux-android21 -fclangir -emit-llvm -fno-clangir-call-conv-lowering %s -o %t.ll
@@ -17,16 +15,6 @@ void test() {
1715
}
1816
} // namespace std
1917

20-
// 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>
21-
// BEFORE: %0 = cir.alloca [[INITLIST_TYPE]], !cir.ptr<[[INITLIST_TYPE]]>,
22-
// BEFORE: %1 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
23-
// BEFORE: %2 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
24-
// BEFORE: %3 = cir.get_global @".str.1" : !cir.ptr<!cir.array<!s8i x 3>>
25-
// BEFORE: %4 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
26-
// BEFORE: cir.std.initializer_list %0 (%2, %4 : !cir.ptr<!s8i>, !cir.ptr<!s8i>) : !cir.ptr<[[INITLIST_TYPE]]>
27-
// BEFORE: %5 = cir.load %0 : !cir.ptr<[[INITLIST_TYPE]]>, [[INITLIST_TYPE]]
28-
// BEFORE: cir.call @_ZSt1fIPKcEvSt16initializer_listIT_E(%5) : ([[INITLIST_TYPE]]) -> ()
29-
3018
// CIR: [[INITLIST_TYPE:!.*]] = !cir.struct<class "std::initializer_list<const char *>" {!cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!s8i>>}>
3119
// CIR: cir.func linkonce_odr @_ZSt1fIPKcEvSt16initializer_listIT_E(%arg0: [[INITLIST_TYPE]]
3220
// CIR: [[LOCAL:%.*]] = cir.alloca [[INITLIST_TYPE]], !cir.ptr<[[INITLIST_TYPE]]>,
@@ -39,22 +27,24 @@ void test() {
3927
// CIR: cir.func @_ZSt4testv()
4028
// CIR: cir.scope {
4129
// CIR: [[INITLIST_LOCAL:%.*]] = cir.alloca [[INITLIST_TYPE]], !cir.ptr<[[INITLIST_TYPE]]>,
30+
// CIR: [[LOCAL_ELEM_ARRAY:%.*]] = cir.alloca !cir.array<!cir.ptr<!s8i> x 2>, !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>,
31+
// 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>>
4232
// CIR: [[XY_CHAR_ARRAY:%.*]] = cir.get_global [[STR_XY]] : !cir.ptr<!cir.array<!s8i x 3>>
4333
// CIR: [[STR_XY_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[XY_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
34+
// CIR: cir.store [[STR_XY_PTR]], [[FIRST_ELEM_PTR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
35+
// CIR: [[ONE:%.*]] = cir.const #cir.int<1>
36+
// CIR: [[NEXT_ELEM_PTR:%.*]] = cir.ptr_stride([[FIRST_ELEM_PTR]] : !cir.ptr<!cir.ptr<!s8i>>, [[ONE]] : !s64i), !cir.ptr<!cir.ptr<!s8i>>
4437
// CIR: [[UV_CHAR_ARRAY:%.*]] = cir.get_global [[STR_UV]] : !cir.ptr<!cir.array<!s8i x 3>>
4538
// CIR: [[STR_UV_PTR:%.*]] = cir.cast(array_to_ptrdecay, [[UV_CHAR_ARRAY]] : !cir.ptr<!cir.array<!s8i x 3>>), !cir.ptr<!s8i>
46-
// CIR: [[LOCAL_ELEM_ARRAY:%.*]] = cir.alloca !cir.array<!cir.ptr<!s8i> x 2>, !cir.ptr<!cir.array<!cir.ptr<!s8i> x 2>>,
47-
// 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>>
48-
// CIR: cir.store [[STR_XY_PTR]], [[ELEM_BEGIN]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
49-
// CIR: [[ONE:%.*]] = cir.const #cir.int<1>
50-
// CIR: [[NEXT_ELEM_PTR:%.*]] = cir.ptr_stride([[ELEM_BEGIN]] : !cir.ptr<!cir.ptr<!s8i>>, [[ONE]] : !u64i), !cir.ptr<!cir.ptr<!s8i>>
5139
// CIR: cir.store [[STR_UV_PTR]], [[NEXT_ELEM_PTR]] : !cir.ptr<!s8i>, !cir.ptr<!cir.ptr<!s8i>>
5240
// CIR: [[START_FLD_PTR:%.*]] = cir.get_member [[INITLIST_LOCAL]][0] {name = "array_start"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
53-
// CIR: cir.store [[ELEM_BEGIN]], [[START_FLD_PTR]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
41+
// 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>>>
42+
// 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>>>
5443
// CIR: [[ELEM_ARRAY_LEN:%.*]] = cir.const #cir.int<2>
55-
// CIR: [[ELEM_END:%.*]] = cir.ptr_stride([[ELEM_BEGIN]] : !cir.ptr<!cir.ptr<!s8i>>, [[ELEM_ARRAY_LEN]] : !u64i), !cir.ptr<!cir.ptr<!s8i>>
5644
// CIR: [[END_FLD_PTR:%.*]] = cir.get_member [[INITLIST_LOCAL]][1] {name = "array_end"} : !cir.ptr<[[INITLIST_TYPE]]> -> !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
57-
// CIR: cir.store [[ELEM_END]], [[END_FLD_PTR]] : !cir.ptr<!cir.ptr<!s8i>>, !cir.ptr<!cir.ptr<!cir.ptr<!s8i>>>
45+
// 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>>
46+
// 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>>>
47+
// 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>>>
5848
// CIR: [[ARG:%.*]] = cir.load [[INITLIST_LOCAL]] : !cir.ptr<[[INITLIST_TYPE]]>, [[INITLIST_TYPE]]
5949
// CIR: cir.call @_ZSt1fIPKcEvSt16initializer_listIT_E([[ARG]]) : ([[INITLIST_TYPE]]) -> ()
6050
// CIR: }
@@ -82,9 +72,9 @@ void test() {
8272
// LLVM: [[PTR_SECOND_ELEM:%.*]] = getelementptr ptr, ptr [[PTR_FIRST_ELEM]], i64 1
8373
// LLVM: store ptr @.str.1, ptr [[PTR_SECOND_ELEM]], align 8
8474
// LLVM: [[INIT_START_FLD_PTR:%.*]] = getelementptr %"class.std::initializer_list<const char *>", ptr [[INIT_STRUCT]], i32 0, i32 0
85-
// LLVM: store ptr [[PTR_FIRST_ELEM]], ptr [[INIT_START_FLD_PTR]], align 8
86-
// LLVM: [[ELEM_ARRAY_END:%.*]] = getelementptr ptr, ptr [[PTR_FIRST_ELEM]], i64 2
75+
// LLVM: store ptr [[ELEM_ARRAY_PTR]], ptr [[INIT_START_FLD_PTR]], align 8
8776
// LLVM: [[INIT_END_FLD_PTR:%.*]] = getelementptr %"class.std::initializer_list<const char *>", ptr [[INIT_STRUCT]], i32 0, i32 1
77+
// LLVM: [[ELEM_ARRAY_END:%.*]] = getelementptr [2 x ptr], ptr [[ELEM_ARRAY_PTR]], i64 2
8878
// LLVM: store ptr [[ELEM_ARRAY_END]], ptr [[INIT_END_FLD_PTR]], align 8
8979
// LLVM: [[ARG2PASS:%.*]] = load %"class.std::initializer_list<const char *>", ptr [[INIT_STRUCT]], align 8
9080
// LLVM: call void @_ZSt1fIPKcEvSt16initializer_listIT_E(%"class.std::initializer_list<const char *>" [[ARG2PASS]])

0 commit comments

Comments
 (0)