Author: serge-sans-paille Date: 2022-05-16T07:50:39+02:00 New Revision: 924acb624f58030652ecc8c07db313fde0f31395
URL: https://github.com/llvm/llvm-project/commit/924acb624f58030652ecc8c07db313fde0f31395 DIFF: https://github.com/llvm/llvm-project/commit/924acb624f58030652ecc8c07db313fde0f31395.diff LOG: [clang] Prevent folding of non-const compound expr When a non-const compound statement is used to initialize a constexpr pointer, the pointed value is not const itself and cannot be folded at codegen time. This matches GCC behavior for compound literal expr arrays. Fix issue #39324. Differential Revision: https://reviews.llvm.org/D124038 Added: Modified: clang/lib/AST/ExprConstant.cpp clang/test/SemaCXX/constant-expression-cxx11.cpp clang/test/SemaTemplate/constexpr-instantiate.cpp Removed: ################################################################################ diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index 650ba305c48b1..519be84a342b3 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -4259,9 +4259,33 @@ handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type, Info.FFDiag(Conv); return false; } + APValue Lit; if (!Evaluate(Lit, Info, CLE->getInitializer())) return false; + + // According to GCC info page: + // + // 6.28 Compound Literals + // + // As an optimization, G++ sometimes gives array compound literals longer + // lifetimes: when the array either appears outside a function or has a + // const-qualified type. If foo and its initializer had elements of type + // char *const rather than char *, or if foo were a global variable, the + // array would have static storage duration. But it is probably safest + // just to avoid the use of array compound literals in C++ code. + // + // Obey that rule by checking constness for converted array types. + + QualType CLETy = CLE->getType(); + if (CLETy->isArrayType() && !Type->isArrayType()) { + if (!CLETy.isConstant(Info.Ctx)) { + Info.FFDiag(Conv); + Info.Note(CLE->getExprLoc(), diag::note_declared_at); + return false; + } + } + CompleteObject LitObj(LVal.Base, &Lit, Base->getType()); return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal, AK); } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) { diff --git a/clang/test/SemaCXX/constant-expression-cxx11.cpp b/clang/test/SemaCXX/constant-expression-cxx11.cpp index 733653af6369c..b03cb7696aae5 100644 --- a/clang/test/SemaCXX/constant-expression-cxx11.cpp +++ b/clang/test/SemaCXX/constant-expression-cxx11.cpp @@ -1596,8 +1596,13 @@ namespace CompoundLiteral { // Matching GCC, file-scope array compound literals initialized by constants // are lifetime-extended. constexpr int *p = (int*)(int[1]){3}; // expected-warning {{C99}} - static_assert(*p == 3, ""); + static_assert(*p == 3, ""); // expected-error {{static_assert expression is not an integral constant expression}} + // expected-note@-1 {{subexpression not valid}} + // expected-note@-3 {{declared here}} static_assert((int[2]){1, 2}[1] == 2, ""); // expected-warning {{C99}} + // expected-error@-1 {{static_assert expression is not an integral constant expression}} + // expected-note@-2 {{subexpression not valid}} + // expected-note@-3 {{declared here}} // Other kinds are not. struct X { int a[2]; }; diff --git a/clang/test/SemaTemplate/constexpr-instantiate.cpp b/clang/test/SemaTemplate/constexpr-instantiate.cpp index 31dbdb617a6ac..0a34f63553aae 100644 --- a/clang/test/SemaTemplate/constexpr-instantiate.cpp +++ b/clang/test/SemaTemplate/constexpr-instantiate.cpp @@ -219,7 +219,9 @@ namespace Unevaluated { static int n; }; template<const int *N> struct B {}; - template<int N> constexpr int A<N>::k = *(int[N]){N}; // expected-error 1+{{negative}} + template <int N> constexpr int A<N>::k = *(int[N]){N}; // expected-error 1+{{negative}} expected-note 1+{{not valid in a constant expression}} expected-note 1+{{declared here}} + // expected-error@-1 1+{{must be initialized by a constant expression}} + template<int N> int A<N>::n = *(int[N]){0}; template <typename> void f() { @@ -230,9 +232,9 @@ namespace Unevaluated { }; decltype(A<-3>::k) d1 = 0; // ok - decltype(char{A<-4>::k}) d2 = 0; // expected-note {{instantiation of }} expected-error {{narrow}} expected-note {{cast}} - decltype(char{A<1>::k}) d3 = 0; // ok - decltype(char{A<1 + (unsigned char)-1>::k}) d4 = 0; // expected-error {{narrow}} expected-note {{cast}} + decltype(char{A<-4>::k}) d2 = 0; // expected-note 1+{{instantiation of }} expected-error {{narrow}} expected-note {{cast}} + decltype(char{A<1>::k}) d3 = 0; // expected-note 1+{{instantiation of }} expected-error {{narrow}} expected-note {{cast}} + decltype(char{A<1 + (unsigned char)-1>::k}) d4 = 0; // expected-error {{narrow}} expected-note {{cast}} expected-note {{instantiation of}} } } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
