[clang] [Clang] Preserve original arguments in constexpr call diagnostics (PR #239911)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Nov 6 23:08:03 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: nudt_yixiao (keepyixiao)
<details>
<summary>Changes</summary>
When constexpr evaluation fails, call stack diagnostics may show modified parameter values instead of the original arguments passed at the call site.
Save the original argument values in CallStackFrame::OriginalArgs and use them when describing constexpr calls.
Add regression tests for modified and multiple function arguments.
Assisted-by: AI
Fixes https://github.com/llvm/llvm-project/issues/107554
---
Full diff: https://github.com/llvm/llvm-project/pull/239911.diff
3 Files Affected:
- (modified) clang/docs/ReleaseNotes.md (+3)
- (modified) clang/lib/AST/ExprConstant.cpp (+23-2)
- (modified) clang/test/SemaCXX/constant-expression-cxx14.cpp (+71)
``````````diff
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index e6e84323ca73f1..1cbbc5f20f0cec 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -797,6 +797,9 @@ documentation](CIR/index.md) for more information regarding ClangIR's status and
- Clang will now no longer assert or miscompile on a constructor that has more than 65535 base and member initializers. (#GH219366)
+- Fixed an issue where diagnostics for failed constant expressions could report modified parameter
+ values instead of the original argument values at the constexpr function call site. (#GH107554)
+
### Improvements to Clang's time-trace
### Improvements to Coverage Mapping
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 57d5bb475d0f9b..fc4b3f8f938fa3 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -512,6 +512,11 @@ namespace {
/// Index - The call index of this call.
unsigned Index;
+ /// The values of the parameters at the beginning of this call.
+ /// Used to describe the constexpr call in diagnostics, since the
+ /// parameter values may be modified during constant evaluation.
+ llvm::SmallVector<APValue, 4> OriginalArgs;
+
/// The stack of integers for tracking version numbers for temporaries.
SmallVector<unsigned, 2> TempVersionStack = {1};
unsigned CurTempVersion = TempVersionStack.back();
@@ -1292,6 +1297,17 @@ CallStackFrame::CallStackFrame(EvalInfo &Info, SourceRange CallRange,
Index(Info.NextCallIndex++) {
Info.CurrentCall = this;
++Info.CallStackDepth;
+ // Save the original argument values before executing
+ // the callee. The parameter slots may be modified
+ // during constant evaluation.
+ if (Arguments) {
+ for (const ParmVarDecl *Param : Callee->parameters()) {
+ if (const APValue *V = Info.getParamSlot(Arguments, Param))
+ OriginalArgs.push_back(*V);
+ else
+ OriginalArgs.emplace_back();
+ }
+ }
}
CallStackFrame::~CallStackFrame() {
@@ -1976,12 +1992,17 @@ void CallStackFrame::describe(raw_ostream &Out) const {
}
Out << '(';
-
+ unsigned ArgIndex = ExplicitInstanceParam;
llvm::ListSeparator Comma;
for (const ParmVarDecl *Param :
Callee->parameters().slice(ExplicitInstanceParam)) {
Out << Comma;
- const APValue *V = Info.getParamSlot(Arguments, Param);
+ const APValue *V = nullptr;
+
+ if (ArgIndex < OriginalArgs.size() && !OriginalArgs[ArgIndex].isAbsent()) {
+ V = &OriginalArgs[ArgIndex];
+ }
+ ArgIndex++;
if (V)
V->printPretty(Out, Info.Ctx, Param->getType());
else
diff --git a/clang/test/SemaCXX/constant-expression-cxx14.cpp b/clang/test/SemaCXX/constant-expression-cxx14.cpp
index c64466700808ad..ee2be4908fa3a8 100644
--- a/clang/test/SemaCXX/constant-expression-cxx14.cpp
+++ b/clang/test/SemaCXX/constant-expression-cxx14.cpp
@@ -1466,3 +1466,74 @@ constexpr bool missingCase() {
1u: return false; // expected-error {{expected 'case' keyword before expression}}
}
}
+
+constexpr int f(int x) {
+ ++x;
+ return x / x; // expected-note {{division by zero}}
+}
+
+constexpr int ii = -1;
+static_assert(f(ii) == 1, ""); // expected-error {{static assertion expression is not an integral constant expression}} \
+ expected-note {{in call to 'f(-1)'}}
+
+constexpr int multi_arg_1(int x, int y) {
+ ++x;
+ ++y;
+ return x / (y - y); // expected-note {{division by zero}}
+}
+
+constexpr int a = -1;
+constexpr int b = 1;
+
+static_assert(multi_arg_1(a, b) == 1, ""); // expected-error {{not an integral constant expression}} \
+ expected-note {{in call to 'multi_arg_1(-1, 1)'}}
+
+constexpr int multi_arg_2(int x, int y) {
+ ++y;
+ return x / (y - y); // expected-note {{division by zero}}
+}
+
+constexpr int a1 = -1;
+constexpr int b1 = 1;
+
+static_assert(multi_arg_2(a1, b1) == 1, ""); // expected-error {{not an integral constant expression}} \
+ expected-note {{in call to 'multi_arg_2(-1, 1)'}}
+
+constexpr int ref_arg_1(int &x) {
+ ++x;
+ return x / (x - x); // expected-note {{division by zero}}
+}
+
+constexpr int test_ref_arg_1() {
+ int a = -1;
+ return ref_arg_1(a); // expected-note {{in call to 'ref_arg_1(a)'}}
+}
+
+static_assert(test_ref_arg_1() == 1, ""); // expected-error {{not an integral constant expression}} \
+ expected-note {{in call to 'test_ref_arg_1()'}}
+
+constexpr int ref_arg_2(int &x, int &y) {
+ ++x;
+ ++y;
+ return x / (y - y); // expected-note {{division by zero}}
+}
+
+constexpr int test_ref_arg_2() {
+ int a = -1;
+ int b = 1;
+ return ref_arg_2(a, b); // expected-note {{in call to 'ref_arg_2(a, b)'}}
+}
+
+static_assert(test_ref_arg_2() == 1, ""); // expected-error {{not an integral constant expression}} \
+ expected-note {{in call to 'test_ref_arg_2()'}}
+
+char c[3] = "Hi";
+
+constexpr char g1(int i) { i *= 2; return c[i]; } // expected-note {{cannot refer to element 10 of array of 3 elements in a constant expression}}
+constexpr char f1(int i, int j) {
+ auto line = i * 4;
+ return g1(line + j); // expected-note {{in call to 'g1(5)'}}
+}
+
+static_assert(f1(1, 1), ""); // expected-error {{not an integral constant expression}} \
+ expected-note {{in call to 'f1(1, 1)'}}
``````````
</details>
https://github.com/llvm/llvm-project/pull/239911
More information about the cfe-commits
mailing list