[clang] [CIR] Extract CIR_ClassCastOp base class for BaseClassAddrOp and DerivedClassAddrOp (PR #195478)
via cfe-commits
cfe-commits at lists.llvm.org
Sat May 2 13:07:26 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: Henrich Lauko (xlauko)
<details>
<summary>Changes</summary>
Both ops have identical structure (arguments, results, assembly format)
and differ only in mnemonic and description. Extract a shared TableGen
base class to eliminate the duplication.
Improve the assembly format to be more consistent with the rest of CIR.
---
Patch is 43.14 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/195478.diff
20 Files Affected:
- (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+22-33)
- (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp (+18-18)
- (modified) clang/test/CIR/CodeGen/base-init-eh.cpp (+2-2)
- (modified) clang/test/CIR/CodeGen/base-to-derived.cpp (+3-3)
- (modified) clang/test/CIR/CodeGen/class.cpp (+2-2)
- (modified) clang/test/CIR/CodeGen/ctor-null-init.cpp (+3-3)
- (modified) clang/test/CIR/CodeGen/ctor-try-body.cpp (+1-1)
- (modified) clang/test/CIR/CodeGen/ctor.cpp (+3-3)
- (modified) clang/test/CIR/CodeGen/delegating-ctor.cpp (+1-1)
- (modified) clang/test/CIR/CodeGen/derived-to-base.cpp (+5-5)
- (modified) clang/test/CIR/CodeGen/dtors.cpp (+2-2)
- (modified) clang/test/CIR/CodeGen/inherited-ctors.cpp (+4-4)
- (modified) clang/test/CIR/CodeGen/multi-vtable.cpp (+3-3)
- (modified) clang/test/CIR/CodeGen/paren-list-agg-init.cpp (+2-2)
- (modified) clang/test/CIR/CodeGen/vbase.cpp (+2-2)
- (modified) clang/test/CIR/CodeGen/virtual-destructor-calls.cpp (+1-1)
- (modified) clang/test/CIR/CodeGen/vtt.cpp (+8-8)
- (modified) clang/test/CIR/IR/vtt-addrpoint.cir (+3-3)
- (modified) clang/test/CIR/Lowering/vtt-addrpoint.cir (+3-3)
- (modified) clang/test/CIR/Transforms/pure-ptr-arithmetic.cir (+2-2)
``````````diff
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 97d623ba5e6d9..6b69353d29ad9 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -5317,10 +5317,27 @@ def CIR_VecSplatOp : CIR_Op<"vec.splat", [
}
//===----------------------------------------------------------------------===//
-// BaseClassAddrOp
+// BaseClassAddrOp & DerivedClassAddrOp
//===----------------------------------------------------------------------===//
-def CIR_BaseClassAddrOp : CIR_Op<"base_class_addr", [Pure]> {
+class CIR_ClassCastOp<string mnemonic> : CIR_Op<mnemonic, [Pure]> {
+ let arguments = (ins
+ CIR_PointerType:$src_addr,
+ IndexAttr:$offset,
+ UnitAttr:$assume_not_null
+ );
+
+ let results = (outs Res<CIR_PointerType, "">:$result);
+
+ let assemblyFormat = [{
+ (`nonnull` $assume_not_null^)?
+ $src_addr ` ` `[` $offset `]`
+ `:` qualified(type($src_addr)) `->` qualified(type($result))
+ attr-dict
+ }];
+}
+
+def CIR_BaseClassAddrOp : CIR_ClassCastOp<"base_class_addr"> {
let summary = "Get the base class address for a class/struct";
let description = [{
The `cir.base_class_addr` operaration gets the address of a particular
@@ -5344,28 +5361,12 @@ def CIR_BaseClassAddrOp : CIR_Op<"base_class_addr", [Pure]> {
```
will generate
```
- %3 = cir.base_class_addr %1 : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+ %3 = cir.base_class_addr nonnull %1 [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
```
}];
-
- let arguments = (ins
- CIR_PointerType:$derived_addr,
- IndexAttr:$offset, UnitAttr:$assume_not_null);
-
- let results = (outs Res<CIR_PointerType, "">:$base_addr);
-
- let assemblyFormat = [{
- $derived_addr `:` qualified(type($derived_addr))
- (`nonnull` $assume_not_null^)?
- ` ` `[` $offset `]` `->` qualified(type($base_addr)) attr-dict
- }];
}
-//===----------------------------------------------------------------------===//
-// DerivedClassAddrOp
-//===----------------------------------------------------------------------===//
-
-def CIR_DerivedClassAddrOp : CIR_Op<"derived_class_addr", [Pure]> {
+def CIR_DerivedClassAddrOp : CIR_ClassCastOp<"derived_class_addr"> {
let summary = "Get the derived class address for a class/struct";
let description = [{
The `cir.derived_class_addr` operaration gets the address of a particular
@@ -5394,21 +5395,9 @@ def CIR_DerivedClassAddrOp : CIR_Op<"derived_class_addr", [Pure]> {
leads to
```
%2 = cir.load %0 : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
- %3 = cir.base_class_addr %2 : !cir.ptr<!rec_B> [0] -> !cir.ptr<!rec_A>
+ %3 = cir.derived_class_addr %2 [0] : !cir.ptr<!rec_A> -> !cir.ptr<!rec_B>
```
}];
-
- let arguments = (ins
- CIR_PointerType:$base_addr,
- IndexAttr:$offset, UnitAttr:$assume_not_null);
-
- let results = (outs Res<CIR_PointerType, "">:$derived_addr);
-
- let assemblyFormat = [{
- $base_addr `:` qualified(type($base_addr))
- (`nonnull` $assume_not_null^)?
- ` ` `[` $offset `]` `->` qualified(type($derived_addr)) attr-dict
- }];
}
//===----------------------------------------------------------------------===//
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
index e17c7a209db6b..128616cac7554 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -1572,29 +1572,29 @@ mlir::LogicalResult CIRToLLVMBaseClassAddrOpLowering::matchAndRewrite(
mlir::ConversionPatternRewriter &rewriter) const {
const mlir::Type resultType =
getTypeConverter()->convertType(baseClassOp.getType());
- mlir::Value derivedAddr = adaptor.getDerivedAddr();
+ mlir::Value srcAddr = adaptor.getSrcAddr();
llvm::SmallVector<mlir::LLVM::GEPArg, 1> offset = {
adaptor.getOffset().getZExtValue()};
mlir::Type byteType = mlir::IntegerType::get(resultType.getContext(), 8,
mlir::IntegerType::Signless);
if (adaptor.getOffset().getZExtValue() == 0) {
- rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(
- baseClassOp, resultType, adaptor.getDerivedAddr());
+ rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(baseClassOp, resultType,
+ adaptor.getSrcAddr());
return mlir::success();
}
if (baseClassOp.getAssumeNotNull()) {
- rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(
- baseClassOp, resultType, byteType, derivedAddr, offset);
+ rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(baseClassOp, resultType,
+ byteType, srcAddr, offset);
} else {
auto loc = baseClassOp.getLoc();
mlir::Value isNull = mlir::LLVM::ICmpOp::create(
- rewriter, loc, mlir::LLVM::ICmpPredicate::eq, derivedAddr,
- mlir::LLVM::ZeroOp::create(rewriter, loc, derivedAddr.getType()));
- mlir::Value adjusted = mlir::LLVM::GEPOp::create(
- rewriter, loc, resultType, byteType, derivedAddr, offset);
+ rewriter, loc, mlir::LLVM::ICmpPredicate::eq, srcAddr,
+ mlir::LLVM::ZeroOp::create(rewriter, loc, srcAddr.getType()));
+ mlir::Value adjusted = mlir::LLVM::GEPOp::create(rewriter, loc, resultType,
+ byteType, srcAddr, offset);
rewriter.replaceOpWithNewOp<mlir::LLVM::SelectOp>(baseClassOp, isNull,
- derivedAddr, adjusted);
+ srcAddr, adjusted);
}
return mlir::success();
}
@@ -1604,13 +1604,13 @@ mlir::LogicalResult CIRToLLVMDerivedClassAddrOpLowering::matchAndRewrite(
mlir::ConversionPatternRewriter &rewriter) const {
const mlir::Type resultType =
getTypeConverter()->convertType(derivedClassOp.getType());
- mlir::Value baseAddr = adaptor.getBaseAddr();
+ mlir::Value srcAddr = adaptor.getSrcAddr();
// The offset is set in the operation as an unsigned value, but it must be
// applied as a negative offset.
int64_t offsetVal = -(adaptor.getOffset().getZExtValue());
if (offsetVal == 0) {
- // If the offset is zero, we can just return the base address,
- rewriter.replaceOp(derivedClassOp, baseAddr);
+ // If the offset is zero, we can just return the source address.
+ rewriter.replaceOp(derivedClassOp, srcAddr);
return mlir::success();
}
llvm::SmallVector<mlir::LLVM::GEPArg, 1> offset = {offsetVal};
@@ -1618,18 +1618,18 @@ mlir::LogicalResult CIRToLLVMDerivedClassAddrOpLowering::matchAndRewrite(
mlir::IntegerType::Signless);
if (derivedClassOp.getAssumeNotNull()) {
rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(
- derivedClassOp, resultType, byteType, baseAddr, offset,
+ derivedClassOp, resultType, byteType, srcAddr, offset,
mlir::LLVM::GEPNoWrapFlags::inbounds);
} else {
mlir::Location loc = derivedClassOp.getLoc();
mlir::Value isNull = mlir::LLVM::ICmpOp::create(
- rewriter, loc, mlir::LLVM::ICmpPredicate::eq, baseAddr,
- mlir::LLVM::ZeroOp::create(rewriter, loc, baseAddr.getType()));
+ rewriter, loc, mlir::LLVM::ICmpPredicate::eq, srcAddr,
+ mlir::LLVM::ZeroOp::create(rewriter, loc, srcAddr.getType()));
mlir::Value adjusted =
- mlir::LLVM::GEPOp::create(rewriter, loc, resultType, byteType, baseAddr,
+ mlir::LLVM::GEPOp::create(rewriter, loc, resultType, byteType, srcAddr,
offset, mlir::LLVM::GEPNoWrapFlags::inbounds);
rewriter.replaceOpWithNewOp<mlir::LLVM::SelectOp>(derivedClassOp, isNull,
- baseAddr, adjusted);
+ srcAddr, adjusted);
}
return mlir::success();
}
diff --git a/clang/test/CIR/CodeGen/base-init-eh.cpp b/clang/test/CIR/CodeGen/base-init-eh.cpp
index 063a4d1dca977..7c5609492c35d 100644
--- a/clang/test/CIR/CodeGen/base-init-eh.cpp
+++ b/clang/test/CIR/CodeGen/base-init-eh.cpp
@@ -24,7 +24,7 @@ void test_base_initializer() {
// CIR: cir.func {{.*}} @_ZN7DerivedC2Ev
// CIR: %[[THIS:.*]] = cir.load %{{.*}}
-// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr nonnull %[[THIS]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.call @_ZN4BaseC2Ei(%[[BASE_ADDR]], %[[ZERO]])
// CIR: cir.cleanup.scope {
@@ -65,7 +65,7 @@ void test_virt_base_initializer() {
// CIR: cir.func {{.*}} @_ZN11VirtDerivedC1Ev
// CIR: %[[THIS:.*]] = cir.load %{{.*}}
-// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_VirtDerived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr nonnull %[[THIS]] [0] : !cir.ptr<!rec_VirtDerived> -> !cir.ptr<!rec_Base>
// CIR: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR: cir.call @_ZN4BaseC2Ei(%[[BASE_ADDR]], %[[ZERO]])
// CIR: cir.cleanup.scope {
diff --git a/clang/test/CIR/CodeGen/base-to-derived.cpp b/clang/test/CIR/CodeGen/base-to-derived.cpp
index 147b0b897e674..92e51a8d36bba 100644
--- a/clang/test/CIR/CodeGen/base-to-derived.cpp
+++ b/clang/test/CIR/CodeGen/base-to-derived.cpp
@@ -27,7 +27,7 @@ X *castAtoX(A *a) {
// CIR: %[[A_ADDR:.*]] = cir.alloca !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>, ["a", init]
// CIR: cir.store %[[ARG0]], %[[A_ADDR]] : !cir.ptr<!rec_A>, !cir.ptr<!cir.ptr<!rec_A>>
// CIR: %[[A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.ptr<!rec_A>>, !cir.ptr<!rec_A>
-// CIR: %[[X:.*]] = cir.derived_class_addr %[[A]] : !cir.ptr<!rec_A> [0] -> !cir.ptr<!rec_X>
+// CIR: %[[X:.*]] = cir.derived_class_addr %[[A]] [0] : !cir.ptr<!rec_A> -> !cir.ptr<!rec_X>
// Note: Because the offset is 0, a null check is not needed.
@@ -49,7 +49,7 @@ X *castBtoX(B *b) {
// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["b", init]
// CIR: cir.store %[[ARG0]], %[[B_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
-// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] : !cir.ptr<!rec_B> [4] -> !cir.ptr<!rec_X>
+// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] [4] : !cir.ptr<!rec_B> -> !cir.ptr<!rec_X>
// LLVM: define {{.*}} ptr @_Z8castBtoXP1B(ptr {{.*}} %[[ARG0:.*]])
// LLVM: %[[B_ADDR:.*]] = alloca ptr, i64 1, align 8
@@ -82,7 +82,7 @@ X &castBReftoXRef(B &b) {
// CIR: %[[B_ADDR:.*]] = cir.alloca !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>, ["b", init, const]
// CIR: cir.store %[[ARG0]], %[[B_ADDR]] : !cir.ptr<!rec_B>, !cir.ptr<!cir.ptr<!rec_B>>
// CIR: %[[B:.*]] = cir.load{{.*}} %[[B_ADDR]] : !cir.ptr<!cir.ptr<!rec_B>>, !cir.ptr<!rec_B>
-// CIR: %[[X:.*]] = cir.derived_class_addr %[[B]] : !cir.ptr<!rec_B> nonnull [4] -> !cir.ptr<!rec_X>
+// CIR: %[[X:.*]] = cir.derived_class_addr nonnull %[[B]] [4] : !cir.ptr<!rec_B> -> !cir.ptr<!rec_X>
// LLVM: define {{.*}} ptr @_Z14castBReftoXRefR1B(ptr {{.*}} %[[ARG0:.*]])
// LLVM: %[[B_ADDR:.*]] = alloca ptr
diff --git a/clang/test/CIR/CodeGen/class.cpp b/clang/test/CIR/CodeGen/class.cpp
index 243eb746ade52..ef51cd36b7176 100644
--- a/clang/test/CIR/CodeGen/class.cpp
+++ b/clang/test/CIR/CodeGen/class.cpp
@@ -71,7 +71,7 @@ int use_base() {
// CIR: cir.func{{.*}} @_Z8use_basev
// CIR: %[[D_ADDR:.*]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["d"]
-// CIR: %[[BASE_ADDR:.*]] cir.base_class_addr %[[D_ADDR]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[BASE_ADDR:.*]] cir.base_class_addr nonnull %[[D_ADDR]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CIR: %[[D_A_ADDR:.*]] = cir.get_member %2[0] {name = "a"} : !cir.ptr<!rec_Base> -> !cir.ptr<!s32i>
// CIR: %[[D_A:.*]] = cir.load align(4) %3 : !cir.ptr<!s32i>, !s32i
@@ -91,7 +91,7 @@ int use_base_via_pointer(Derived *d) {
// CIR: %[[D_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["d", init]
// CIR: cir.store %[[ARG0]], %[[D_ADDR]]
// CIR: %[[D:.*]] = cir.load align(8) %[[D_ADDR]]
-// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[D]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[BASE_ADDR:.*]] = cir.base_class_addr nonnull %[[D]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CIR: %[[D_A_ADDR:.*]] = cir.get_member %[[BASE_ADDR]][0] {name = "a"}
// CIR: %[[D_A:.*]] = cir.load align(4) %[[D_A_ADDR]]
diff --git a/clang/test/CIR/CodeGen/ctor-null-init.cpp b/clang/test/CIR/CodeGen/ctor-null-init.cpp
index 6f31a46305ae8..0aacc99b9364e 100644
--- a/clang/test/CIR/CodeGen/ctor-null-init.cpp
+++ b/clang/test/CIR/CodeGen/ctor-null-init.cpp
@@ -19,7 +19,7 @@ void test_empty_base_null_init() {
// CIR: cir.func {{.*}} @_Z25test_empty_base_null_initv()
// CIR-NEXT: %[[B_ADDR:.*]] = cir.alloca !rec_B, !cir.ptr<!rec_B>, ["agg.tmp.ensured"]
-// CIR-NEXT: %[[A_ADDR:.*]] = cir.base_class_addr %[[B_ADDR]] : !cir.ptr<!rec_B> nonnull [0] -> !cir.ptr<!rec_A>
+// CIR-NEXT: %[[A_ADDR:.*]] = cir.base_class_addr nonnull %[[B_ADDR]] [0] : !cir.ptr<!rec_B> -> !cir.ptr<!rec_A>
// LLVM: define{{.*}} @_Z25test_empty_base_null_initv()
// LLVM-NEXT: %[[B:.*]] = alloca %struct.B
@@ -46,7 +46,7 @@ void test_non_empty_base_null_init() {
// CIR: cir.func {{.*}} @_Z29test_non_empty_base_null_initv()
// CIR: %[[TMP:.*]] = cir.alloca !rec_D, !cir.ptr<!rec_D>, ["agg.tmp.ensured"]
-// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TMP]] : !cir.ptr<!rec_D> nonnull [0] -> !cir.ptr<!rec_C>
+// CIR: %[[BASE:.*]] = cir.base_class_addr nonnull %[[TMP]] [0] : !cir.ptr<!rec_D> -> !cir.ptr<!rec_C>
// CIR: %[[ZERO:.*]] = cir.const #cir.const_record<{#cir.int<0> : !s32i}> : !rec_C
// CIR: cir.store{{.*}} %[[ZERO]], %[[BASE]]
@@ -77,7 +77,7 @@ void test_base_chain_null_init() {
// CIR: cir.func {{.*}} @_Z25test_base_chain_null_initv()
// CIR: %[[TMP:.*]] = cir.alloca !rec_G, !cir.ptr<!rec_G>, ["agg.tmp.ensured"]
-// CIR: %[[BASE:.*]] = cir.base_class_addr %[[TMP]] : !cir.ptr<!rec_G> nonnull [0] -> !cir.ptr<!rec_F>
+// CIR: %[[BASE:.*]] = cir.base_class_addr nonnull %[[TMP]] [0] : !cir.ptr<!rec_G> -> !cir.ptr<!rec_F>
// CIR: %[[ZERO:.*]] = cir.const #cir.const_record<{#cir.zero : !rec_E}> : !rec_F
// CIR: cir.store{{.*}} %[[ZERO]], %[[BASE]]
diff --git a/clang/test/CIR/CodeGen/ctor-try-body.cpp b/clang/test/CIR/CodeGen/ctor-try-body.cpp
index 567fe9d7c77ac..d843ad551db6d 100644
--- a/clang/test/CIR/CodeGen/ctor-try-body.cpp
+++ b/clang/test/CIR/CodeGen/ctor-try-body.cpp
@@ -38,7 +38,7 @@ struct HasThings : Base {
// CIR-NEXT: %[[THIS_LOAD:.*]] = cir.load %[[THIS_ALLOC]] : !cir.ptr<!cir.ptr<!rec_HasThings>>, !cir.ptr<!rec_HasThings>
// CIR-NEXT: cir.scope {
// CIR-NEXT: cir.try {
-// CIR-NEXT: %[[BASE_ADDR:.*]] = cir.base_class_addr %[[THIS_LOAD]] : !cir.ptr<!rec_HasThings> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR-NEXT: %[[BASE_ADDR:.*]] = cir.base_class_addr nonnull %[[THIS_LOAD]] [0] : !cir.ptr<!rec_HasThings> -> !cir.ptr<!rec_Base>
// CIR-NEXT: cir.call @_ZN4BaseC2Ev(%[[BASE_ADDR]]) : (!cir.ptr<!rec_Base>{{.*}}) -> ()
// CIR-NEXT: %[[FROMCTOR_ADDR:.*]] = cir.cast bitcast %[[THIS_LOAD]] : !cir.ptr<!rec_HasThings> -> !cir.ptr<!rec_FromCtor>
// CIR-NEXT: %[[C_LOAD:.*]] = cir.load %[[C_ALLOC]] : !cir.ptr<!cir.ptr<!rec_Ctor>>, !cir.ptr<!rec_Ctor>
diff --git a/clang/test/CIR/CodeGen/ctor.cpp b/clang/test/CIR/CodeGen/ctor.cpp
index 3df31b71b34c0..19fff5f5eaecc 100644
--- a/clang/test/CIR/CodeGen/ctor.cpp
+++ b/clang/test/CIR/CodeGen/ctor.cpp
@@ -250,7 +250,7 @@ void test_derived() {
// CHECK-NEXT: cir.store %arg0, %[[THIS_ADDR]]
// CHECK-NEXT: cir.store %arg1, %[[VAL_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
-// CHECK-NEXT: %[[BASE:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CHECK-NEXT: %[[BASE:.*]] = cir.base_class_addr nonnull %[[THIS]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CHECK-NEXT: %[[VAL:.*]] = cir.load{{.*}} %[[VAL_ADDR]]
// CHECK-NEXT: cir.call @_ZN4BaseC2Ei(%[[BASE]], %[[VAL]])
// CHECK-NEXT: cir.return
@@ -309,10 +309,10 @@ void test_derived2() {
// CHECK-NEXT: cir.store %arg2, %[[VAL2_ADDR]]
// CHECK-NEXT: cir.store %arg3, %[[VAL3_ADDR]]
// CHECK-NEXT: %[[THIS:.*]] = cir.load{{.*}} %[[THIS_ADDR]]
-// CHECK-NEXT: %[[BASE:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Derived2> nonnull [0] -> !cir.ptr<!rec_Base>
+// CHECK-NEXT: %[[BASE:.*]] = cir.base_class_addr nonnull %[[THIS]] [0] : !cir.ptr<!rec_Derived2> -> !cir.ptr<!rec_Base>
// CHECK-NEXT: %[[VAL1:.*]] = cir.load{{.*}} %[[VAL1_ADDR]]
// CHECK-NEXT: cir.call @_ZN4BaseC2Ei(%[[BASE]], %[[VAL1]])
-// CHECK-NEXT: %[[BASE2:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Derived2> nonnull [4] -> !cir.ptr<!rec_Base2>
+// CHECK-NEXT: %[[BASE2:.*]] = cir.base_class_addr nonnull %[[THIS]] [4] : !cir.ptr<!rec_Derived2> -> !cir.ptr<!rec_Base2>
// CHECK-NEXT: %[[VAL2:.*]] = cir.load{{.*}} %[[VAL2_ADDR]]
// CHECK-NEXT: cir.call @_ZN5Base2C2Ei(%[[BASE2]], %[[VAL2]])
// CHECK-NEXT: %[[C_ADDR:.*]] = cir.get_member %[[THIS]][2] {name = "c"}
diff --git a/clang/test/CIR/CodeGen/delegating-ctor.cpp b/clang/test/CIR/CodeGen/delegating-ctor.cpp
index 7c2f5be118c35..ab3d02dde2a68 100644
--- a/clang/test/CIR/CodeGen/delegating-ctor.cpp
+++ b/clang/test/CIR/CodeGen/delegating-ctor.cpp
@@ -257,7 +257,7 @@ Derived::Derived(const void *inVoid) { squawk(); }
// CIR: cir.store %[[THIS_ARG]], %[[THIS_ADDR]]
// CIR: cir.store %[[INVOID_ARG]], %[[INVOID_ADDR]]
// CIR: %[[THIS:.*]] = cir.load %[[THIS_ADDR]]
-// CIR: %[[BASE:.*]] = cir.base_class_addr %[[THIS]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[BASE:.*]] = cir.base_class_addr nonnull %[[THIS]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CIR: cir.call @_ZN4BaseC2Ev(%[[BASE]])
// CIR: %[[VPTR_GLOBAL:.*]] = cir.vtable.address_point(@_ZTV7Derived, address_point = <index = 0, offset = 4>) : !cir.vptr
// CIR: %[[VPTR_ADDR:.*]] = cir.vtable.get_vptr %[[THIS]] : !cir.ptr<!rec_Derived> -> !cir.ptr<!cir.vptr>
diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp
index a5b9cb7313e00..7deb00ab761e7 100644
--- a/clang/test/CIR/CodeGen/derived-to-base.cpp
+++ b/clang/test/CIR/CodeGen/derived-to-base.cpp
@@ -28,7 +28,7 @@ void f() {
// CIR: cir.func {{.*}} @_Z1fv()
// CIR: %[[D:.*]] = cir.alloca !rec_Derived, !cir.ptr<!rec_Derived>, ["d", init]
// CIR: cir.call @_ZN7DerivedC1Ev(%[[D]]) : (!cir.ptr<!rec_Derived> {{.*}}) -> ()
-// CIR: %[[D_BASE:.*]] = cir.base_class_addr %[[D]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[D_BASE:.*]] = cir.base_class_addr nonnull %[[D]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CIR: cir.call @_ZN4Base1fEv(%[[D_BASE]]) : (!cir.ptr<!rec_Base> {{.*}}) -> ()
// LLVM: define {{.*}}void @_Z1fv()
@@ -51,7 +51,7 @@ void callBaseUsingDerived(Derived *derived) {
// CIR: %[[DERIVED_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Derived>, !cir.ptr<!cir.ptr<!rec_Derived>>, ["derived", init]
// CIR: cir.store %[[DERIVED_ARG]], %[[DERIVED_ADDR]]
// CIR: %[[DERIVED:.*]] = cir.load{{.*}} %[[DERIVED_ADDR]]
-// CIR: %[[DERIVED_BASE:.*]] = cir.base_class_addr %[[DERIVED]] : !cir.ptr<!rec_Derived> nonnull [0] -> !cir.ptr<!rec_Base>
+// CIR: %[[DERIVED_BASE:.*]] = cir.base_class_addr nonnull %[[DERIVED]] [0] : !cir.ptr<!rec_Derived> -> !cir.ptr<!rec_Base>
// CIR: cir.call @_Z7useBaseP4Base(%[[DERIVED_BASE]]) : (!cir.ptr<!rec_Base> {{.*}}) -> ()
// LLVM: define {{.*}} void @_Z20callBaseUsingDerivedP7Derived(ptr {{.*}} %[[DERIVED_ARG:.*]])
@@ -75,7 +75,7 @@ Base *returnBaseFromDerived(Derived* derived) {
// CIR: %[[BASE_ADDR:.*]] = cir.alloca !cir.ptr<!rec_Base>, !cir.ptr<!cir.ptr<!rec_Base>>, ["__retval"]
// CIR: cir.store %[[DERIVED_ARG]], %[[DERIVED_AD...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/195478
More information about the cfe-commits
mailing list