[clang][bytecode] Support partial initializers for CXXNewExprs #126494
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
For `new A[N]{1,2,3}`, we need to allocate N elements of type A,
and initialize the first three with the given InitListExpr elements.
However, if N is larger than 3, we need to initialize the remaining
elements with the InitListExpr array filler.
Similarly, for `new A[N];`, we need to initilize all fields with the
constructor of A. The initializer type is a CXXConstructExpr of
IncompleteArrayType in this case, which we can't generally handle.
llvmbot
added
clang
|
@llvm/pr-subscribers-clang Author: Timm Baeder (tbaederr) ChangesFor Similarly, for Full diff: https://github.com/llvm/llvm-project/pull/126494.diff 3 Files Affected:
diff --git a/clang/lib/AST/ByteCode/Compiler.cpp b/clang/lib/AST/ByteCode/Compiler.cpp
index 1f0e022edcd7687..86a3773d74d05c5 100644
--- a/clang/lib/AST/ByteCode/Compiler.cpp
+++ b/clang/lib/AST/ByteCode/Compiler.cpp
@@ -3370,15 +3370,23 @@ bool Compiler<Emitter>::VisitCXXNewExpr(const CXXNewExpr *E) {
PrimType SizeT = classifyPrim(Stripped->getType());
+ // Save evaluated array size to a variable.
+ unsigned ArrayLen = allocateLocalPrimitive(
+ Stripped, SizeT, /*IsConst=*/false, /*IsExtended=*/false);
+ if (!this->visit(Stripped))
+ return false;
+ if (!this->emitSetLocal(SizeT, ArrayLen, E))
+ return false;
+
if (PlacementDest) {
if (!this->visit(PlacementDest))
return false;
- if (!this->visit(Stripped))
+ if (!this->emitGetLocal(SizeT, ArrayLen, E))
return false;
if (!this->emitCheckNewTypeMismatchArray(SizeT, E, E))
return false;
} else {
- if (!this->visit(Stripped))
+ if (!this->emitGetLocal(SizeT, ArrayLen, E))
return false;
if (ElemT) {
@@ -3392,10 +3400,113 @@ bool Compiler<Emitter>::VisitCXXNewExpr(const CXXNewExpr *E) {
}
}
- if (Init && !this->visitInitializer(Init))
- return false;
+ if (Init) {
+ QualType InitType = Init->getType();
+ size_t StaticInitElems = 0;
+ const Expr *DynamicInit = nullptr;
+ if (const ConstantArrayType *CAT =
+ Ctx.getASTContext().getAsConstantArrayType(InitType)) {
+ StaticInitElems = CAT->getZExtSize();
+ if (!this->visitInitializer(Init))
+ return false;
- } else {
+ if (const auto *ILE = dyn_cast<InitListExpr>(Init);
+ ILE && ILE->hasArrayFiller())
+ DynamicInit = ILE->getArrayFiller();
+ }
+
+ // The initializer initializes a certain number of elements, S.
+ // However, the complete number of elements, N, might be larger than that.
+ // In this case, we need to get an initializer for the remaining elements.
+ // There are to cases:
+ // 1) For the form 'new Struct[n];', the initializer is a
+ // CXXConstructExpr and its type is an IncompleteArrayType.
+ // 2) For the form 'new Struct[n]{1,2,3}', the initializer is an
+ // InitListExpr and the initializer for the remaining elements
+ // is the array filler.
+
+ if (DynamicInit || InitType->isIncompleteArrayType()) {
+ const Function *CtorFunc = nullptr;
+ if (const auto *CE = dyn_cast<CXXConstructExpr>(Init)) {
+ CtorFunc = getFunction(CE->getConstructor());
+ if (!CtorFunc)
+ return false;
+ }
+
+ LabelTy EndLabel = this->getLabel();
+ LabelTy StartLabel = this->getLabel();
+
+ // In the nothrow case, the alloc above might have returned nullptr.
+ // Don't call any constructors that case.
+ if (IsNoThrow) {
+ if (!this->emitDupPtr(E))
+ return false;
+ if (!this->emitNullPtr(0, nullptr, E))
+ return false;
+ if (!this->emitEQPtr(E))
+ return false;
+ if (!this->jumpTrue(EndLabel))
+ return false;
+ }
+
+ // Create loop variables.
+ unsigned Iter = allocateLocalPrimitive(
+ Stripped, SizeT, /*IsConst=*/false, /*IsExtended=*/false);
+ if (!this->emitConst(StaticInitElems, SizeT, E))
+ return false;
+ if (!this->emitSetLocal(SizeT, Iter, E))
+ return false;
+
+ this->fallthrough(StartLabel);
+ this->emitLabel(StartLabel);
+ // Condition. Iter < ArrayLen?
+ if (!this->emitGetLocal(SizeT, Iter, E))
+ return false;
+ if (!this->emitGetLocal(SizeT, ArrayLen, E))
+ return false;
+ if (!this->emitLT(SizeT, E))
+ return false;
+ if (!this->jumpFalse(EndLabel))
+ return false;
+
+ // Pointer to the allocated array is already on the stack.
+ if (!this->emitGetLocal(SizeT, Iter, E))
+ return false;
+ if (!this->emitArrayElemPtr(SizeT, E))
+ return false;
+
+ if (DynamicInit) {
+ if (std::optional<PrimType> InitT = classify(DynamicInit)) {
+ if (!this->visit(DynamicInit))
+ return false;
+ if (!this->emitStorePop(*InitT, E))
+ return false;
+ } else {
+ if (!this->visitInitializer(DynamicInit))
+ return false;
+ if (!this->emitPopPtr(E))
+ return false;
+ }
+ } else {
+ assert(CtorFunc);
+ if (!this->emitCall(CtorFunc, 0, E))
+ return false;
+ }
+
+ // ++Iter;
+ if (!this->emitGetPtrLocal(Iter, E))
+ return false;
+ if (!this->emitIncPop(SizeT, E))
+ return false;
+
+ if (!this->jump(StartLabel))
+ return false;
+
+ this->fallthrough(EndLabel);
+ this->emitLabel(EndLabel);
+ }
+ }
+ } else { // Non-array.
if (PlacementDest) {
if (!this->visit(PlacementDest))
return false;
diff --git a/clang/lib/AST/ByteCode/Interp.h b/clang/lib/AST/ByteCode/Interp.h
index 66fd31feb24f4ed..5cc371c7ee49507 100644
--- a/clang/lib/AST/ByteCode/Interp.h
+++ b/clang/lib/AST/ByteCode/Interp.h
@@ -1484,7 +1484,10 @@ bool InitThisBitField(InterpState &S, CodePtr OpPC, const Record::Field *F,
template <PrimType Name, class T = typename PrimConv<Name>::T>
bool InitField(InterpState &S, CodePtr OpPC, uint32_t I) {
const T &Value = S.Stk.pop<T>();
- const Pointer &Field = S.Stk.peek<Pointer>().atField(I);
+ const Pointer &Ptr = S.Stk.peek<Pointer>();
+ if (!CheckRange(S, OpPC, Ptr, CSK_Field))
+ return false;
+ const Pointer &Field = Ptr.atField(I);
Field.deref<T>() = Value;
Field.activate();
Field.initialize();
diff --git a/clang/test/AST/ByteCode/new-delete.cpp b/clang/test/AST/ByteCode/new-delete.cpp
index a8f073aa03fc101..e60ff894c9715ae 100644
--- a/clang/test/AST/ByteCode/new-delete.cpp
+++ b/clang/test/AST/ByteCode/new-delete.cpp
@@ -268,11 +268,10 @@ namespace NowThrowNew {
delete[] p;
return result;
}
- /// This needs support for CXXConstrucExprs with non-constant array sizes.
- static_assert(erroneous_array_bound_nothrow2(3)); // expected-error {{not an integral constant expression}}
- static_assert(erroneous_array_bound_nothrow2(0));// expected-error {{not an integral constant expression}}
- static_assert(erroneous_array_bound_nothrow2(-1) == 0);// expected-error {{not an integral constant expression}}
- static_assert(!erroneous_array_bound_nothrow2(1LL << 62));// expected-error {{not an integral constant expression}}
+ static_assert(erroneous_array_bound_nothrow2(3));
+ static_assert(erroneous_array_bound_nothrow2(0));
+ static_assert(erroneous_array_bound_nothrow2(-1) == 0);
+ static_assert(!erroneous_array_bound_nothrow2(1LL << 62));
constexpr bool erroneous_array_bound(long long n) {
delete[] new int[n]; // both-note {{array bound -1 is negative}} both-note {{array bound 4611686018427387904 is too large}}
@@ -857,6 +856,54 @@ struct SS {
};
constexpr unsigned short ssmall = SS<unsigned short>(100)[42];
+
+
+namespace IncompleteArray {
+ struct A {
+ int b = 10;
+ };
+ constexpr int test1() {
+ int n = 5;
+ int* a = new int[n];
+ int c = a[0]; // both-note {{read of uninitialized object}}
+ delete[] a;
+ return c;
+ }
+ static_assert(test1() == 10); // both-error {{not an integral constant expression}} \
+ // both-note {{in call to}}
+
+ constexpr int test2() {
+ int n = 0;
+ int* a = new int[n];
+ delete[] a;
+ return 10;
+ }
+ static_assert(test2() == 10);
+
+ /// In this case, the type of the initializer is A[2], while the full size of the
+ /// allocated array is of course 5. The remaining 3 elements need to be initialized
+ /// using A's constructor.
+ constexpr int test3() {
+ int n = 3;
+ A* a = new A[n]{5, 1};
+ int c = a[0].b + a[1].b + a[2].b;
+ delete[] a;
+ return c;
+ }
+ static_assert(test3() == (5 + 1 + 10));
+
+ constexpr int test4() {
+ auto n = 3;
+ int *a = new int[n]{12};
+ int c = a[0] + a[1];
+ delete[] a;
+ return c;
+ }
+ static_assert(test4() == 12);
+
+
+}
+
#else
/// Make sure we reject this prior to C++20
constexpr int a() { // both-error {{never produces a constant expression}}
|
Icohedron
pushed a commit
to Icohedron/llvm-project
that referenced
this pull request
Feb 11, 2025
…126494) For `new A[N]{1,2,3}`, we need to allocate N elements of type A, and initialize the first three with the given InitListExpr elements. However, if N is larger than 3, we need to initialize the remaining elements with the InitListExpr array filler. Similarly, for `new A[N];`, we need to initilize all fields with the constructor of A. The initializer type is a CXXConstructExpr of IncompleteArrayType in this case, which we can't generally handle.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
For
new A[N]{1,2,3}, we need to allocate N elements of type A, and initialize the first three with the given InitListExpr elements. However, if N is larger than 3, we need to initialize the remaining elements with the InitListExpr array filler.Similarly, for
new A[N];, we need to initilize all fields with the constructor of A. The initializer type is a CXXConstructExpr of IncompleteArrayType in this case, which we can't generally handle.