Skip to content

Commit fd4af2e

Browse files
sitio-coutolanza
sitio-couto
authored and
lanza
committed
[CIR] Refactor StructElementAddr into GetMemberOp
Improves a few aspects of the old CIR GEP equivalent: * Generalize the name to GetMemberOp, since it can be used for unions, classes, structs, and others. * Add custom assembly format to improve readability. * Add a new CIR dialect operation to represent the operation. * Remove redundancy from arguments names (e.g. "member_index" to just "index") for terseness. * Add verifier to check if: * The index is within bounds. * The type is a record (has members to be accessed). * The result type matches the type of the member. * Use CIRGenBuilder when building GetMemberOps. * Also add some getter wrappers. ghstack-source-id: f28916e Pull Request resolved: #228
1 parent 7c05fe4 commit fd4af2e

File tree

16 files changed

+115
-74
lines changed

16 files changed

+115
-74
lines changed

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

Lines changed: 34 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1409,41 +1409,47 @@ def VTableAddrPointOp : CIR_Op<"vtable.address_point",
14091409
}
14101410

14111411
//===----------------------------------------------------------------------===//
1412-
// StructElementAddr
1412+
// GetMemberOp
14131413
//===----------------------------------------------------------------------===//
14141414

1415-
// FIXME: rename this among the lines of GetGlobalOp.
1416-
def StructElementAddr : CIR_Op<"struct_element_addr"> {
1415+
def GetMemberOp : CIR_Op<"get_member"> {
14171416
let summary = "Get the address of a member of a struct";
14181417
let description = [{
1419-
The `cir.struct_element_addr` operaration gets the address of a particular
1420-
named member from the input struct.
1418+
The `cir.get_member` operation gets the address of a particular named
1419+
member from the input record.
14211420

1422-
It expects a pointer to the base struct as well as the name of the member
1421+
It expects a pointer to the base record as well as the name of the member
14231422
and its field index.
14241423

14251424
Example:
14261425
```mlir
1427-
!ty_22struct2EBar22 = type !cir.struct<"struct.Bar", i32, i8>
1428-
...
1429-
%0 = cir.alloca !ty_22struct2EBar22, cir.ptr <!ty_22struct2EBar22>
1430-
...
1431-
%1 = cir.struct_element_addr %0, "Bar.a"
1432-
%2 = cir.load %1 : cir.ptr <int>, int
1433-
...
1426+
// Suppose we have a struct with multiple members.
1427+
!s32i = !cir.int<s, 32>
1428+
!s8i = !cir.int<s, 32>
1429+
!struct_ty = !cir.struct<"struct.Bar" {!s32i, !s8i}>
1430+
1431+
// Get the address of the member at index 1.
1432+
%1 = cir.get_member %0[1] {name = "i"} : (!cir.ptr<!struct_ty>) -> !cir.ptr<!s8i>
14341433
```
14351434
}];
14361435

14371436
let arguments = (ins
1438-
Arg<CIR_PointerType, "the address to load from", [MemRead]>:$struct_addr,
1439-
StrAttr:$member_name,
1440-
IndexAttr:$member_index);
1437+
Arg<CIR_PointerType, "the address to load from", [MemRead]>:$addr,
1438+
StrAttr:$name,
1439+
IndexAttr:$index_attr);
14411440

14421441
let results = (outs Res<CIR_PointerType, "">:$result);
14431442

1443+
let assemblyFormat = [{
1444+
$addr `[` $index_attr `]` attr-dict
1445+
`:` qualified(type($addr)) `->` qualified(type($result))
1446+
}];
1447+
14441448
let builders = [
1445-
OpBuilder<(ins "Type":$type, "Value":$value, "llvm::StringRef":$name,
1446-
"unsigned":$index),
1449+
OpBuilder<(ins "Type":$type,
1450+
"Value":$value,
1451+
"llvm::StringRef":$name,
1452+
"unsigned":$index),
14471453
[{
14481454
mlir::APInt fieldIdx(64, index);
14491455
build($_builder, $_state, type, value, name, fieldIdx);
@@ -1452,10 +1458,18 @@ def StructElementAddr : CIR_Op<"struct_element_addr"> {
14521458

14531459
let extraClassDeclaration = [{
14541460
/// Return the index of the struct member being accessed.
1455-
uint64_t getIndex() { return getMemberIndex().getZExtValue(); }
1461+
uint64_t getIndex() { return getIndexAttr().getZExtValue(); }
1462+
1463+
/// Return the record type pointed by the base pointer.
1464+
mlir::cir::PointerType getAddrTy() { return getAddr().getType(); }
1465+
1466+
/// Return the result type.
1467+
mlir::cir::PointerType getResultTy() {
1468+
return getResult().getType().cast<mlir::cir::PointerType>();
1469+
}
14561470
}];
14571471

1458-
// FIXME: add verifier.
1472+
let hasVerifier = 1;
14591473
}
14601474

14611475
//===----------------------------------------------------------------------===//

‎clang/lib/CIR/CodeGen/CIRGenBuilder.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -602,6 +602,13 @@ class CIRGenBuilderTy : public mlir::OpBuilder {
602602
global.getLoc(), getPointerTo(global.getSymType()), global.getName());
603603
}
604604

605+
/// Create a pointer to a record member.
606+
mlir::Value createGetMember(mlir::Location loc, mlir::Type result,
607+
mlir::Value base, llvm::StringRef name,
608+
unsigned index) {
609+
return create<mlir::cir::GetMemberOp>(loc, result, base, name, index);
610+
}
611+
605612
/// Cast the element type of the given address to a different type,
606613
/// preserving information like the alignment.
607614
cir::Address createElementBitCast(mlir::Location loc, cir::Address addr,

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

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -72,13 +72,13 @@ static Address buildAddrOfFieldStorage(CIRGenFunction &CGF, Address Base,
7272
// For most cases fieldName is the same as field->getName() but for lambdas,
7373
// which do not currently carry the name, so it can be passed down from the
7474
// CaptureStmt.
75-
auto sea = CGF.getBuilder().create<mlir::cir::StructElementAddr>(
75+
auto memberAddr = CGF.getBuilder().createGetMember(
7676
loc, fieldPtr, Base.getPointer(), fieldName, fieldIndex);
7777

7878
// TODO: We could get the alignment from the CIRGenRecordLayout, but given the
7979
// member name based lookup of the member here we probably shouldn't be. We'll
8080
// have to consider this later.
81-
auto addr = Address(sea->getResult(0), CharUnits::One());
81+
auto addr = Address(memberAddr, CharUnits::One());
8282
return addr;
8383
}
8484

@@ -356,8 +356,7 @@ static CIRGenCallee buildDirectCallee(CIRGenModule &CGM, GlobalDecl GD) {
356356
// When directing calling an inline builtin, call it through it's mangled
357357
// name to make it clear it's not the actual builtin.
358358
auto Fn = cast<mlir::cir::FuncOp>(CGF.CurFn);
359-
if (Fn.getName() != FDInlineName &&
360-
onlyHasInlineBuiltinDeclaration(FD)) {
359+
if (Fn.getName() != FDInlineName && onlyHasInlineBuiltinDeclaration(FD)) {
361360
assert(0 && "NYI");
362361
}
363362

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

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2240,6 +2240,28 @@ LogicalResult MemCpyOp::verify() {
22402240
return mlir::success();
22412241
}
22422242

2243+
//===----------------------------------------------------------------------===//
2244+
// GetMemberOp Definitions
2245+
//===----------------------------------------------------------------------===//
2246+
2247+
LogicalResult GetMemberOp::verify() {
2248+
2249+
const auto recordTy = getAddrTy().getPointee().dyn_cast<StructType>();
2250+
if (!recordTy)
2251+
return emitError() << "expected pointer to a record type";
2252+
2253+
if (recordTy.getMembers().size() <= getIndex())
2254+
return emitError() << "member index out of bounds";
2255+
2256+
// FIXME(cir): Member type check is disabled for classes and incomplete types
2257+
// as the codegen for these still need to be patched.
2258+
if (!recordTy.isClass() && !recordTy.getBody() &&
2259+
recordTy.getMembers()[getIndex()] != getResultTy().getPointee())
2260+
return emitError() << "member type mismatch";
2261+
2262+
return mlir::success();
2263+
}
2264+
22432265
//===----------------------------------------------------------------------===//
22442266
// TableGen'd op method definitions
22452267
//===----------------------------------------------------------------------===//

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

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -477,12 +477,12 @@ static std::string getVarNameFromValue(mlir::Value v) {
477477

478478
if (auto allocaOp = dyn_cast<AllocaOp>(srcOp))
479479
return allocaOp.getName().str();
480-
if (auto getElemOp = dyn_cast<StructElementAddr>(srcOp)) {
481-
auto parent = dyn_cast<AllocaOp>(getElemOp.getStructAddr().getDefiningOp());
480+
if (auto getElemOp = dyn_cast<GetMemberOp>(srcOp)) {
481+
auto parent = dyn_cast<AllocaOp>(getElemOp.getAddr().getDefiningOp());
482482
if (parent) {
483483
llvm::SmallString<128> finalName;
484484
llvm::raw_svector_ostream Out(finalName);
485-
Out << parent.getName() << "." << getElemOp.getMemberName();
485+
Out << parent.getName() << "." << getElemOp.getName();
486486
return Out.str().str();
487487
}
488488
}
@@ -1048,12 +1048,12 @@ void LifetimeCheckPass::classifyAndInitTypeCategories(mlir::Value addr,
10481048
// Go through uses of the alloca via `cir.struct_element_addr`, and
10491049
// track only the fields that are actually used.
10501050
std::for_each(addr.use_begin(), addr.use_end(), [&](mlir::OpOperand &use) {
1051-
auto op = dyn_cast<mlir::cir::StructElementAddr>(use.getOwner());
1051+
auto op = dyn_cast<mlir::cir::GetMemberOp>(use.getOwner());
10521052
if (!op)
10531053
return;
10541054

10551055
auto eltAddr = op.getResult();
1056-
// If nothing is using this StructElementAddr, don't bother since
1056+
// If nothing is using this GetMemberOp, don't bother since
10571057
// it could lead to even more noisy outcomes.
10581058
if (eltAddr.use_empty())
10591059
return;
@@ -1063,7 +1063,7 @@ void LifetimeCheckPass::classifyAndInitTypeCategories(mlir::Value addr,
10631063

10641064
// Classify exploded types. Keep alloca original location.
10651065
classifyAndInitTypeCategories(eltAddr, eltTy, loc, ++nestLevel);
1066-
fieldVals[op.getMemberIndex().getZExtValue()] = eltAddr;
1066+
fieldVals[op.getIndex()] = eltAddr;
10671067
});
10681068

10691069
// In case this aggregate gets initialized at once, the fields need
@@ -1135,7 +1135,7 @@ void LifetimeCheckPass::checkCoroTaskStore(StoreOp storeOp) {
11351135
mlir::Value LifetimeCheckPass::getLambdaFromMemberAccess(mlir::Value addr) {
11361136
auto op = addr.getDefiningOp();
11371137
// FIXME: we likely want to consider more indirections here...
1138-
if (!isa<mlir::cir::StructElementAddr>(op))
1138+
if (!isa<mlir::cir::GetMemberOp>(op))
11391139
return nullptr;
11401140
auto allocaOp =
11411141
dyn_cast<mlir::cir::AllocaOp>(op->getOperand(0).getDefiningOp());
@@ -1443,7 +1443,7 @@ void LifetimeCheckPass::checkPointerDeref(mlir::Value addr, mlir::Location loc,
14431443
D << "returned lambda captures local variable";
14441444
else if (derefStyle == DerefStyle::CallParam ||
14451445
derefStyle == DerefStyle::IndirectCallParam) {
1446-
bool isAgg = isa_and_nonnull<StructElementAddr>(addr.getDefiningOp());
1446+
bool isAgg = isa_and_nonnull<GetMemberOp>(addr.getDefiningOp());
14471447
D << "passing ";
14481448
if (!isAgg)
14491449
D << "invalid pointer";

‎clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

Lines changed: 7 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1712,23 +1712,22 @@ class CIRBrOpLowering : public mlir::OpConversionPattern<mlir::cir::BrOp> {
17121712
}
17131713
};
17141714

1715-
class CIRStructElementAddrOpLowering
1716-
: public mlir::OpConversionPattern<mlir::cir::StructElementAddr> {
1715+
class CIRGetMemberOpLowering
1716+
: public mlir::OpConversionPattern<mlir::cir::GetMemberOp> {
17171717
public:
1718-
using mlir::OpConversionPattern<
1719-
mlir::cir::StructElementAddr>::OpConversionPattern;
1718+
using mlir::OpConversionPattern<mlir::cir::GetMemberOp>::OpConversionPattern;
17201719

17211720
mlir::LogicalResult
1722-
matchAndRewrite(mlir::cir::StructElementAddr op, OpAdaptor adaptor,
1721+
matchAndRewrite(mlir::cir::GetMemberOp op, OpAdaptor adaptor,
17231722
mlir::ConversionPatternRewriter &rewriter) const override {
17241723
auto llResTy = getTypeConverter()->convertType(op.getType());
17251724
// Since the base address is a pointer to structs, the first offset is
17261725
// always zero. The second offset tell us which member it will access.
17271726
llvm::SmallVector<mlir::LLVM::GEPArg> offset{0, op.getIndex()};
17281727
const auto elementTy = getTypeConverter()->convertType(
1729-
op.getStructAddr().getType().getPointee());
1728+
op.getAddr().getType().getPointee());
17301729
rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(
1731-
op, llResTy, elementTy, adaptor.getStructAddr(), offset);
1730+
op, llResTy, elementTy, adaptor.getAddr(), offset);
17321731
return mlir::success();
17331732
}
17341733
};
@@ -1784,7 +1783,7 @@ void populateCIRToLLVMConversionPatterns(mlir::RewritePatternSet &patterns,
17841783
CIRIfLowering, CIRGlobalOpLowering, CIRGetGlobalOpLowering,
17851784
CIRVAStartLowering, CIRVAEndLowering, CIRVACopyLowering,
17861785
CIRVAArgLowering, CIRBrOpLowering, CIRTernaryOpLowering,
1787-
CIRStructElementAddrOpLowering, CIRSwitchOpLowering,
1786+
CIRGetMemberOpLowering, CIRSwitchOpLowering,
17881787
CIRPtrDiffOpLowering, CIRCopyOpLowering, CIRMemCpyOpLowering>(
17891788
converter, patterns.getContext());
17901789
}

‎clang/test/CIR/CodeGen/String.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -21,10 +21,10 @@ void test() {
2121
// CHECK-NEXT: %0 = cir.alloca !cir.ptr<!ty_22String22>
2222
// CHECK-NEXT: cir.store %arg0, %0
2323
// CHECK-NEXT: %1 = cir.load %0
24-
// CHECK-NEXT: %2 = "cir.struct_element_addr"(%1) <{member_index = 0 : index, member_name = "storage"}>
24+
// CHECK-NEXT: %2 = cir.get_member %1[0] {name = "storage"}
2525
// CHECK-NEXT: %3 = cir.const(#cir.null : !cir.ptr<!s8i>) : !cir.ptr<!s8i>
2626
// CHECK-NEXT: cir.store %3, %2 : !cir.ptr<!s8i>, cir.ptr <!cir.ptr<!s8i>>
27-
// CHECK-NEXT: %4 = "cir.struct_element_addr"(%1) <{member_index = 1 : index, member_name = "size"}> : (!cir.ptr<!ty_22String22>) -> !cir.ptr<!s64i>
27+
// CHECK-NEXT: %4 = cir.get_member %1[1] {name = "size"} : !cir.ptr<!ty_22String22> -> !cir.ptr<!s64i>
2828
// CHECK-NEXT: %5 = cir.const(#cir.int<0> : !s32i) : !s32i
2929
// CHECK-NEXT: %6 = cir.cast(integral, %5 : !s32i), !s64i
3030
// CHECK-NEXT: cir.store %6, %4 : !s64i, cir.ptr <!s64i>
@@ -36,10 +36,10 @@ void test() {
3636
// CHECK-NEXT: cir.store %arg0, %0
3737
// CHECK-NEXT: cir.store %arg1, %1
3838
// CHECK-NEXT: %2 = cir.load %0
39-
// CHECK-NEXT: %3 = "cir.struct_element_addr"(%2) <{member_index = 0 : index, member_name = "storage"}>
39+
// CHECK-NEXT: %3 = cir.get_member %2[0] {name = "storage"}
4040
// CHECK-NEXT: %4 = cir.const(#cir.null : !cir.ptr<!s8i>)
4141
// CHECK-NEXT: cir.store %4, %3
42-
// CHECK-NEXT: %5 = "cir.struct_element_addr"(%2) <{member_index = 1 : index, member_name = "size"}> : (!cir.ptr<!ty_22String22>) -> !cir.ptr<!s64i>
42+
// CHECK-NEXT: %5 = cir.get_member %2[1] {name = "size"} : !cir.ptr<!ty_22String22> -> !cir.ptr<!s64i>
4343
// CHECK-NEXT: %6 = cir.load %1 : cir.ptr <!s32i>, !s32i
4444
// CHECK-NEXT: %7 = cir.cast(integral, %6 : !s32i), !s64i
4545
// CHECK-NEXT: cir.store %7, %5 : !s64i, cir.ptr <!s64i>
@@ -52,7 +52,7 @@ void test() {
5252
// CHECK-NEXT: cir.store %arg0, %0 : !cir.ptr<!ty_22String22>, cir.ptr <!cir.ptr<!ty_22String22>>
5353
// CHECK-NEXT: cir.store %arg1, %1 : !cir.ptr<!s8i>, cir.ptr <!cir.ptr<!s8i>>
5454
// CHECK-NEXT: %2 = cir.load %0 : cir.ptr <!cir.ptr<!ty_22String22>>, !cir.ptr<!ty_22String22>
55-
// CHECK-NEXT: %3 = "cir.struct_element_addr"(%2) <{member_index = 0 : index, member_name = "storage"}> : (!cir.ptr<!ty_22String22>) -> !cir.ptr<!cir.ptr<!s8i>>
55+
// CHECK-NEXT: %3 = cir.get_member %2[0] {name = "storage"} : !cir.ptr<!ty_22String22> -> !cir.ptr<!cir.ptr<!s8i>>
5656
// CHECK-NEXT: %4 = cir.const(#cir.null : !cir.ptr<!s8i>) : !cir.ptr<!s8i>
5757
// CHECK-NEXT: cir.store %4, %3 : !cir.ptr<!s8i>, cir.ptr <!cir.ptr<!s8i>>
5858
// CHECK-NEXT: cir.return

‎clang/test/CIR/CodeGen/agg-init.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -35,10 +35,10 @@ void use() { yop{}; }
3535

3636
// CHECK: cir.func @_Z3usev()
3737
// CHECK: %0 = cir.alloca !ty_22yep_22, cir.ptr <!ty_22yep_22>, ["agg.tmp0"] {alignment = 4 : i64}
38-
// CHECK: %1 = "cir.struct_element_addr"(%0) <{member_index = 0 : index, member_name = "Status"}> : (!cir.ptr<!ty_22yep_22>) -> !cir.ptr<!u32i>
38+
// CHECK: %1 = cir.get_member %0[0] {name = "Status"} : !cir.ptr<!ty_22yep_22> -> !cir.ptr<!u32i>
3939
// CHECK: %2 = cir.const(#cir.int<0> : !u32i) : !u32i
4040
// CHECK: cir.store %2, %1 : !u32i, cir.ptr <!u32i>
41-
// CHECK: %3 = "cir.struct_element_addr"(%0) <{member_index = 1 : index, member_name = "HC"}> : (!cir.ptr<!ty_22yep_22>) -> !cir.ptr<!u32i>
41+
// CHECK: %3 = cir.get_member %0[1] {name = "HC"} : !cir.ptr<!ty_22yep_22> -> !cir.ptr<!u32i>
4242
// CHECK: %4 = cir.const(#cir.int<0> : !u32i) : !u32i
4343
// CHECK: cir.store %4, %3 : !u32i, cir.ptr <!u32i>
4444
// CHECK: cir.return
@@ -68,12 +68,12 @@ void yo() {
6868
// CHECK: %1 = cir.alloca !ty_22Yo22, cir.ptr <!ty_22Yo22>, ["ext2", init] {alignment = 8 : i64}
6969
// CHECK: %2 = cir.const(#cir.const_struct<{#cir.int<1000070000> : !u32i, #cir.null : !cir.ptr<!void>, #cir.int<0> : !u64i}> : !ty_22Yo22) : !ty_22Yo22
7070
// CHECK: cir.store %2, %0 : !ty_22Yo22, cir.ptr <!ty_22Yo22>
71-
// CHECK: %3 = "cir.struct_element_addr"(%1) <{member_index = 0 : index, member_name = "type"}> : (!cir.ptr<!ty_22Yo22>) -> !cir.ptr<!u32i>
71+
// CHECK: %3 = cir.get_member %1[0] {name = "type"} : !cir.ptr<!ty_22Yo22> -> !cir.ptr<!u32i>
7272
// CHECK: %4 = cir.const(#cir.int<1000066001> : !u32i) : !u32i
7373
// CHECK: cir.store %4, %3 : !u32i, cir.ptr <!u32i>
74-
// CHECK: %5 = "cir.struct_element_addr"(%1) <{member_index = 1 : index, member_name = "next"}> : (!cir.ptr<!ty_22Yo22>) -> !cir.ptr<!cir.ptr<!void>>
74+
// CHECK: %5 = cir.get_member %1[1] {name = "next"} : !cir.ptr<!ty_22Yo22> -> !cir.ptr<!cir.ptr<!void>>
7575
// CHECK: %6 = cir.cast(bitcast, %0 : !cir.ptr<!ty_22Yo22>), !cir.ptr<!void>
7676
// CHECK: cir.store %6, %5 : !cir.ptr<!void>, cir.ptr <!cir.ptr<!void>>
77-
// CHECK: %7 = "cir.struct_element_addr"(%1) <{member_index = 2 : index, member_name = "createFlags"}> : (!cir.ptr<!ty_22Yo22>) -> !cir.ptr<!u64i>
77+
// CHECK: %7 = cir.get_member %1[2] {name = "createFlags"} : !cir.ptr<!ty_22Yo22> -> !cir.ptr<!u64i>
7878
// CHECK: %8 = cir.const(#cir.int<0> : !u64i) : !u64i
7979
// CHECK: cir.store %8, %7 : !u64i, cir.ptr <!u64i>

‎clang/test/CIR/CodeGen/assign-operator.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -23,15 +23,15 @@ struct String {
2323

2424
// Get address of `this->size`
2525

26-
// CHECK: %3 = "cir.struct_element_addr"(%2) <{member_index = 0 : index, member_name = "size"}>
26+
// CHECK: %3 = cir.get_member %2[0] {name = "size"}
2727

2828
// Get address of `s`
2929

3030
// CHECK: %4 = cir.load %1 : cir.ptr <!cir.ptr<!ty_22String22>>
3131

3232
// Get the address of s.size
3333

34-
// CHECK: %5 = "cir.struct_element_addr"(%4) <{member_index = 0 : index, member_name = "size"}>
34+
// CHECK: %5 = cir.get_member %4[0] {name = "size"}
3535

3636
// Load value from s.size and store in this->size
3737

@@ -53,9 +53,9 @@ struct String {
5353
// CHECK: cir.store %arg1, %1 : !cir.ptr<!ty_22StringView22>
5454
// CHECK: %3 = cir.load deref %0 : cir.ptr <!cir.ptr<!ty_22StringView22>>
5555
// CHECK: %4 = cir.load %1 : cir.ptr <!cir.ptr<!ty_22StringView22>>
56-
// CHECK: %5 = "cir.struct_element_addr"(%4) <{member_index = 0 : index, member_name = "size"}>
56+
// CHECK: %5 = cir.get_member %4[0] {name = "size"}
5757
// CHECK: %6 = cir.load %5 : cir.ptr <!s64i>, !s64i
58-
// CHECK: %7 = "cir.struct_element_addr"(%3) <{member_index = 0 : index, member_name = "size"}>
58+
// CHECK: %7 = cir.get_member %3[0] {name = "size"}
5959
// CHECK: cir.store %6, %7 : !s64i, cir.ptr <!s64i>
6060
// CHECK: cir.store %3, %2 : !cir.ptr<!ty_22StringView22>
6161
// CHECK: %8 = cir.load %2 : cir.ptr <!cir.ptr<!ty_22StringView22>>

‎clang/test/CIR/CodeGen/ctor-member-lvalue-to-rvalue.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,9 @@ struct String {
1111
// CHECK: cir.store %arg0, %0
1212
// CHECK: cir.store %arg1, %1
1313
// CHECK: %2 = cir.load %0
14-
// CHECK: %3 = "cir.struct_element_addr"(%2) <{member_index = 0 : index, member_name = "size"}>
14+
// CHECK: %3 = cir.get_member %2[0] {name = "size"}
1515
// CHECK: %4 = cir.load %1
16-
// CHECK: %5 = "cir.struct_element_addr"(%4) <{member_index = 0 : index, member_name = "size"}>
16+
// CHECK: %5 = cir.get_member %4[0] {name = "size"}
1717
// CHECK: %6 = cir.load %5 : cir.ptr <!s64i>, !s64i
1818
// CHECK: cir.store %6, %3 : !s64i, cir.ptr <!s64i>
1919
// CHECK: cir.return

‎clang/test/CIR/CodeGen/derived-to-base.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -82,7 +82,7 @@ void C3::Layer::Initialize() {
8282

8383
// CHECK: cir.scope {
8484
// CHECK: %2 = cir.base_class_addr(%1 : cir.ptr <!ty_22C33A3ALayer22>) -> cir.ptr <!ty_22C23A3ALayer22>
85-
// CHECK: %3 = "cir.struct_element_addr"(%2) <{member_index = 0 : index, member_name = "m_C1"}> : (!cir.ptr<!ty_22C23A3ALayer22>) -> !cir.ptr<!cir.ptr<!ty_22C222>>
85+
// CHECK: %3 = cir.get_member %2[0] {name = "m_C1"} : !cir.ptr<!ty_22C23A3ALayer22> -> !cir.ptr<!cir.ptr<!ty_22C222>>
8686
// CHECK: %4 = cir.load %3 : cir.ptr <!cir.ptr<!ty_22C222>>, !cir.ptr<!ty_22C222>
8787
// CHECK: %5 = cir.const(#cir.null : !cir.ptr<!ty_22C222>) : !cir.ptr<!ty_22C222>
8888
// CHECK: %6 = cir.cmp(eq, %4, %5) : !cir.ptr<!ty_22C222>, !cir.bool
@@ -155,4 +155,4 @@ class B : public A {
155155
void t() {
156156
B b;
157157
b.foo();
158-
}
158+
}

0 commit comments

Comments
 (0)