[clang] e1021bb - [CIR] Implement CXX field default initialization (#157140)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Sep 5 13:19:46 PDT 2025
Author: Andy Kaylor
Date: 2025-09-05T13:19:43-07:00
New Revision: e1021bb9bdcbd75c0fa6164628b6f791d696214b
URL: https://github.com/llvm/llvm-project/commit/e1021bb9bdcbd75c0fa6164628b6f791d696214b
DIFF: https://github.com/llvm/llvm-project/commit/e1021bb9bdcbd75c0fa6164628b6f791d696214b.diff
LOG: [CIR] Implement CXX field default initialization (#157140)
This adds the code needed to handle default initialization for fields of
various types.
Added:
clang/test/CIR/CodeGen/cxx-default-init.cpp
Modified:
clang/lib/CIR/CodeGen/CIRGenClass.cpp
clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp
clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
clang/lib/CIR/CodeGen/CIRGenFunction.h
Removed:
################################################################################
diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
index ecfcd9f820a22..0a8dc2b62fe21 100644
--- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
@@ -517,17 +517,23 @@ void CIRGenFunction::emitInitializerForField(FieldDecl *field, LValue lhs,
QualType fieldType = field->getType();
switch (getEvaluationKind(fieldType)) {
case cir::TEK_Scalar:
- if (lhs.isSimple())
+ if (lhs.isSimple()) {
emitExprAsInit(init, field, lhs, false);
- else
- cgm.errorNYI(field->getSourceRange(),
- "emitInitializerForField: non-simple scalar");
+ } else {
+ RValue rhs = RValue::get(emitScalarExpr(init));
+ emitStoreThroughLValue(rhs, lhs);
+ }
break;
case cir::TEK_Complex:
- cgm.errorNYI(field->getSourceRange(), "emitInitializerForField: complex");
+ emitComplexExprIntoLValue(init, lhs, /*isInit=*/true);
break;
case cir::TEK_Aggregate: {
- cgm.errorNYI(field->getSourceRange(), "emitInitializerForField: aggregate");
+ assert(!cir::MissingFeatures::aggValueSlotGC());
+ assert(!cir::MissingFeatures::sanitizers());
+ AggValueSlot slot = AggValueSlot::forLValue(
+ lhs, AggValueSlot::IsDestructed, AggValueSlot::IsNotAliased,
+ getOverlapForFieldInit(field), AggValueSlot::IsNotZeroed);
+ emitAggExpr(init, slot);
break;
}
}
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp b/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
index 2e7fb9843b135..dc34d2b3baa8d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprAggregate.cpp
@@ -91,7 +91,10 @@ class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
void visitCXXParenListOrInitListExpr(Expr *e, ArrayRef<Expr *> args,
FieldDecl *initializedFieldInUnion,
Expr *arrayFiller);
-
+ void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *die) {
+ CIRGenFunction::CXXDefaultInitExprScope Scope(cgf, die);
+ Visit(die->getExpr());
+ }
void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *e) {
assert(!cir::MissingFeatures::aggValueSlotDestructedFlag());
Visit(e->getSubExpr());
@@ -232,10 +235,6 @@ class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
cgf.cgm.errorNYI(dae->getSourceRange(),
"AggExprEmitter: VisitCXXDefaultArgExpr");
}
- void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *die) {
- cgf.cgm.errorNYI(die->getSourceRange(),
- "AggExprEmitter: VisitCXXDefaultInitExpr");
- }
void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *e) {
cgf.cgm.errorNYI(e->getSourceRange(),
"AggExprEmitter: VisitCXXInheritedCtorInitExpr");
@@ -794,6 +793,26 @@ void CIRGenFunction::emitAggregateCopy(LValue dest, LValue src, QualType ty,
assert(!cir::MissingFeatures::opTBAA());
}
+// TODO(cir): This could be shared with classic codegen.
+AggValueSlot::Overlap_t
+CIRGenFunction::getOverlapForFieldInit(const FieldDecl *fd) {
+ if (!fd->hasAttr<NoUniqueAddressAttr>() || !fd->getType()->isRecordType())
+ return AggValueSlot::DoesNotOverlap;
+
+ // If the field lies entirely within the enclosing class's nvsize, its tail
+ // padding cannot overlap any already-initialized object. (The only subobjects
+ // with greater addresses that might already be initialized are vbases.)
+ const RecordDecl *classRD = fd->getParent();
+ const ASTRecordLayout &layout = getContext().getASTRecordLayout(classRD);
+ if (layout.getFieldOffset(fd->getFieldIndex()) +
+ getContext().getTypeSize(fd->getType()) <=
+ (uint64_t)getContext().toBits(layout.getNonVirtualSize()))
+ return AggValueSlot::DoesNotOverlap;
+
+ // The tail padding may contain values we need to preserve.
+ return AggValueSlot::MayOverlap;
+}
+
LValue CIRGenFunction::emitAggExprToLValue(const Expr *e) {
assert(hasAggregateEvaluationKind(e->getType()) && "Invalid argument!");
Address temp = createMemTemp(e->getType(), getLoc(e->getSourceRange()));
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp b/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp
index c90bd2126c754..d678ea0212aa5 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp
@@ -201,9 +201,8 @@ class ComplexExprEmitter : public StmtVisitor<ComplexExprEmitter, mlir::Value> {
return {};
}
mlir::Value VisitCXXDefaultInitExpr(CXXDefaultInitExpr *die) {
- cgf.cgm.errorNYI(die->getExprLoc(),
- "ComplexExprEmitter VisitCXXDefaultInitExpr");
- return {};
+ CIRGenFunction::CXXDefaultInitExprScope scope(cgf, die);
+ return Visit(die->getExpr());
}
mlir::Value VisitExprWithCleanups(ExprWithCleanups *e) {
cgf.cgm.errorNYI(e->getExprLoc(),
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
index 0e000cc494063..754ef79392916 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -661,6 +661,11 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
mlir::Value VisitUnaryImag(const UnaryOperator *e);
+ mlir::Value VisitCXXDefaultInitExpr(CXXDefaultInitExpr *die) {
+ CIRGenFunction::CXXDefaultInitExprScope scope(cgf, die);
+ return Visit(die->getExpr());
+ }
+
mlir::Value VisitCXXThisExpr(CXXThisExpr *te) { return cgf.loadCXXThis(); }
mlir::Value VisitExprWithCleanups(ExprWithCleanups *e);
diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h
index 7a885c109794c..de9e3541ed840 100644
--- a/clang/lib/CIR/CodeGen/CIRGenFunction.h
+++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h
@@ -25,7 +25,9 @@
#include "clang/AST/ASTContext.h"
#include "clang/AST/BaseSubobject.h"
#include "clang/AST/CharUnits.h"
+#include "clang/AST/CurrentSourceLocExprScope.h"
#include "clang/AST/Decl.h"
+#include "clang/AST/ExprCXX.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/Type.h"
#include "clang/CIR/Dialect/IR/CIRDialect.h"
@@ -599,6 +601,12 @@ class CIRGenFunction : public CIRGenTypeCache {
/// true when both vcall CFI and whole-program-vtables are enabled.
bool shouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *rd);
+ /// Source location information about the default argument or member
+ /// initializer expression we're evaluating, if any.
+ clang::CurrentSourceLocExprScope curSourceLocExprScope;
+ using SourceLocExprScopeGuard =
+ clang::CurrentSourceLocExprScope::SourceLocExprScopeGuard;
+
/// A scope within which we are constructing the fields of an object which
/// might use a CXXDefaultInitExpr. This stashes away a 'this' value to use if
/// we need to evaluate the CXXDefaultInitExpr within the evaluation.
@@ -617,6 +625,29 @@ class CIRGenFunction : public CIRGenTypeCache {
Address oldCXXDefaultInitExprThis;
};
+ /// The scope of a CXXDefaultInitExpr. Within this scope, the value of 'this'
+ /// is overridden to be the object under construction.
+ class CXXDefaultInitExprScope {
+ public:
+ CXXDefaultInitExprScope(CIRGenFunction &cgf, const CXXDefaultInitExpr *e)
+ : cgf{cgf}, oldCXXThisValue(cgf.cxxThisValue),
+ oldCXXThisAlignment(cgf.cxxThisAlignment),
+ sourceLocScope(e, cgf.curSourceLocExprScope) {
+ cgf.cxxThisValue = cgf.cxxDefaultInitExprThis.getPointer();
+ cgf.cxxThisAlignment = cgf.cxxDefaultInitExprThis.getAlignment();
+ }
+ ~CXXDefaultInitExprScope() {
+ cgf.cxxThisValue = oldCXXThisValue;
+ cgf.cxxThisAlignment = oldCXXThisAlignment;
+ }
+
+ public:
+ CIRGenFunction &cgf;
+ mlir::Value oldCXXThisValue;
+ clang::CharUnits oldCXXThisAlignment;
+ SourceLocExprScopeGuard sourceLocScope;
+ };
+
LValue makeNaturalAlignPointeeAddrLValue(mlir::Value v, clang::QualType t);
LValue makeNaturalAlignAddrLValue(mlir::Value val, QualType ty);
@@ -658,6 +689,8 @@ class CIRGenFunction : public CIRGenTypeCache {
const clang::CXXRecordDecl *rd);
void initializeVTablePointer(mlir::Location loc, const VPtr &vptr);
+ AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *fd);
+
/// Return the address of a local variable.
Address getAddrOfLocalVar(const clang::VarDecl *vd) {
auto it = localDeclMap.find(vd);
diff --git a/clang/test/CIR/CodeGen/cxx-default-init.cpp b/clang/test/CIR/CodeGen/cxx-default-init.cpp
new file mode 100644
index 0000000000000..06d3a27f61cc9
--- /dev/null
+++ b/clang/test/CIR/CodeGen/cxx-default-init.cpp
@@ -0,0 +1,245 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -mconstructor-aliases -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s --check-prefix=CIR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -mconstructor-aliases -fclangir -emit-llvm %s -o %t-cir.ll
+// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -mconstructor-aliases -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=OGCG
+
+struct Pair {
+ int a;
+ int b;
+};
+
+struct ZeroInit {
+ int i{};
+ Pair p{};
+ int arr[4]{};
+ float _Complex c{};
+ unsigned bf : 8 {};
+ ZeroInit() = default;
+};
+
+// CIR: cir.func{{.*}} @_ZN8ZeroInitC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_ZeroInit> {{.*}})
+// CIR: %[[ITER:.*]] = cir.alloca {{.*}} ["arrayinit.temp"]
+// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA:.*]]
+// CIR: %[[I:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
+// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR: cir.store{{.*}} %[[ZERO]], %[[I]]
+// CIR: %[[P:.*]] = cir.get_member %[[THIS]][1] {name = "p"}
+// CIR: %[[P_A:.*]] = cir.get_member %[[P]][0] {name = "a"}
+// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR: cir.store{{.*}} %[[ZERO]], %[[P_A]]
+// CIR: %[[P_B:.*]] = cir.get_member %[[P]][1] {name = "b"}
+// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR: cir.store{{.*}} %[[ZERO]], %[[P_B]]
+// CIR: %[[ARR:.*]] = cir.get_member %[[THIS]][2] {name = "arr"}
+// CIR: %[[ARR_BEGIN:.*]] = cir.cast(array_to_ptrdecay, %[[ARR]] : !cir.ptr<!cir.array<!s32i x 4>>), !cir.ptr<!s32i>
+// CIR: cir.store{{.*}} %[[ARR_BEGIN]], %[[ITER]]
+// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s64i
+// CIR: %[[END:.*]] = cir.ptr_stride(%[[ARR_BEGIN]] : !cir.ptr<!s32i>, %[[FOUR]] : !s64i)
+// CIR: cir.do {
+// CIR: %[[CUR:.*]] = cir.load{{.*}} %[[ITER]]
+// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR: cir.store{{.*}} %[[ZERO]], %[[CUR]]
+// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
+// CIR: %[[NEXT:.*]] = cir.ptr_stride(%[[CUR]] : !cir.ptr<!s32i>, %[[ONE]] : !s64i)
+// CIR: cir.store{{.*}} %[[NEXT]], %[[ITER]]
+// CIR: cir.yield
+// CIR: } while {
+// CIR: %[[CUR:.*]] = cir.load{{.*}} %[[ITER]]
+// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[CUR]], %[[END]])
+// CIR: cir.condition(%[[CMP]])
+// CIR: }
+// CIR: %[[C:.*]] = cir.get_member %[[THIS]][3] {name = "c"}
+// CIR: %[[ZERO:.*]] = cir.const #cir.zero : !cir.complex<!cir.float>
+// CIR: cir.store{{.*}} %[[ZERO]], %[[C]]
+// CIR: %[[BF:.*]] = cir.get_member %[[THIS]][4] {name = "bf"}
+// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i
+// CIR: %[[BF_VAL:.*]] = cir.set_bitfield{{.*}} (#bfi_bf, %[[BF]] : !cir.ptr<!u8i>, %[[ZERO]] : !u32i)
+
+// LLVM: define{{.*}} void @_ZN8ZeroInitC2Ev(ptr %[[THIS_ARG:.*]])
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
+// LLVM: %[[ITER:.*]] = alloca ptr
+// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
+// LLVM: %[[I:.*]] = getelementptr %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 0
+// LLVM: store i32 0, ptr %[[I]]
+// LLVM: %[[P:.*]] = getelementptr %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 1
+// LLVM: %[[P_A:.*]] = getelementptr %struct.Pair, ptr %[[P]], i32 0, i32 0
+// LLVM: store i32 0, ptr %[[P_A]]
+// LLVM: %[[P_B:.*]] = getelementptr %struct.Pair, ptr %[[P]], i32 0, i32 1
+// LLVM: store i32 0, ptr %[[P_B]]
+// LLVM: %[[ARR:.*]] = getelementptr %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 2
+// LLVM: %[[ARR_BEGIN:.*]] = getelementptr i32, ptr %[[ARR]], i32 0
+// LLVM: store ptr %[[ARR_BEGIN]], ptr %[[ITER]]
+// LLVM: %[[ARR_END:.*]] = getelementptr i32, ptr %[[ARR_BEGIN]], i64 4
+// LLVM: br label %[[LOOP_BODY:.*]]
+// LLVM: [[LOOP_COND:.*]]:
+// LLVM: %[[CUR:.*]] = load ptr, ptr %[[ITER]]
+// LLVM: %[[CMP:.*]] = icmp ne ptr %[[CUR]], %[[ARR_END]]
+// LLVM: br i1 %[[CMP]], label %[[LOOP_BODY]], label %[[LOOP_END:.*]]
+// LLVM: [[LOOP_BODY]]:
+// LLVM: %[[CUR:.*]] = load ptr, ptr %[[ITER]]
+// LLVM: store i32 0, ptr %[[CUR]]
+// LLVM: %[[NEXT:.*]] = getelementptr i32, ptr %[[CUR]], i64 1
+// LLVM: store ptr %[[NEXT]], ptr %[[ITER]]
+// LLVM: br label %[[LOOP_COND]]
+// LLVM: [[LOOP_END]]:
+// LLVM: %[[C:.*]] = getelementptr %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 3
+// LLVM: store { float, float } zeroinitializer, ptr %[[C]]
+// LLVM: %[[BF:.*]] = getelementptr %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 4
+// LLVM: store i8 0, ptr %[[BF]]
+
+// OGCG: define{{.*}} void @_ZN8ZeroInitC2Ev(ptr {{.*}} %[[THIS_ARG:.*]])
+// OGCG: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA:.*]]
+// OGCG: %[[I:.*]] = getelementptr inbounds nuw %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 0
+// OGCG: store i32 0, ptr %[[I]]
+// OGCG: %[[P:.*]] = getelementptr inbounds nuw %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 1
+// OGCG: %[[P_A:.*]] = getelementptr inbounds nuw %struct.Pair, ptr %[[P]], i32 0, i32 0
+// OGCG: store i32 0, ptr %[[P_A]]
+// OGCG: %[[P_B:.*]] = getelementptr inbounds nuw %struct.Pair, ptr %[[P]], i32 0, i32 1
+// OGCG: store i32 0, ptr %[[P_B]]
+// OGCG: %[[ARR:.*]] = getelementptr inbounds nuw %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 2
+// OGCG: %[[ARR_END:.*]] = getelementptr inbounds i32, ptr %[[ARR]], i64 4
+// OGCG: br label %[[LOOP_BODY:.*]]
+// OGCG: [[LOOP_BODY]]:
+// OGCG: %[[CUR:.*]] = phi ptr [ %[[ARR]], %entry ], [ %[[NEXT:.*]], %[[LOOP_BODY]] ]
+// OGCG: store i32 0, ptr %[[CUR]]
+// OGCG: %[[NEXT]] = getelementptr inbounds i32, ptr %[[CUR]], i64 1
+// OGCG: %[[CMP:.*]] = icmp eq ptr %[[NEXT]], %[[ARR_END]]
+// OGCG: br i1 %[[CMP]], label %[[LOOP_END:.*]], label %[[LOOP_BODY]]
+// OGCG: [[LOOP_END]]:
+// OGCG: %[[C:.*]] = getelementptr inbounds nuw %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 3
+// OGCG: %[[C_REAL_PTR:.*]] = getelementptr inbounds nuw { float, float }, ptr %[[C]], i32 0, i32 0
+// OGCG: %[[C_IMAG_PTR:.*]] = getelementptr inbounds nuw { float, float }, ptr %[[C]], i32 0, i32 1
+// OGCG: store float 0.000000e+00, ptr %[[C_REAL_PTR]]
+// OGCG: store float 0.000000e+00, ptr %[[C_IMAG_PTR]]
+// OGCG: %[[BF:.*]] = getelementptr inbounds nuw %struct.ZeroInit, ptr %[[THIS]], i32 0, i32 4
+// OGCG: store i8 0, ptr %[[BF]]
+
+struct ValueInit {
+ int i{1};
+ Pair p{2, 3};
+ int arr[4]{4, 5};
+ float _Complex c{6.0f, 7.0f};
+ unsigned bf : 8 {0xFF};
+ ValueInit() = default;
+};
+
+// CIR: cir.func{{.*}} @_ZN9ValueInitC2Ev(%[[THIS_ARG:.*]]: !cir.ptr<!rec_ValueInit> {{.*}})
+// CIR: %[[ITER:.*]] = cir.alloca {{.*}} ["arrayinit.temp"]
+// CIR: %[[THIS:.*]] = cir.load %[[THIS_ALLOCA:.*]]
+// CIR: %[[I:.*]] = cir.get_member %[[THIS]][0] {name = "i"}
+// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
+// CIR: cir.store{{.*}} %[[ONE]], %[[I]]
+// CIR: %[[P:.*]] = cir.get_member %[[THIS]][1] {name = "p"}
+// CIR: %[[P_A:.*]] = cir.get_member %[[P]][0] {name = "a"}
+// CIR: %[[TWO:.*]] = cir.const #cir.int<2> : !s32i
+// CIR: cir.store{{.*}} %[[TWO]], %[[P_A]]
+// CIR: %[[P_B:.*]] = cir.get_member %[[P]][1] {name = "b"}
+// CIR: %[[THREE:.*]] = cir.const #cir.int<3> : !s32i
+// CIR: cir.store{{.*}} %[[THREE]], %[[P_B]]
+// CIR: %[[ARR:.*]] = cir.get_member %[[THIS]][2] {name = "arr"}
+// CIR: %[[ARR_BEGIN:.*]] = cir.cast(array_to_ptrdecay, %[[ARR]] : !cir.ptr<!cir.array<!s32i x 4>>), !cir.ptr<!s32i>
+// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s32i
+// CIR: cir.store{{.*}} %[[FOUR]], %[[ARR_BEGIN]]
+// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
+// CIR: %[[SECOND:.*]] = cir.ptr_stride(%[[ARR_BEGIN]] : !cir.ptr<!s32i>, %[[ONE]] : !s64i)
+// CIR: %[[FIVE:.*]] = cir.const #cir.int<5> : !s32i
+// CIR: cir.store{{.*}} %[[FIVE]], %[[SECOND]]
+// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
+// CIR: %[[NEXT:.*]] = cir.ptr_stride(%[[SECOND]] : !cir.ptr<!s32i>, %[[ONE]] : !s64i)
+// CIR: cir.store{{.*}} %[[NEXT]], %[[ITER]]
+// CIR: %[[FOUR:.*]] = cir.const #cir.int<4> : !s64i
+// CIR: %[[END:.*]] = cir.ptr_stride(%[[ARR_BEGIN]] : !cir.ptr<!s32i>, %[[FOUR]] : !s64i)
+// CIR: cir.do {
+// CIR: %[[CUR:.*]] = cir.load{{.*}} %[[ITER]]
+// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
+// CIR: cir.store{{.*}} %[[ZERO]], %[[CUR]]
+// CIR: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i
+// CIR: %[[NEXT:.*]] = cir.ptr_stride(%[[CUR]] : !cir.ptr<!s32i>, %[[ONE]] : !s64i)
+// CIR: cir.store{{.*}} %[[NEXT]], %[[ITER]]
+// CIR: cir.yield
+// CIR: } while {
+// CIR: %[[CUR:.*]] = cir.load{{.*}} %[[ITER]]
+// CIR: %[[CMP:.*]] = cir.cmp(ne, %[[CUR]], %[[END]])
+// CIR: cir.condition(%[[CMP]])
+// CIR: }
+// CIR: %[[C:.*]] = cir.get_member %[[THIS]][3] {name = "c"}
+// CIR: %[[FOUR_FIVEI:.*]] = cir.const #cir.const_complex<#cir.fp<6.000000e+00> : !cir.float, #cir.fp<7.000000e+00>
+// CIR: cir.store{{.*}} %[[FOUR_FIVEI]], %[[C]]
+// CIR: %[[BF:.*]] = cir.get_member %[[THIS]][4] {name = "bf"}
+// CIR: %[[FF:.*]] = cir.const #cir.int<255> : !s32i
+// CIR: %[[FF_CAST:.*]] = cir.cast(integral, %[[FF]] : !s32i), !u32i
+// CIR: %[[BF_VAL:.*]] = cir.set_bitfield{{.*}} (#bfi_bf, %[[BF]] : !cir.ptr<!u8i>, %[[FF_CAST]] : !u32i)
+
+// LLVM: define{{.*}} void @_ZN9ValueInitC2Ev(ptr %[[THIS_ARG:.*]])
+// LLVM: %[[THIS_ALLOCA:.*]] = alloca ptr
+// LLVM: %[[ITER:.*]] = alloca ptr
+// LLVM: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA]]
+// LLVM: %[[I:.*]] = getelementptr %struct.ValueInit, ptr %[[THIS]], i32 0, i32 0
+// LLVM: store i32 1, ptr %[[I]]
+// LLVM: %[[P:.*]] = getelementptr %struct.ValueInit, ptr %[[THIS]], i32 0, i32 1
+// LLVM: %[[P_A:.*]] = getelementptr %struct.Pair, ptr %[[P]], i32 0, i32 0
+// LLVM: store i32 2, ptr %[[P_A]]
+// LLVM: %[[P_B:.*]] = getelementptr %struct.Pair, ptr %[[P]], i32 0, i32 1
+// LLVM: store i32 3, ptr %[[P_B]]
+// LLVM: %[[ARR:.*]] = getelementptr %struct.ValueInit, ptr %[[THIS]], i32 0, i32 2
+// LLVM: %[[ARR_BEGIN:.*]] = getelementptr i32, ptr %[[ARR]], i32 0
+// LLVM: store i32 4, ptr %[[ARR_BEGIN]]
+// LLVM: %[[ARR_1:.*]] = getelementptr i32, ptr %[[ARR_BEGIN]], i64 1
+// LLVM: store i32 5, ptr %[[ARR_1]]
+// LLVM: %[[ARR_2:.*]] = getelementptr i32, ptr %[[ARR_1]], i64 1
+// LLVM: store ptr %[[ARR_2]], ptr %[[ITER]]
+// LLVM: %[[ARR_END:.*]] = getelementptr i32, ptr %[[ARR_BEGIN]], i64 4
+// LLVM: br label %[[LOOP_BODY:.*]]
+// LLVM: [[LOOP_COND:.*]]:
+// LLVM: %[[CUR:.*]] = load ptr, ptr %[[ITER]]
+// LLVM: %[[CMP:.*]] = icmp ne ptr %[[CUR]], %[[ARR_END]]
+// LLVM: br i1 %[[CMP]], label %[[LOOP_BODY]], label %[[LOOP_END:.*]]
+// LLVM: [[LOOP_BODY]]:
+// LLVM: %[[CUR:.*]] = load ptr, ptr %[[ITER]]
+// LLVM: store i32 0, ptr %[[CUR]]
+// LLVM: %[[NEXT:.*]] = getelementptr i32, ptr %[[CUR]], i64 1
+// LLVM: store ptr %[[NEXT]], ptr %[[ITER]]
+// LLVM: br label %[[LOOP_COND]]
+// LLVM: [[LOOP_END]]:
+// LLVM: %[[C:.*]] = getelementptr %struct.ValueInit, ptr %[[THIS]], i32 0, i32 3
+// LLVM: store { float, float } { float 6.000000e+00, float 7.000000e+00 }, ptr %[[C]]
+// LLVM: %[[BF:.*]] = getelementptr %struct.ValueInit, ptr %[[THIS]], i32 0, i32 4
+// LLVM: store i8 -1, ptr %[[BF]]
+
+// OGCG: define{{.*}} void @_ZN9ValueInitC2Ev(ptr {{.*}} %[[THIS_ARG:.*]])
+// OGCG: %[[THIS:.*]] = load ptr, ptr %[[THIS_ALLOCA:.*]]
+// OGCG: %[[I:.*]] = getelementptr inbounds nuw %struct.ValueInit, ptr %[[THIS]], i32 0, i32 0
+// OGCG: store i32 1, ptr %[[I]]
+// OGCG: %[[P:.*]] = getelementptr inbounds nuw %struct.ValueInit, ptr %[[THIS]], i32 0, i32 1
+// OGCG: %[[P_A:.*]] = getelementptr inbounds nuw %struct.Pair, ptr %[[P]], i32 0, i32 0
+// OGCG: store i32 2, ptr %[[P_A]]
+// OGCG: %[[P_B:.*]] = getelementptr inbounds nuw %struct.Pair, ptr %[[P]], i32 0, i32 1
+// OGCG: store i32 3, ptr %[[P_B]]
+// OGCG: %[[ARR:.*]] = getelementptr inbounds nuw %struct.ValueInit, ptr %[[THIS]], i32 0, i32 2
+// OGCG: store i32 4, ptr %[[ARR]]
+// OGCG: %[[ARR_1:.*]] = getelementptr inbounds i32, ptr %[[ARR]], i64 1
+// OGCG: store i32 5, ptr %[[ARR_1]]
+// OGCG: %[[ARR_BEGIN:.*]] = getelementptr inbounds i32, ptr %[[ARR]], i64 2
+// OGCG: %[[ARR_END:.*]] = getelementptr inbounds i32, ptr %[[ARR]], i64 4
+// OGCG: br label %[[LOOP_BODY:.*]]
+// OGCG: [[LOOP_BODY]]:
+// OGCG: %[[CUR:.*]] = phi ptr [ %[[ARR_BEGIN]], %entry ], [ %[[NEXT:.*]], %[[LOOP_BODY]] ]
+// OGCG: store i32 0, ptr %[[CUR]]
+// OGCG: %[[NEXT]] = getelementptr inbounds i32, ptr %[[CUR]], i64 1
+// OGCG: %[[CMP:.*]] = icmp eq ptr %[[NEXT]], %[[ARR_END]]
+// OGCG: br i1 %[[CMP]], label %[[LOOP_END:.*]], label %[[LOOP_BODY]]
+// OGCG: [[LOOP_END]]:
+// OGCG: %[[C:.*]] = getelementptr inbounds nuw %struct.ValueInit, ptr %[[THIS]], i32 0, i32 3
+// OGCG: %[[C_REAL_PTR:.*]] = getelementptr inbounds nuw { float, float }, ptr %[[C]], i32 0, i32 0
+// OGCG: %[[C_IMAG_PTR:.*]] = getelementptr inbounds nuw { float, float }, ptr %[[C]], i32 0, i32 1
+// OGCG: store float 6.000000e+00, ptr %[[C_REAL_PTR]]
+// OGCG: store float 7.000000e+00, ptr %[[C_IMAG_PTR]]
+// OGCG: %[[BF:.*]] = getelementptr inbounds nuw %struct.ValueInit, ptr %[[THIS]], i32 0, i32 4
+// OGCG: store i8 -1, ptr %[[BF]]
+
+void use_structs() {
+ ZeroInit zi;
+ ValueInit vi;
+}
More information about the cfe-commits
mailing list