https://github.com/efriedma-quic updated
https://github.com/llvm/llvm-project/pull/132990
>From 2873bb1aee5470ecd7fa66c1f255bfe8b26dbc68 Mon Sep 17 00:00:00 2001
From: Eli Friedman <efrie...@quicinc.com>
Date: Mon, 17 Mar 2025 11:20:21 -0700
Subject: [PATCH 1/3] [clang] fix constexpr-unknown handling of
self-references.
Usually, in constant evaluation, references which are local to the
evaluation have to be initialized before they're accessed. However,
there's one funny special case: the initializer of a reference can refer
to itself. This generally ends up being undefined behavior if it's
used in an evaluated context, but it isn't othewise forbidden.
In constant evaluation, this splits into two cases: global variables,
and local variables in constexpr functions. This patch handles both of
those cases. (Local variables tends to trip other errors in most cases,
but if you try hard enough, you can get an accepts-invalid.)
I'm not sure what's correct for g5(): this patch and gcc accept, but
-fexperimental-new-constant-interpreter rejects.
Fixes #131330 .
---
clang/lib/AST/ExprConstant.cpp | 70 ++++++++-----------
.../SemaCXX/constant-expression-p2280r4.cpp | 49 ++++++++++++-
2 files changed, 78 insertions(+), 41 deletions(-)
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 0165a0a3b0df3..5c64f0510469c 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -3485,11 +3485,27 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
APValue::LValueBase Base(VD, Frame ? Frame->Index : 0, Version);
+ auto CheckUninitReference = [&] {
+ if (!Result->hasValue() && VD->getType()->isReferenceType()) {
+ // We can't use an uninitialized reference directly.
+ if (!AllowConstexprUnknown) {
+ if (!Info.checkingPotentialConstantExpression())
+ Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
+ return false;
+ }
+ Result = &Info.CurrentCall->createConstexprUnknownAPValues(VD, Base);
+ }
+ return true;
+ };
+
// If this is a local variable, dig out its value.
if (Frame) {
Result = Frame->getTemporary(VD, Version);
- if (Result)
+ if (Result) {
+ if (!CheckUninitReference())
+ return false;
return true;
+ }
if (!isa<ParmVarDecl>(VD)) {
// Assume variables referenced within a lambda's call operator that were
@@ -3514,6 +3530,9 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
// in-flight value.
if (Info.EvaluatingDecl == Base) {
Result = Info.EvaluatingDeclValue;
+ if (!CheckUninitReference())
+ return false;
+
return true;
}
@@ -3587,11 +3606,7 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
// type so we can no longer assume we have an Init.
// Used to be C++20 [expr.const]p5.12:
// ... reference has a preceding initialization and either ...
- if (Init && !VD->evaluateValue()) {
- if (AllowConstexprUnknown) {
- Result = &Info.CurrentCall->createConstexprUnknownAPValues(VD, Base);
- return true;
- }
+ if (Init && !VD->evaluateValue() && !AllowConstexprUnknown) {
Info.FFDiag(E, diag::note_constexpr_var_init_non_constant, 1) << VD;
NoteLValueLocation(Info, Base);
return false;
@@ -3629,17 +3644,17 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
Result = VD->getEvaluatedValue();
- // C++23 [expr.const]p8
- // ... For such an object that is not usable in constant expressions, the
- // dynamic type of the object is constexpr-unknown. For such a reference that
- // is not usable in constant expressions, the reference is treated as binding
- // to an unspecified object of the referenced type whose lifetime and that of
- // all subobjects includes the entire constant evaluation and whose dynamic
- // type is constexpr-unknown.
- if (AllowConstexprUnknown) {
- if (!Result)
+ if (!Result) {
+ if (AllowConstexprUnknown) {
Result = &Info.CurrentCall->createConstexprUnknownAPValues(VD, Base);
+ } else {
+ return false;
+ }
}
+
+ if (!CheckUninitReference())
+ return false;
+
return true;
}
@@ -8929,12 +8944,7 @@ bool LValueExprEvaluator::VisitDeclRefExpr(const
DeclRefExpr *E) {
return Error(E);
}
-
bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
- // C++23 [expr.const]p8 If we have a reference type allow unknown references
- // and pointers.
- 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
@@ -9001,26 +9011,6 @@ bool LValueExprEvaluator::VisitVarDecl(const Expr *E,
const VarDecl *VD) {
APValue *V;
if (!evaluateVarDeclInit(Info, E, VD, Frame, Version, V))
return false;
- if (!V->hasValue()) {
- // FIXME: Is it possible for V to be indeterminate here? If so, we should
- // adjust the diagnostic to say that.
- // C++23 [expr.const]p8 If we 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);
-
- // C++23 [expr.const]p8 If we 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);
}
diff --git a/clang/test/SemaCXX/constant-expression-p2280r4.cpp
b/clang/test/SemaCXX/constant-expression-p2280r4.cpp
index f22430a0e88a2..544372ee4492d 100644
--- a/clang/test/SemaCXX/constant-expression-p2280r4.cpp
+++ b/clang/test/SemaCXX/constant-expression-p2280r4.cpp
@@ -1,5 +1,5 @@
// RUN: %clang_cc1 -std=c++23 -verify=expected,nointerpreter %s
-// RUN: %clang_cc1 -std=c++23 -verify %s
-fexperimental-new-constant-interpreter
+// RUN: %clang_cc1 -std=c++23 -verify=expected,interpreter %s
-fexperimental-new-constant-interpreter
using size_t = decltype(sizeof(0));
@@ -177,3 +177,50 @@ namespace extern_reference_used_as_unknown {
int y;
constinit int& g = (x,y); // expected-warning {{left operand of comma
operator has no effect}}
}
+
+namespace uninit_reference_used {
+ int y;
+ constexpr int &r = r; // expected-error {{must be initialized by a constant
expression}} \
+ // nointerpreter-note {{initializer of 'r' is not a constant expression}} \
+ // nointerpreter-note {{declared here}}
+ constexpr int &rr = (rr, y);
+ constexpr int &g() {
+ int &x = x; // expected-warning {{reference 'x' is not yet bound to a
value when used within its own initialization}} \
+ // nointerpreter-note {{declared here}} \
+ // interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
+ return x;
+ }
+ constexpr int &gg = g(); // expected-error {{must be initialized by a
constant expression}} \
+ // nointerpreter-note {{reference to 'x' is not a constant expression}} \
+ // interpreter-note {{in call to 'g()'}}
+ constexpr int g2() {
+ int &x = x; // expected-warning {{reference 'x' is not yet bound to a
value when used within its own initialization}} \
+ // interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
+ return x;
+ }
+ constexpr int gg2 = g2(); // expected-error {{must be initialized by a
constant expression}} \
+ // interpreter-note {{in call to 'g2()'}}
+ constexpr int &g3() {
+ int &x = (x,y); // expected-warning{{left operand of comma operator has no
effect}} \
+ // expected-warning {{reference 'x' is not yet bound to a value when used
within its own initialization}}
+ return x;
+ }
+ constexpr int &gg3 = g3();
+ typedef decltype(sizeof(1)) uintptr_t;
+ constexpr uintptr_t g4() {
+ uintptr_t * &x = x; // expected-warning {{reference 'x' is not yet bound
to a value when used within its own initialization}} \
+ // interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
+ *(uintptr_t*)x = 10;
+ return 3;
+ }
+ constexpr uintptr_t gg4 = g4(); // expected-error {{must be initialized by a
constant expression}} \
+ // interpreter-note {{in call to 'g4()'}}
+ constexpr int g5() {
+ int &x = x; // expected-warning {{reference 'x' is not yet bound to a
value when used within its own initialization}} \
+ // interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
+ return 3;
+ }
+ constexpr uintptr_t gg5 = g5(); // interpreter-error {{must be initialized
by a constant expression}} \
+ // interpreter-note {{in call to 'g5()'}}
+
+}
>From 44fc6e1ef3b1bdcac23d777e931834b1423368f6 Mon Sep 17 00:00:00 2001
From: Eli Friedman <efrie...@quicinc.com>
Date: Fri, 28 Mar 2025 14:41:32 -0700
Subject: [PATCH 2/3] Address review comments.
Don't treat local variables as constexpr-unknown. Re-add comment describing
constexpr-unknown.
---
clang/lib/AST/ExprConstant.cpp | 32 +++++++++----------
.../SemaCXX/constant-expression-p2280r4.cpp | 22 +++++++------
2 files changed, 29 insertions(+), 25 deletions(-)
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 5c64f0510469c..5c91a6efef494 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -3485,10 +3485,19 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
APValue::LValueBase Base(VD, Frame ? Frame->Index : 0, Version);
- auto CheckUninitReference = [&] {
+ auto CheckUninitReference = [&] (bool IsLocalVariable) {
if (!Result->hasValue() && VD->getType()->isReferenceType()) {
- // We can't use an uninitialized reference directly.
- if (!AllowConstexprUnknown) {
+ // C++23 [expr.const]p8
+ // ... For such an object that is not usable in constant expressions, the
+ // dynamic type of the object is constexpr-unknown. For such a reference
+ // that is not usable in constant expressions, the reference is treated
+ // as binding to an unspecified object of the referenced type whose
+ // lifetime and that of all subobjects includes the entire constant
+ // evaluation and whose dynamic type is constexpr-unknown.
+ //
+ // Variables that are part of the current evaluation are not
+ // constexpr-unknown.
+ if (!AllowConstexprUnknown || IsLocalVariable) {
if (!Info.checkingPotentialConstantExpression())
Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
return false;
@@ -3501,11 +3510,8 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
// If this is a local variable, dig out its value.
if (Frame) {
Result = Frame->getTemporary(VD, Version);
- if (Result) {
- if (!CheckUninitReference())
- return false;
- return true;
- }
+ if (Result)
+ return CheckUninitReference(/*IsLocalVariable=*/true);
if (!isa<ParmVarDecl>(VD)) {
// Assume variables referenced within a lambda's call operator that were
@@ -3530,10 +3536,7 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
// in-flight value.
if (Info.EvaluatingDecl == Base) {
Result = Info.EvaluatingDeclValue;
- if (!CheckUninitReference())
- return false;
-
- return true;
+ return CheckUninitReference(/*IsLocalVariable=*/false);
}
// P2280R4 struck the restriction that variable of reference type lifetime
@@ -3652,10 +3655,7 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const
Expr *E,
}
}
- if (!CheckUninitReference())
- return false;
-
- return true;
+ return CheckUninitReference(/*IsLocalVariable=*/false);
}
/// Get the base index of the given base class within an APValue representing
diff --git a/clang/test/SemaCXX/constant-expression-p2280r4.cpp
b/clang/test/SemaCXX/constant-expression-p2280r4.cpp
index 544372ee4492d..da19cdf952902 100644
--- a/clang/test/SemaCXX/constant-expression-p2280r4.cpp
+++ b/clang/test/SemaCXX/constant-expression-p2280r4.cpp
@@ -186,41 +186,45 @@ namespace uninit_reference_used {
constexpr int &rr = (rr, y);
constexpr int &g() {
int &x = x; // expected-warning {{reference 'x' is not yet bound to a
value when used within its own initialization}} \
- // nointerpreter-note {{declared here}} \
+ // nointerpreter-note {{use of reference outside its lifetime is not
allowed in a constant expression}} \
// interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
return x;
}
constexpr int &gg = g(); // expected-error {{must be initialized by a
constant expression}} \
- // nointerpreter-note {{reference to 'x' is not a constant expression}} \
- // interpreter-note {{in call to 'g()'}}
+ // expected-note {{in call to 'g()'}}
constexpr int g2() {
int &x = x; // expected-warning {{reference 'x' is not yet bound to a
value when used within its own initialization}} \
+ // nointerpreter-note {{use of reference outside its lifetime is not
allowed in a constant expression}} \
// interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
return x;
}
constexpr int gg2 = g2(); // expected-error {{must be initialized by a
constant expression}} \
- // interpreter-note {{in call to 'g2()'}}
+ // expected-note {{in call to 'g2()'}}
constexpr int &g3() {
int &x = (x,y); // expected-warning{{left operand of comma operator has no
effect}} \
- // expected-warning {{reference 'x' is not yet bound to a value when used
within its own initialization}}
+ // expected-warning {{reference 'x' is not yet bound to a value when used
within its own initialization}} \
+ // nointerpreter-note {{use of reference outside its lifetime is not
allowed in a constant expression}}
return x;
}
- constexpr int &gg3 = g3();
+ constexpr int &gg3 = g3(); // nointerpreter-error {{must be initialized by a
constant expression}} \
+ // nointerpreter-note {{in call to 'g3()'}}
typedef decltype(sizeof(1)) uintptr_t;
constexpr uintptr_t g4() {
uintptr_t * &x = x; // expected-warning {{reference 'x' is not yet bound
to a value when used within its own initialization}} \
+ // nointerpreter-note {{use of reference outside its lifetime is not
allowed in a constant expression}} \
// interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
*(uintptr_t*)x = 10;
return 3;
}
constexpr uintptr_t gg4 = g4(); // expected-error {{must be initialized by a
constant expression}} \
- // interpreter-note {{in call to 'g4()'}}
+ // expected-note {{in call to 'g4()'}}
constexpr int g5() {
int &x = x; // expected-warning {{reference 'x' is not yet bound to a
value when used within its own initialization}} \
+ // nointerpreter-note {{use of reference outside its lifetime is not
allowed in a constant expression}} \
// interpreter-note {{read of uninitialized object is not allowed in a
constant expression}}
return 3;
}
- constexpr uintptr_t gg5 = g5(); // interpreter-error {{must be initialized
by a constant expression}} \
- // interpreter-note {{in call to 'g5()'}}
+ constexpr uintptr_t gg5 = g5(); // expected-error {{must be initialized by a
constant expression}} \
+ // expected-note {{in call to 'g5()'}}
}
>From 8d376007b9fa67a5b2ea28312bbe994318fd3cb5 Mon Sep 17 00:00:00 2001
From: Eli Friedman <efrie...@quicinc.com>
Date: Fri, 28 Mar 2025 14:46:17 -0700
Subject: [PATCH 3/3] Add release note, since we're not backporting this.
---
clang/docs/ReleaseNotes.rst | 2 ++
1 file changed, 2 insertions(+)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 159991e8db981..2779b91194048 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -357,6 +357,8 @@ Bug Fixes to C++ Support
- Fixed a Clang regression in C++20 mode where unresolved dependent call
expressions were created inside non-dependent contexts (#GH122892)
- Clang now emits the ``-Wunused-variable`` warning when some structured
bindings are unused
and the ``[[maybe_unused]]`` attribute is not applied. (#GH125810)
+- Fixed bug in constant evaluation that would allow using the value of a
+ reference in its own initializer in C++23 mode (#GH131330).
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
