[clang] [CIR] Use the global address space for the VTT parameter (PR #240548)
Arseniy Obolenskiy via cfe-commits
cfe-commits at lists.llvm.org
Tue Nov 10 03:05:02 PST 2026
https://github.com/aobolensk updated https://github.com/llvm/llvm-project/pull/240548
>From 909a7d08cd2f8428fdab07f03dd8a578b39ce45e Mon Sep 17 00:00:00 2001
From: Arseniy Obolenskiy <arseniy.obolenskiy at amd.com>
Date: Mon, 9 Nov 2026 22:14:26 +0100
Subject: [PATCH 1/3] [CIR] Use the global address space for the VTT parameter
Match classic CodeGen, which types the VTT as a pointer into the target global address space
Let cir.vtt.address_point carry that address space
---
clang/include/clang/CIR/Dialect/IR/CIROps.td | 3 ++-
clang/lib/CIR/CodeGen/CIRGenClass.cpp | 4 +++-
clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp | 20 ++++++++++---------
clang/lib/CIR/CodeGen/CIRGenModule.h | 20 +++++++++----------
clang/lib/CIR/Dialect/IR/CIRDialect.cpp | 14 +++++++++++--
5 files changed, 38 insertions(+), 23 deletions(-)
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index 93c91a48bd0c7b..f54be6b69cf327 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -3868,7 +3868,8 @@ def CIR_VTTAddrPointOp : CIR_Op<"vtt.address_point", [
The second parameter `offset` provides a virtual step to adjust to
the actual address point of the vtable.
- The return type is always a `!cir.ptr<!cir.ptr<void>>`.
+ The return type is always a `!cir.ptr<!cir.ptr<void>>`. Either pointer
+ level may carry an address space.
Example:
```
diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
index 4a703262577ad0..fd93328c3c96a4 100644
--- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
@@ -1203,7 +1203,9 @@ mlir::Value CIRGenFunction::getVTTParameter(GlobalDecl gd, bool forVirtualBase,
// We're the complete constructor, so get the VTT by name.
cir::GlobalOp vtt = cgm.getVTables().getAddrOfVTT(rd);
return builder.createVTTAddrPoint(
- loc, builder.getPointerTo(cgm.voidPtrTy),
+ loc,
+ builder.getPointerTo(convertType(getContext().VoidPtrTy),
+ vtt.getAddrSpaceAttr()),
mlir::FlatSymbolRefAttr::get(vtt.getSymNameAttr()), subVTTIndex);
}
}
diff --git a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
index f70e6e7cd2da09..47205b9c64265d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp
@@ -282,14 +282,14 @@ CIRGenItaniumCXXABI::buildStructorSignature(
// All parameters are already in place except VTT, which goes after 'this'.
// These are clang types, so we don't need to worry about sret yet.
- // Check if we need to add a VTT parameter (which has type void **).
+ // Check if we need to add a VTT parameter (which has type global void **).
if ((isa<CXXConstructorDecl>(gd.getDecl()) ? gd.getCtorType() == Ctor_Base
: gd.getDtorType() == Dtor_Base) &&
cast<CXXMethodDecl>(gd.getDecl())->getParent()->getNumVBases() != 0) {
- assert(!cir::MissingFeatures::addressSpace());
+ LangAS as = cgm.getGlobalVarAddressSpace(nullptr);
+ QualType q = astContext.getAddrSpaceQualType(astContext.VoidPtrTy, as);
argTys.insert(argTys.begin() + 1,
- astContext.getPointerType(
- CanQualType::CreateUnsafe(astContext.VoidPtrTy)));
+ astContext.getPointerType(CanQualType::CreateUnsafe(q)));
return AddedStructorArgCounts::withPrefix(1);
}
@@ -418,8 +418,9 @@ void CIRGenItaniumCXXABI::addImplicitStructorParams(CIRGenFunction &cgf,
ASTContext &astContext = cgm.getASTContext();
// FIXME: avoid the fake decl
- assert(!cir::MissingFeatures::addressSpace());
- QualType t = astContext.getPointerType(astContext.VoidPtrTy);
+ LangAS as = cgm.getGlobalVarAddressSpace(nullptr);
+ QualType q = astContext.getAddrSpaceQualType(astContext.VoidPtrTy, as);
+ QualType t = astContext.getPointerType(q);
auto *vttDecl = ImplicitParamDecl::Create(
astContext, /*DC=*/nullptr, md->getLocation(),
&astContext.Idents.get("vtt"), t, ImplicitParamKind::CXXVTT);
@@ -471,9 +472,10 @@ CIRGenCXXABI::AddedStructorArgs CIRGenItaniumCXXABI::getImplicitConstructorArgs(
// some targets.
mlir::Value vtt =
cgf.getVTTParameter(GlobalDecl(d, type), forVirtualBase, delegating);
- QualType vttTy =
- cgm.getASTContext().getPointerType(cgm.getASTContext().VoidPtrTy);
- assert(!cir::MissingFeatures::addressSpace());
+ ASTContext &astContext = cgm.getASTContext();
+ LangAS as = cgm.getGlobalVarAddressSpace(nullptr);
+ QualType q = astContext.getAddrSpaceQualType(astContext.VoidPtrTy, as);
+ QualType vttTy = astContext.getPointerType(q);
return AddedStructorArgs::withPrefix({{vtt, vttTy}});
}
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h
index 7933c3356a4f69..2d606eb977a5a5 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.h
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.h
@@ -524,6 +524,16 @@ class CIRGenModule : public CIRGenTypeCache {
/// space, which may lead to type mismatches in other parts of the IR.
LangAS getLangTempAllocaAddressSpace() const;
+ /// Return the AST address space of the underlying global variable for D, as
+ /// determined by its declaration. Normally this is the same as the address
+ /// space of D's type, but in CUDA, address spaces are associated with
+ /// declarations, not types. If D is nullptr, return the default address
+ /// space for global variable.
+ ///
+ /// For languages without explicit address spaces, if D has default address
+ /// space, target-specific global or constant address space may be returned.
+ LangAS getGlobalVarAddressSpace(const VarDecl *decl);
+
/// Return the CIR address space attribute for a global in \p as, honoring
/// the target address space map where the LangAS fold would lose it.
mlir::ptr::MemorySpaceAttrInterface getGlobalCIRAddressSpace(LangAS as);
@@ -1049,16 +1059,6 @@ class CIRGenModule : public CIRGenTypeCache {
/// Create cir::AnnotationAttr for a single AnnotateAttr on a global.
cir::AnnotationAttr emitAnnotateAttr(const clang::AnnotateAttr *aa);
-
- /// Return the AST address space of the underlying global variable for D, as
- /// determined by its declaration. Normally this is the same as the address
- /// space of D's type, but in CUDA, address spaces are associated with
- /// declarations, not types. If D is nullptr, return the default address
- /// space for global variable.
- ///
- /// For languages without explicit address spaces, if D has default address
- /// space, target-specific global or constant address space may be returned.
- LangAS getGlobalVarAddressSpace(const VarDecl *decl);
};
} // namespace CIRGen
diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
index 35f390afffe8ba..76c7a4ef8828e7 100644
--- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
+++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp
@@ -2855,6 +2855,12 @@ cir::VTTAddrPointOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
if (!op)
return emitOpError("'")
<< name << "' does not reference a valid cir.global";
+ auto resultType = mlir::cast<cir::PointerType>(getAddr().getType());
+ if (op.getAddrSpaceAttr() != resultType.getAddrSpace())
+ return emitOpError()
+ << "result type address space does not match the address "
+ "space of the global @"
+ << name;
std::optional<mlir::Attribute> init = op.getInitialValue();
if (!init)
return success();
@@ -2874,9 +2880,13 @@ LogicalResult cir::VTTAddrPointOp::verify() {
if (getSymAddr())
return success();
- mlir::Type resultType = getAddr().getType();
+ // Both pointer levels may carry an address space.
+ auto resultType = mlir::cast<cir::PointerType>(getAddr().getType());
+ auto eltTy = mlir::dyn_cast<cir::PointerType>(resultType.getPointee());
mlir::Type resTy = cir::PointerType::get(
- cir::PointerType::get(cir::VoidType::get(getContext())));
+ cir::PointerType::get(cir::VoidType::get(getContext()),
+ eltTy ? eltTy.getAddrSpace() : nullptr),
+ resultType.getAddrSpace());
if (resultType != resTy)
return emitOpError("result type must be ")
>From c37c09e418e640dc18e7dbd9ff827bc9ad42313d Mon Sep 17 00:00:00 2001
From: Arseniy Obolenskiy <arseniy.obolenskiy at amd.com>
Date: Mon, 9 Nov 2026 22:36:37 +0100
Subject: [PATCH 2/3] more tests
---
clang/test/CIR/CodeGenCUDA/vtt-addrspace.cu | 49 +++++++++++++++++++++
clang/test/CIR/IR/invalid-vtable.cir | 11 +++++
2 files changed, 60 insertions(+)
create mode 100644 clang/test/CIR/CodeGenCUDA/vtt-addrspace.cu
diff --git a/clang/test/CIR/CodeGenCUDA/vtt-addrspace.cu b/clang/test/CIR/CodeGenCUDA/vtt-addrspace.cu
new file mode 100644
index 00000000000000..7eae03c2e8cb7e
--- /dev/null
+++ b/clang/test/CIR/CodeGenCUDA/vtt-addrspace.cu
@@ -0,0 +1,49 @@
+#include "Inputs/cuda.h"
+
+// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -x cuda -fcuda-is-device \
+// RUN: -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t.cir %s
+// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -x cuda -fcuda-is-device \
+// RUN: -fclangir -emit-llvm %s -o %t-cir.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t-cir.ll %s
+// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -x cuda -fcuda-is-device \
+// RUN: -emit-llvm %s -o %t.ll
+// RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
+
+// RUN: %clang_cc1 -triple amdgpu-amd-amdhsa -x hip -fcuda-is-device \
+// RUN: -fclangir -emit-cir %s -o %t-amdgcn.cir
+// RUN: FileCheck --check-prefix=CIR --input-file=%t-amdgcn.cir %s
+
+// RUN: %clang_cc1 -triple spirv64-amd-amdhsa -x hip -fcuda-is-device \
+// RUN: -fclangir -emit-cir %s -o %t-spirv.cir
+// RUN: FileCheck --check-prefix=CIR-SPV --input-file=%t-spirv.cir %s
+
+// The VTT parameter points into the globals address space. The VTT address
+// point keeps the address space of the VTT global and is cast at the call.
+
+struct A { int a; };
+struct B : virtual A { __device__ B() {} };
+struct C : B { __device__ C() {} };
+
+__device__ void f() { C c; }
+
+// CIR-LABEL: cir.func {{.*}} @_ZN1CC1Ev(
+// CIR: %[[VTT:.*]] = cir.vtt.address_point @_ZTT1C, offset = 1 -> !cir.ptr<!cir.ptr<!void>>
+// CIR: %[[CAST:.*]] = cir.cast address_space %[[VTT]] : !cir.ptr<!cir.ptr<!void>> -> !cir.ptr<!cir.ptr<!void>, target_address_space(1)>
+// CIR: cir.call @_ZN1BC2Ev(%{{.*}}, %[[CAST]])
+
+// CIR-LABEL: cir.func {{.*}} @_ZN1BC2Ev({{.*}}, %arg1: !cir.ptr<!cir.ptr<!void>, target_address_space(1)>
+// CIR: cir.vtt.address_point %{{.*}} : !cir.ptr<!cir.ptr<!void>, target_address_space(1)>, offset = 0 -> !cir.ptr<!cir.ptr<!void>, target_address_space(1)>
+
+// LLVM-LABEL: define {{.*}}void @_ZN1CC1Ev(
+// LLVM: call void @_ZN1BC2Ev(ptr {{.*}}, ptr addrspace(1) noundef addrspacecast (ptr getelementptr inbounds nuw (i8, ptr @_ZTT1C, i64 8) to ptr addrspace(1)))
+
+// LLVM-LABEL: define linkonce_odr void @_ZN1BC2Ev(ptr {{.*}}, ptr addrspace(1) noundef %{{.*}})
+
+// CIR-SPV-LABEL: cir.func {{.*}} @_ZN1CC1Ev(
+// CIR-SPV: %[[VTT:.*]] = cir.vtt.address_point @_ZTT1C, offset = 1 -> !cir.ptr<!cir.ptr<!void, target_address_space(4)>>
+// CIR-SPV: %[[CAST:.*]] = cir.cast address_space %[[VTT]] : !cir.ptr<!cir.ptr<!void, target_address_space(4)>> -> !cir.ptr<!cir.ptr<!void, target_address_space(4)>, target_address_space(1)>
+// CIR-SPV: cir.call @_ZN1BC2Ev(%{{.*}}, %[[CAST]])
+
+// CIR-SPV-LABEL: cir.func {{.*}} @_ZN1BC2Ev({{.*}}, %arg1: !cir.ptr<!cir.ptr<!void, target_address_space(4)>, target_address_space(1)>
+// CIR-SPV: cir.vtt.address_point %{{.*}} : !cir.ptr<!cir.ptr<!void, target_address_space(4)>, target_address_space(1)>, offset = 0 -> !cir.ptr<!cir.ptr<!void, target_address_space(4)>, target_address_space(1)>
diff --git a/clang/test/CIR/IR/invalid-vtable.cir b/clang/test/CIR/IR/invalid-vtable.cir
index f444a0ee5b539d..59b2c4faa22655 100644
--- a/clang/test/CIR/IR/invalid-vtable.cir
+++ b/clang/test/CIR/IR/invalid-vtable.cir
@@ -132,3 +132,14 @@ cir.func @bad_return_type_for_vtt_addrpoint() {
%0 = cir.vtt.address_point @_ZTT1C, offset = 1 -> !cir.ptr<!u8i>
cir.return
}
+
+// -----
+
+!u8i = !cir.int<u, 8>
+!void = !cir.void
+cir.global linkonce_odr @_ZTT1C = #cir.const_array<[#cir.global_view<@_ZTV1C, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>, #cir.global_view<@_ZTC1C0_1B, [0 : i32, 3 : i32]> : !cir.ptr<!u8i>]> : !cir.array<!cir.ptr<!u8i> x 2> align(8)
+cir.func @vtt_addrpoint_addrspace_mismatch() {
+ // expected-error @below {{'cir.vtt.address_point' op result type address space does not match the address space of the global @_ZTT1C}}
+ %0 = cir.vtt.address_point @_ZTT1C, offset = 1 -> !cir.ptr<!cir.ptr<!void>, target_address_space(1)>
+ cir.return
+}
>From 9b512e6279f830a2621d9dc13694bd1660304eb2 Mon Sep 17 00:00:00 2001
From: Arseniy Obolenskiy <arseniy.obolenskiy at amd.com>
Date: Tue, 10 Nov 2026 12:04:46 +0100
Subject: [PATCH 3/3] comment
---
clang/lib/CIR/CodeGen/CIRGenClass.cpp | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
index fd93328c3c96a4..be173f9299e949 100644
--- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenClass.cpp
@@ -1202,11 +1202,11 @@ mlir::Value CIRGenFunction::getVTTParameter(GlobalDecl gd, bool forVirtualBase,
} else {
// We're the complete constructor, so get the VTT by name.
cir::GlobalOp vtt = cgm.getVTables().getAddrOfVTT(rd);
- return builder.createVTTAddrPoint(
- loc,
- builder.getPointerTo(convertType(getContext().VoidPtrTy),
- vtt.getAddrSpaceAttr()),
- mlir::FlatSymbolRefAttr::get(vtt.getSymNameAttr()), subVTTIndex);
+ mlir::Type voidPtrTy = convertType(getContext().VoidPtrTy);
+ cir::PointerType vttTy =
+ builder.getPointerTo(voidPtrTy, vtt.getAddrSpaceAttr());
+ auto vttSym = mlir::FlatSymbolRefAttr::get(vtt.getSymNameAttr());
+ return builder.createVTTAddrPoint(loc, vttTy, vttSym, subVTTIndex);
}
}
More information about the cfe-commits
mailing list