https://github.com/shafik created https://github.com/llvm/llvm-project/pull/95474
P2280R4 allows the use of references in pointers of unknown origins in a constant expression context but only in specific cases that could be constant expressions. We track whether a variable is a constexpr unknown in a constant expression by setting a flag in either APValue or LValue and using this flag to prevent using unknown values in places where it is not allowed. Fixes: https://github.com/llvm/llvm-project/issues/63139 https://github.com/llvm/llvm-project/issues/63117 >From 7583d32c023f38cd2b4c6a3fad3bea5e115e9905 Mon Sep 17 00:00:00 2001 From: Shafik Yaghmour <shafik.yaghm...@intel.com> Date: Thu, 13 Jun 2024 14:20:50 -0700 Subject: [PATCH] [Clang] Implement P2280R4 Using unknown pointers and references in constant expressions P2280R4 allows the use of references in pointers of unknown origins in a constant expression context but only in specific cases that could be constant expressions. We track whether a variable is a constexpr unknown in a constant expression by setting a flag in either APValue or LValue and using this flag to prevent using unknown values in places where it is not allowed. Fixes: https://github.com/llvm/llvm-project/issues/63139 https://github.com/llvm/llvm-project/issues/63117 --- clang/include/clang/AST/APValue.h | 48 +++++++---- clang/lib/AST/APValue.cpp | 12 ++- clang/lib/AST/ExprConstant.cpp | 85 +++++++++++++++++-- .../SemaCXX/constant-expression-cxx11.cpp | 16 ++-- .../SemaCXX/constant-expression-cxx2a.cpp | 3 +- .../SemaCXX/constant-expression-p2280r4.cpp | 54 ++++++++++++ 6 files changed, 183 insertions(+), 35 deletions(-) create mode 100644 clang/test/SemaCXX/constant-expression-p2280r4.cpp diff --git a/clang/include/clang/AST/APValue.h b/clang/include/clang/AST/APValue.h index c4206b73b1156..6352348107a64 100644 --- a/clang/include/clang/AST/APValue.h +++ b/clang/include/clang/AST/APValue.h @@ -249,6 +249,7 @@ class APValue { struct NoLValuePath {}; struct UninitArray {}; struct UninitStruct {}; + struct ConstexprUnknown {}; template <typename Impl> friend class clang::serialization::BasicReaderBase; friend class ASTImporter; @@ -256,6 +257,7 @@ class APValue { private: ValueKind Kind; + bool AllowConstexprUnknown = false; struct ComplexAPSInt { APSInt Real, Imag; @@ -314,53 +316,69 @@ class APValue { DataType Data; public: - APValue() : Kind(None) {} - explicit APValue(APSInt I) : Kind(None) { + bool allowConstexprUnknown() const { return AllowConstexprUnknown; } + + void setConstexprUnknown() { AllowConstexprUnknown = true; } + + APValue() : Kind(None), AllowConstexprUnknown(false) {} + explicit APValue(APSInt I) : Kind(None), AllowConstexprUnknown(false) { MakeInt(); setInt(std::move(I)); } - explicit APValue(APFloat F) : Kind(None) { + explicit APValue(APFloat F) : Kind(None), AllowConstexprUnknown(false) { MakeFloat(); setFloat(std::move(F)); } - explicit APValue(APFixedPoint FX) : Kind(None) { + explicit APValue(APFixedPoint FX) : Kind(None), AllowConstexprUnknown(false) { MakeFixedPoint(std::move(FX)); } - explicit APValue(const APValue *E, unsigned N) : Kind(None) { + explicit APValue(const APValue *E, unsigned N) + : Kind(None), AllowConstexprUnknown(false) { MakeVector(); setVector(E, N); } - APValue(APSInt R, APSInt I) : Kind(None) { + APValue(APSInt R, APSInt I) : Kind(None), AllowConstexprUnknown(false) { MakeComplexInt(); setComplexInt(std::move(R), std::move(I)); } - APValue(APFloat R, APFloat I) : Kind(None) { + APValue(APFloat R, APFloat I) : Kind(None), AllowConstexprUnknown(false) { MakeComplexFloat(); setComplexFloat(std::move(R), std::move(I)); } APValue(const APValue &RHS); APValue(APValue &&RHS); APValue(LValueBase B, const CharUnits &O, NoLValuePath N, bool IsNullPtr = false) - : Kind(None) { + : Kind(None), AllowConstexprUnknown(false) { MakeLValue(); setLValue(B, O, N, IsNullPtr); } APValue(LValueBase B, const CharUnits &O, ArrayRef<LValuePathEntry> Path, bool OnePastTheEnd, bool IsNullPtr = false) - : Kind(None) { + : Kind(None), AllowConstexprUnknown(false) { MakeLValue(); setLValue(B, O, Path, OnePastTheEnd, IsNullPtr); } - APValue(UninitArray, unsigned InitElts, unsigned Size) : Kind(None) { + + APValue(LValueBase B, ConstexprUnknown, const CharUnits &O, + bool IsNullPtr = false) + : Kind(None), AllowConstexprUnknown(true) { + MakeLValue(); + setLValue(B, O, NoLValuePath{}, IsNullPtr); + } + + APValue(UninitArray, unsigned InitElts, unsigned Size) + : Kind(None), AllowConstexprUnknown(false) { MakeArray(InitElts, Size); } - APValue(UninitStruct, unsigned B, unsigned M) : Kind(None) { + APValue(UninitStruct, unsigned B, unsigned M) + : Kind(None), AllowConstexprUnknown(false) { MakeStruct(B, M); } explicit APValue(const FieldDecl *D, const APValue &V = APValue()) - : Kind(None) { + : Kind(None), AllowConstexprUnknown(false) { MakeUnion(); setUnion(D, V); } APValue(const ValueDecl *Member, bool IsDerivedMember, - ArrayRef<const CXXRecordDecl*> Path) : Kind(None) { + ArrayRef<const CXXRecordDecl *> Path) + : Kind(None), AllowConstexprUnknown(false) { MakeMemberPointer(Member, IsDerivedMember, Path); } - APValue(const AddrLabelExpr* LHSExpr, const AddrLabelExpr* RHSExpr) - : Kind(None) { + APValue(const AddrLabelExpr *LHSExpr, const AddrLabelExpr *RHSExpr) + : Kind(None), AllowConstexprUnknown(false) { MakeAddrLabelDiff(); setAddrLabelDiff(LHSExpr, RHSExpr); } static APValue IndeterminateValue() { diff --git a/clang/lib/AST/APValue.cpp b/clang/lib/AST/APValue.cpp index d8e33ff421c06..f7841cb6556de 100644 --- a/clang/lib/AST/APValue.cpp +++ b/clang/lib/AST/APValue.cpp @@ -308,7 +308,8 @@ APValue::UnionData::~UnionData () { delete Value; } -APValue::APValue(const APValue &RHS) : Kind(None) { +APValue::APValue(const APValue &RHS) + : Kind(None), AllowConstexprUnknown(RHS.AllowConstexprUnknown) { switch (RHS.getKind()) { case None: case Indeterminate: @@ -379,13 +380,17 @@ APValue::APValue(const APValue &RHS) : Kind(None) { } } -APValue::APValue(APValue &&RHS) : Kind(RHS.Kind), Data(RHS.Data) { +APValue::APValue(APValue &&RHS) + : Kind(RHS.Kind), AllowConstexprUnknown(RHS.AllowConstexprUnknown), + Data(RHS.Data) { RHS.Kind = None; } APValue &APValue::operator=(const APValue &RHS) { if (this != &RHS) *this = APValue(RHS); + + AllowConstexprUnknown = RHS.AllowConstexprUnknown; return *this; } @@ -395,6 +400,7 @@ APValue &APValue::operator=(APValue &&RHS) { DestroyDataAndMakeUninit(); Kind = RHS.Kind; Data = RHS.Data; + AllowConstexprUnknown = RHS.AllowConstexprUnknown; RHS.Kind = None; } return *this; @@ -426,6 +432,7 @@ void APValue::DestroyDataAndMakeUninit() { else if (Kind == AddrLabelDiff) ((AddrLabelDiffData *)(char *)&Data)->~AddrLabelDiffData(); Kind = None; + AllowConstexprUnknown = false; } bool APValue::needsCleanup() const { @@ -468,6 +475,7 @@ bool APValue::needsCleanup() const { void APValue::swap(APValue &RHS) { std::swap(Kind, RHS.Kind); std::swap(Data, RHS.Data); + std::swap(AllowConstexprUnknown, RHS.AllowConstexprUnknown); } /// Profile the value of an APInt, excluding its bit-width. diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index 7178f081d9cf3..9a427d908e4c9 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -1609,8 +1609,11 @@ namespace { SubobjectDesignator Designator; bool IsNullPtr : 1; bool InvalidBase : 1; + // P2280R4 track if we have an unknown reference or pointer. + bool AllowConstexprUnknown = false; const APValue::LValueBase getLValueBase() const { return Base; } + bool allowConstexprUnknown() const { return AllowConstexprUnknown; } CharUnits &getLValueOffset() { return Offset; } const CharUnits &getLValueOffset() const { return Offset; } SubobjectDesignator &getLValueDesignator() { return Designator; } @@ -1628,6 +1631,8 @@ namespace { V = APValue(Base, Offset, Designator.Entries, Designator.IsOnePastTheEnd, IsNullPtr); } + if (AllowConstexprUnknown) + V.setConstexprUnknown(); } void setFrom(ASTContext &Ctx, const APValue &V) { assert(V.isLValue() && "Setting LValue from a non-LValue?"); @@ -1636,6 +1641,7 @@ namespace { InvalidBase = false; Designator = SubobjectDesignator(Ctx, V); IsNullPtr = V.isNullPointer(); + AllowConstexprUnknown = V.allowConstexprUnknown(); } void set(APValue::LValueBase B, bool BInvalid = false) { @@ -1653,6 +1659,7 @@ namespace { InvalidBase = BInvalid; Designator = SubobjectDesignator(getType(B)); IsNullPtr = false; + AllowConstexprUnknown = false; } void setNull(ASTContext &Ctx, QualType PointerTy) { @@ -1662,6 +1669,7 @@ namespace { InvalidBase = false; Designator = SubobjectDesignator(PointerTy->getPointeeType()); IsNullPtr = true; + AllowConstexprUnknown = false; } void setInvalid(APValue::LValueBase B, unsigned I = 0) { @@ -3300,6 +3308,11 @@ static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E, static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, const VarDecl *VD, CallStackFrame *Frame, unsigned Version, APValue *&Result) { + // P2280R4 If we have a reference type and we are in C++23 allow unknown + // references and pointers. + bool AllowConstexprUnknown = + Info.getLangOpts().CPlusPlus23 && VD->getType()->isReferenceType(); + APValue::LValueBase Base(VD, Frame ? Frame->Index : 0, Version); // If this is a local variable, dig out its value. @@ -3334,7 +3347,9 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, return true; } - if (isa<ParmVarDecl>(VD)) { + // P2280R4 struck the restriction that variable of referene type lifetime + // should begin within the evaluation of E + if (isa<ParmVarDecl>(VD) && !AllowConstexprUnknown) { // Assume parameters of a potential constant expression are usable in // constant expressions. if (!Info.checkingPotentialConstantExpression() || @@ -3358,7 +3373,9 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, // FIXME: We should eventually check whether the variable has a reachable // initializing declaration. const Expr *Init = VD->getAnyInitializer(VD); - if (!Init) { + // P2280R4 struck the restriction that variable of referene type should have + // a preceding initialization. + if (!Init && !AllowConstexprUnknown) { // Don't diagnose during potential constant expression checking; an // initializer might be added later. if (!Info.checkingPotentialConstantExpression()) { @@ -3369,7 +3386,9 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, return false; } - if (Init->isValueDependent()) { + // P2280R4 struck the initialization requirement for variables of reference + // type so we can no longer assume we have an Init. + if (Init && Init->isValueDependent()) { // The DeclRefExpr is not value-dependent, but the variable it refers to // has a value-dependent initializer. This should only happen in // constant-folding cases, where the variable is not actually of a suitable @@ -3388,7 +3407,9 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, // Check that we can fold the initializer. In C++, we will have already done // this in the cases where it matters for conformance. - if (!VD->evaluateValue()) { + // P2280R4 struck the initialization requirement for variables of reference + // type so we can no longer assume we have an Init. + if (Init && !VD->evaluateValue()) { Info.FFDiag(E, diag::note_constexpr_var_init_non_constant, 1) << VD; NoteLValueLocation(Info, Base); return false; @@ -3420,6 +3441,15 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, } Result = VD->getEvaluatedValue(); + + // P2280R4 If we don't have a value because this is a reference that was not + // initialized or whose lifetime began within E then create a value with as + // a ConstexprUnknown status. + if (AllowConstexprUnknown) { + if (!Result) { + Result = new APValue(Base, APValue::ConstexprUnknown{}, CharUnits::One()); + } + } return true; } @@ -3700,6 +3730,11 @@ findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const FieldDecl *LastField = nullptr; const FieldDecl *VolatileField = nullptr; + // P2280R4 If we have an unknown referene or pointer and we don't have a + // value then bail out. + if (O->allowConstexprUnknown() && !O->hasValue()) + return false; + // Walk the designator's path to find the subobject. for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) { // Reading an indeterminate value is undefined, but assigning over one is OK. @@ -5732,6 +5767,12 @@ struct CheckDynamicTypeHandler { /// dynamic type. static bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This, AccessKinds AK, bool Polymorphic) { + // P2280R4 We are not allowed to invoke a virtual function whose dynamic type + // us constexpr-unknown, so stop early and let this fail later on if we + // attempt to do so. + if (This.allowConstexprUnknown()) + return true; + if (This.Designator.Invalid) return false; @@ -5804,7 +5845,13 @@ static std::optional<DynamicType> ComputeDynamicType(EvalInfo &Info, // If we don't have an lvalue denoting an object of class type, there is no // meaningful dynamic type. (We consider objects of non-class type to have no // dynamic type.) - if (!checkDynamicType(Info, E, This, AK, true)) + if (!checkDynamicType(Info, E, This, AK, + (AK == AK_TypeId + ? (E->getType()->isReferenceType() ? true : false) + : true))) + return std::nullopt; + + if (This.Designator.Invalid) return std::nullopt; // Refuse to compute a dynamic type in the presence of virtual bases. This @@ -8539,7 +8586,8 @@ static bool HandleLambdaCapture(EvalInfo &Info, const Expr *E, LValue &Result, const ParmVarDecl *Self = MD->getParamDecl(0); if (Self->getType()->isReferenceType()) { APValue *RefValue = Info.getParamSlot(Info.CurrentCall->Arguments, Self); - Result.setFrom(Info.Ctx, *RefValue); + if (!RefValue->allowConstexprUnknown() || RefValue->hasValue()) + Result.setFrom(Info.Ctx, *RefValue); } else { const ParmVarDecl *VD = Info.CurrentCall->Arguments.getOrigParam(Self); CallStackFrame *Frame = @@ -8595,7 +8643,10 @@ bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) { bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) { - + // P2280R4 if we are in C++23 track if we have an unknown reference or + // pointer. + bool AllowConstexprUnknown = + Info.getLangOpts().CPlusPlus23 && VD->getType()->isReferenceType(); // If we are within a lambda's call operator, check whether the 'VD' referred // to within 'E' actually represents a lambda-capture that maps to a // data-member/field within the closure object, and if so, evaluate to the @@ -8665,10 +8716,23 @@ bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) { if (!V->hasValue()) { // FIXME: Is it possible for V to be indeterminate here? If so, we should // adjust the diagnostic to say that. - if (!Info.checkingPotentialConstantExpression()) + // P2280R4 If we are have a variable that is unknown reference or pointer + // it may not have a value but still be usable later on so do not diagnose. + if (!Info.checkingPotentialConstantExpression() && !AllowConstexprUnknown) Info.FFDiag(E, diag::note_constexpr_use_uninit_reference); + + // P2280R4 If we are have a variable that is unknown reference or pointer + // try to recover it from the frame and set the result accordingly. + if (VD->getType()->isReferenceType() && AllowConstexprUnknown) { + if (Frame) { + Result.set({VD, Frame->Index, Version}); + return true; + } + return Success(VD); + } return false; } + return Success(*V, E); } @@ -11486,7 +11550,10 @@ class IntExprEvaluator } bool Success(const APValue &V, const Expr *E) { - if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate()) { + // P2280R4 if we have an unknown reference or pointer allow further + // evaluation of the value. + if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate() || + V.allowConstexprUnknown()) { Result = V; return true; } diff --git a/clang/test/SemaCXX/constant-expression-cxx11.cpp b/clang/test/SemaCXX/constant-expression-cxx11.cpp index efb391ba0922d..684a6a242bf71 100644 --- a/clang/test/SemaCXX/constant-expression-cxx11.cpp +++ b/clang/test/SemaCXX/constant-expression-cxx11.cpp @@ -1419,9 +1419,9 @@ namespace ConvertedConstantExpr { // useless note and instead just point to the non-constant subexpression. enum class E { em = m, - en = n, // expected-error {{not a constant expression}} expected-note {{initializer of 'n' is unknown}} + en = n, // cxx23-note {{initializer of 'n' is not a constant expression}} expected-error {{enumerator value is not a constant expression}} cxx11_20-note {{initializer of 'n' is unknown}} eo = (m + // expected-error {{not a constant expression}} - n // expected-note {{initializer of 'n' is unknown}} + n // cxx23-note {{initializer of 'n' is not a constant expression}} cxx11_20-note {{initializer of 'n' is unknown}} ), eq = reinterpret_cast<long>((int*)0) // expected-error {{not a constant expression}} expected-note {{reinterpret_cast}} }; @@ -1961,7 +1961,8 @@ namespace ConstexprConstructorRecovery { namespace Lifetime { void f() { - constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}} expected-warning {{not yet bound to a value}} + constexpr int &n = n; // expected-error {{constant expression}} cxx23-note {{reference to 'n' is not a constant expression}} cxx23-note {{address of non-static constexpr variable 'n' may differ}} expected-warning {{not yet bound to a value}} + // cxx11_20-note@-1 {{use of reference outside its lifetime is not allowed in a constant expression}} constexpr int m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}} } @@ -2381,15 +2382,15 @@ namespace array_size { template<typename T> void f1(T t) { constexpr int k = t.size(); } - template<typename T> void f2(const T &t) { // expected-note 2{{declared here}} - constexpr int k = t.size(); // expected-error 2{{constant}} expected-note 2{{function parameter 't' with unknown value cannot be used in a constant expression}} + template<typename T> void f2(const T &t) { // cxx11_20-note 2{{declared here}} + constexpr int k = t.size(); // cxx11_20-error 2{{constexpr variable 'k' must be initialized by a constant expression}} cxx11_20-note 2{{function parameter 't' with unknown value cannot be used in a constant expression}} } template<typename T> void f3(const T &t) { constexpr int k = T::size(); } void g(array<3> a) { f1(a); - f2(a); // expected-note {{instantiation of}} + f2(a); // cxx11_20-note {{in instantiation of function template}} f3(a); } @@ -2398,8 +2399,9 @@ namespace array_size { }; void h(array_nonstatic<3> a) { f1(a); - f2(a); // expected-note {{instantiation of}} + f2(a); // cxx11_20-note {{instantiation of}} } + //static_assert(f2(array_size::array<3>{})); } namespace flexible_array { diff --git a/clang/test/SemaCXX/constant-expression-cxx2a.cpp b/clang/test/SemaCXX/constant-expression-cxx2a.cpp index e4d97dcb73562..3910886a36346 100644 --- a/clang/test/SemaCXX/constant-expression-cxx2a.cpp +++ b/clang/test/SemaCXX/constant-expression-cxx2a.cpp @@ -308,8 +308,7 @@ namespace TypeId { static_assert(&B2().ti1 == &typeid(B)); static_assert(&B2().ti2 == &typeid(B2)); extern B2 extern_b2; - // expected-note@+1 {{typeid applied to object 'extern_b2' whose dynamic type is not constant}} - static_assert(&typeid(extern_b2) == &typeid(B2)); // expected-error {{constant expression}} + static_assert(&typeid(extern_b2) == &typeid(B2)); constexpr B2 b2; constexpr const B &b1 = b2; diff --git a/clang/test/SemaCXX/constant-expression-p2280r4.cpp b/clang/test/SemaCXX/constant-expression-p2280r4.cpp new file mode 100644 index 0000000000000..be41eed88c494 --- /dev/null +++ b/clang/test/SemaCXX/constant-expression-p2280r4.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -std=c++23 -verify %s + +using size_t = decltype(sizeof(0)); + +namespace std { +struct type_info { + const char* name() const noexcept(true); +}; +} + +template <typename T, size_t N> +constexpr size_t array_size(T (&)[N]) { + return N; +} + +void use_array(int const (&gold_medal_mel)[2]) { + constexpr auto gold = array_size(gold_medal_mel); // ok +} + +constexpr auto olympic_mile() { + const int ledecky = 1500; + return []{ return ledecky; }; +} +static_assert(olympic_mile()() == 1500); // ok + +struct Swim { + constexpr int phelps() { return 28; } + virtual constexpr int lochte() { return 12; } + int coughlin = 12; +}; + +constexpr int how_many(Swim& swam) { + Swim* p = &swam; + return (p + 1 - 1)->phelps(); +} + +void splash(Swim& swam) { + static_assert(swam.phelps() == 28); // ok + static_assert((&swam)->phelps() == 28); // ok + Swim* pswam = &swam; // expected-note {{declared here}} + static_assert(pswam->phelps() == 28); // expected-error {{static assertion expression is not an integral constant expression}} + // expected-note@-1 {{read of non-constexpr variable 'pswam' is not allowed in a constant expression}} + static_assert(how_many(swam) == 28); // ok + static_assert(Swim().lochte() == 12); // ok + static_assert(swam.lochte() == 12); // expected-error {{static assertion expression is not an integral constant expression}} + static_assert(swam.coughlin == 12); // expected-error {{static assertion expression is not an integral constant expression}} +} + +extern Swim dc; +extern Swim& trident; // expected-note {{declared here}} + +constexpr auto& sandeno = typeid(dc); // ok: can only be typeid(Swim) +constexpr auto& gallagher = typeid(trident); // expected-error {{constexpr variable 'gallagher' must be initialized by a constant expression}} + // expected-note@-1 {{initializer of 'trident' is not a constant expression}} _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
