intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-13 19:08:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

[CIR] Upstream reserved placement new handling (#169436)

Browse Source 
This upstreams the code to support reserved placement new calls.
This commit is contained in:
Andy Kaylor
2025-11-25 09:33:27 -08:00
committed by GitHub
parent 8380a48aa0
commit 1441f04585
3 changed files with 67 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
clang/lib/CIR/CodeGen/Address.h
View File

@@ -77,6 +77,12 @@ public:
return Address(newPtr, getElementType(), getAlignment());
}
/// Return address with different alignment, but same pointer and element
/// type.
Address withAlignment(clang::CharUnits newAlignment) const {
return Address(getPointer(), getElementType(), newAlignment);
}
/// Return address with different element type, a bitcast pointer, and
/// the same alignment.
Address withElementType(CIRGenBuilderTy &builder, mlir::Type ElemTy) const;

23
clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp
View File

@@ -806,8 +806,27 @@ mlir::Value CIRGenFunction::emitCXXNewExpr(const CXXNewExpr *e) {
Address allocation = Address::invalid();
CallArgList allocatorArgs;
if (allocator->isReservedGlobalPlacementOperator()) {
cgm.errorNYI(e->getSourceRange(),
"emitCXXNewExpr: reserved global placement operator");
// If the allocator is a global placement operator, just
// "inline" it directly.
assert(e->getNumPlacementArgs() == 1);
const Expr *arg = *e->placement_arguments().begin();
LValueBaseInfo baseInfo;
allocation = emitPointerWithAlignment(arg, &baseInfo);
// The pointer expression will, in many cases, be an opaque void*.
// In these cases, discard the computed alignment and use the
// formal alignment of the allocated type.
if (baseInfo.getAlignmentSource() != AlignmentSource::Decl)
allocation = allocation.withAlignment(allocAlign);
// Set up allocatorArgs for the call to operator delete if it's not
// the reserved global operator.
if (e->getOperatorDelete() &&
!e->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
cgm.errorNYI(e->getSourceRange(),
"emitCXXNewExpr: reserved placement new with delete");
}
} else {
const FunctionProtoType *allocatorType =
allocator->getType()->castAs<FunctionProtoType>();

40
clang/test/CIR/CodeGen/placement-new.cpp Normal file
View File

@@ -0,0 +1,40 @@
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu %s -fclangir -emit-cir -o %t.cir
// RUN: FileCheck --input-file=%t.cir -check-prefix=CIR %s
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu %s -fclangir -emit-llvm -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll -check-prefix=LLVM %s
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-linux-gnu %s -emit-llvm -o %t.ll
// RUN: FileCheck --input-file=%t.ll -check-prefix=OGCG %s
typedef __typeof__(sizeof(0)) size_t;
// Declare the reserved placement operators.
void *operator new(size_t, void*) throw();
struct A { A(); ~A(); };
void test_reserved_placement_new(void *p) {
new (p) A();
}
// CIR-LABEL: cir.func dso_local @_Z27test_reserved_placement_newPv(
// CIR-SAME: %[[ARG0:.*]]: !cir.ptr<!void>
// CIR: %[[P:.*]] = cir.alloca !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>, ["p", init]
// CIR: cir.store %[[ARG0]], %[[P]] : !cir.ptr<!void>, !cir.ptr<!cir.ptr<!void>>
// CIR: %[[SIZE:.*]] = cir.const #cir.int<1> : !u64i
// CIR: %[[PTR:.*]] = cir.load{{.*}} %[[P]] : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
// CIR: %[[PTR_A:.*]] = cir.cast bitcast %[[PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_A>
// CIR: cir.call @_ZN1AC1Ev(%[[PTR_A]]) : (!cir.ptr<!rec_A>) -> ()
// LLVM-LABEL: define dso_local void @_Z27test_reserved_placement_newPv(
// LLVM-SAME: ptr %[[ARG0:.*]]
// LLVM: %[[P:.*]] = alloca ptr
// LLVM: store ptr %[[ARG0:.*]], ptr %[[P]]
// LLVM: %[[PTR:.*]] = load ptr, ptr %[[P]]
// LLVM: call void @_ZN1AC1Ev(ptr %[[PTR]])
// OGCG-LABEL: define dso_local void @_Z27test_reserved_placement_newPv(
// OGCG-SAME: ptr {{.*}} %[[ARG0:.*]]
// OGCG: %[[P:.*]] = alloca ptr
// OGCG: store ptr %[[ARG0:.*]], ptr %[[P]]
// OGCG: %[[PTR:.*]] = load ptr, ptr %[[P]]
// OGCG: call void @_ZN1AC1Ev(ptr {{.*}} %[[PTR]])