hokein updated this revision to Diff 282917.
hokein added a comment.
update
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D84637/new/
https://reviews.llvm.org/D84637
Files:
clang/lib/AST/ExprConstant.cpp
clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
clang/test/SemaCXX/enable_if.cpp
clang/test/SemaCXX/invalid-constructor-init.cpp
clang/test/SemaCXX/recovery-expr-type.cpp
Index: clang/test/SemaCXX/recovery-expr-type.cpp
===================================================================
--- clang/test/SemaCXX/recovery-expr-type.cpp
+++ clang/test/SemaCXX/recovery-expr-type.cpp
@@ -53,14 +53,12 @@
return 2;
}
static constexpr int foo2() {
- return AA<T>::getB(); // expected-error{{no matching function for call to 'getB'}} \
- // expected-note {{subexpression not valid in a constant expression}}
+ return AA<T>::getB(); // expected-error{{no matching function for call to 'getB'}}
}
};
// FIXME: should we suppress the "be initialized by a constant expression" diagnostic?
constexpr auto x2 = AA<int>::foo2(); // expected-error {{be initialized by a constant expression}} \
- // expected-note {{in instantiation of member function}} \
- // expected-note {{in call to}}
+ // expected-note {{in instantiation of member function}}
}
// verify no assertion failure on violating value category.
Index: clang/test/SemaCXX/invalid-constructor-init.cpp
===================================================================
--- clang/test/SemaCXX/invalid-constructor-init.cpp
+++ clang/test/SemaCXX/invalid-constructor-init.cpp
@@ -2,7 +2,7 @@
struct X {
int Y;
- constexpr X() // expected-error {{constexpr constructor never produces}}
+ constexpr X()
: Y(foo()) {} // expected-error {{use of undeclared identifier 'foo'}}
};
// no crash on evaluating the constexpr ctor.
@@ -16,7 +16,7 @@
struct X3 {
int Y;
- constexpr X3() // expected-error {{constexpr constructor never produces}}
+ constexpr X3()
: Y(({foo();})) {} // expected-error {{use of undeclared identifier 'foo'}}
};
Index: clang/test/SemaCXX/enable_if.cpp
===================================================================
--- clang/test/SemaCXX/enable_if.cpp
+++ clang/test/SemaCXX/enable_if.cpp
@@ -415,7 +415,7 @@
template <int N> constexpr int callTemplated() { return templated<N>(); }
constexpr int B = 10 + // expected-error {{initialized by a constant expression}}
- callTemplated<0>(); // expected-error@-3{{no matching function for call to 'templated'}} expected-note{{in instantiation of function template}} expected-note@-10{{candidate disabled}} expected-note {{in call to 'callTemplated()'}} expected-note@-3 {{subexpression not valid in a constant expression}}
+ callTemplated<0>(); // expected-error@-3{{no matching function for call to 'templated'}} expected-note{{in instantiation of function template}} expected-note@-10{{candidate disabled}}
static_assert(callTemplated<1>() == 1, "");
}
Index: clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
===================================================================
--- /dev/null
+++ clang/test/SemaCXX/constexpr-function-recovery-crash.cpp
@@ -0,0 +1,35 @@
+// RUN: %clang_cc1 %s -std=c++20 -fsyntax-only -verify
+
+// verify no value-dependent-assertion crash in constexpr function body.
+class Foo {
+ constexpr Foo() {
+ while (invalid()) {} // expected-error {{use of undeclared identifier}}
+ if (invalid()) {} // expected-error {{use of undeclared identifier}}
+ }
+};
+
+constexpr void test1() {
+ while (invalid()) {} // expected-error {{use of undeclared identifier}}
+ if (invalid()) {} // expected-error {{use of undeclared identifier}}
+}
+
+struct A {
+ int* p = new int(invalid()); // expected-error {{use of undeclared identifier}}
+ constexpr ~A() { delete p; }
+};
+constexpr int test2() {
+ A a;
+ return 1;
+}
+
+constexpr int test3() {
+ return invalid(); // expected-error {{use of undeclared identifier}}
+}
+
+constexpr int test4() { // expected-error {{constexpr function never produces a constant expression}}
+ if (invalid()) // expected-error {{use of undeclared identifier}}
+ return 1;
+ else
+ return 0;
+// FIXME: remove the "control reached end" diagnostic note.
+} // expected-note {{control reached end of constexpr function}}
Index: clang/lib/AST/ExprConstant.cpp
===================================================================
--- clang/lib/AST/ExprConstant.cpp
+++ clang/lib/AST/ExprConstant.cpp
@@ -1868,6 +1868,7 @@
/// result.
/// \return \c true if the caller should keep evaluating.
static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
+ assert(!E->isValueDependent());
APValue Scratch;
if (!Evaluate(Scratch, Info, E))
// We don't need the value, but we might have skipped a side effect here.
@@ -2369,6 +2370,7 @@
static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition");
APValue Val;
if (!Evaluate(Val, Info, E))
@@ -4611,6 +4613,7 @@
/// Evaluate a condition (either a variable declaration or an expression).
static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
const Expr *Cond, bool &Result) {
+ assert(!Cond->isValueDependent());
FullExpressionRAII Scope(Info);
if (CondDecl && !EvaluateDecl(Info, CondDecl))
return false;
@@ -4744,6 +4747,15 @@
llvm_unreachable("Invalid EvalStmtResult!");
}
+static EvalStmtResult EvaluateDependentExpr(const Expr *E, EvalInfo &Info) {
+ assert(E->isValueDependent());
+ if (Info.noteSideEffect())
+ return ESR_Succeeded;
+ assert(E->containsErrors() && "valid value-dependent expression should never "
+ "reach invalid code path.");
+ return ESR_Failed;
+}
+
// Evaluate a statement.
static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
const Stmt *S, const SwitchCase *Case) {
@@ -4868,6 +4880,8 @@
switch (S->getStmtClass()) {
default:
if (const Expr *E = dyn_cast<Expr>(S)) {
+ if (E->isValueDependent())
+ return EvaluateDependentExpr(E, Info);
// Don't bother evaluating beyond an expression-statement which couldn't
// be evaluated.
// FIXME: Do we need the FullExpressionRAII object here?
@@ -4900,6 +4914,10 @@
case Stmt::ReturnStmtClass: {
const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
FullExpressionRAII Scope(Info);
+ if (RetExpr && RetExpr->isValueDependent())
+ return EvaluateDependentExpr(RetExpr, Info) == ESR_Succeeded
+ ? ESR_Returned
+ : ESR_Failed;
if (RetExpr &&
!(Result.Slot
? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
@@ -4940,6 +4958,8 @@
return ESR;
}
}
+ if (IS->getCond()->isValueDependent())
+ return EvaluateDependentExpr(IS->getCond(), Info);
bool Cond;
if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
return ESR_Failed;
@@ -4958,6 +4978,8 @@
case Stmt::WhileStmtClass: {
const WhileStmt *WS = cast<WhileStmt>(S);
while (true) {
+ if (WS->getCond()->isValueDependent())
+ return EvaluateDependentExpr(WS->getCond(), Info);
BlockScopeRAII Scope(Info);
bool Continue;
if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
@@ -4987,6 +5009,8 @@
return ESR;
Case = nullptr;
+ if (DS->getCond()->isValueDependent())
+ return EvaluateDependentExpr(DS->getCond(), Info);
FullExpressionRAII CondScope(Info);
if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info) ||
!CondScope.destroy())
@@ -5007,6 +5031,8 @@
}
}
while (true) {
+ if (FS->getCond() && FS->getCond()->isValueDependent())
+ return EvaluateDependentExpr(FS->getCond(), Info);
BlockScopeRAII IterScope(Info);
bool Continue = true;
if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
@@ -5073,6 +5099,8 @@
while (true) {
// Condition: __begin != __end.
{
+ if (FS->getCond()->isValueDependent())
+ return EvaluateDependentExpr(FS->getCond(), Info);
bool Continue = true;
FullExpressionRAII CondExpr(Info);
if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
@@ -5097,7 +5125,8 @@
return ESR_Failed;
return ESR;
}
-
+ if (FS->getInc()->isValueDependent())
+ return EvaluateDependentExpr(FS->getInc(), Info);
// Increment: ++__begin
if (!EvaluateIgnoredValue(Info, FS->getInc()))
return ESR_Failed;
@@ -5195,13 +5224,6 @@
return false;
}
- if (const auto *CtorDecl = dyn_cast_or_null<CXXConstructorDecl>(Definition)) {
- for (const auto *InitExpr : CtorDecl->inits()) {
- if (InitExpr->getInit() && InitExpr->getInit()->containsErrors())
- return false;
- }
- }
-
// Can we evaluate this function call?
if (Definition && Definition->isConstexpr() && Body)
return true;
@@ -5858,6 +5880,8 @@
// If it's a delegating constructor, delegate.
if (Definition->isDelegatingConstructor()) {
CXXConstructorDecl::init_const_iterator I = Definition->init_begin();
+ if ((*I)->getInit()->isValueDependent())
+ return EvaluateDependentExpr((*I)->getInit(), Info);
{
FullExpressionRAII InitScope(Info);
if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()) ||
@@ -6002,6 +6026,8 @@
// This refers to innermost anonymous struct/union containing initializer,
// not to currently constructed class.
const Expr *Init = I->getInit();
+ if (Init->isValueDependent())
+ return EvaluateDependentExpr(Init, Info);
ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent,
isa<CXXDefaultInitExpr>(Init));
FullExpressionRAII InitScope(Info);
@@ -7750,6 +7776,7 @@
/// * @selector() expressions in Objective-C
static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
bool InvalidBaseOK) {
+ assert(!E->isValueDependent());
assert(E->isGLValue() || E->getType()->isFunctionType() ||
E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E));
return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
@@ -7866,7 +7893,8 @@
}
QualType Type = Inner->getType();
-
+ if (Inner->isValueDependent())
+ return EvaluateDependentExpr(Inner, Info);
// Materialize the temporary itself.
if (!EvaluateInPlace(*Value, Info, Result, Inner)) {
*Value = APValue();
@@ -8280,6 +8308,7 @@
static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
bool InvalidBaseOK) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->hasPointerRepresentation());
return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
}
@@ -8408,6 +8437,8 @@
if (!evaluateLValue(SubExpr, Result))
return false;
} else {
+ if (SubExpr->isValueDependent())
+ return EvaluateDependentExpr(SubExpr, Info);
APValue &Value = Info.CurrentCall->createTemporary(
SubExpr, SubExpr->getType(), false, Result);
if (!EvaluateInPlace(Value, Info, Result, SubExpr))
@@ -9111,6 +9142,8 @@
AllocType))
return false;
} else if (Init) {
+ if (Init->isValueDependent())
+ return EvaluateDependentExpr(Init, Info);
if (!EvaluateInPlace(*Val, Info, Result, Init))
return false;
} else if (!getDefaultInitValue(AllocType, *Val)) {
@@ -9157,6 +9190,7 @@
static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isMemberPointerType());
return MemberPointerExprEvaluator(Info, Result).Visit(E);
}
@@ -9631,6 +9665,7 @@
static bool EvaluateRecord(const Expr *E, const LValue &This,
APValue &Result, EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isRecordType() &&
"can't evaluate expression as a record rvalue");
return RecordExprEvaluator(Info, This, Result).Visit(E);
@@ -9686,6 +9721,7 @@
/// Evaluate an expression of record type as a temporary.
static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isRecordType());
return TemporaryExprEvaluator(Info, Result).Visit(E);
}
@@ -9972,6 +10008,7 @@
static bool EvaluateArray(const Expr *E, const LValue &This,
APValue &Result, EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue");
return ArrayExprEvaluator(Info, This, Result).Visit(E);
}
@@ -9979,6 +10016,7 @@
static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
APValue &Result, const InitListExpr *ILE,
QualType AllocType) {
+ assert(!ILE->isValueDependent());
assert(ILE->isRValue() && ILE->getType()->isArrayType() &&
"not an array rvalue");
return ArrayExprEvaluator(Info, This, Result)
@@ -9989,6 +10027,7 @@
APValue &Result,
const CXXConstructExpr *CCE,
QualType AllocType) {
+ assert(!CCE->isValueDependent());
assert(CCE->isRValue() && CCE->getType()->isArrayType() &&
"not an array rvalue");
return ArrayExprEvaluator(Info, This, Result)
@@ -10366,11 +10405,13 @@
/// like char*).
static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType());
return IntExprEvaluator(Info, Result).Visit(E);
}
static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
+ assert(!E->isValueDependent());
APValue Val;
if (!EvaluateIntegerOrLValue(E, Val, Info))
return false;
@@ -10392,6 +10433,7 @@
static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
if (E->getType()->isFixedPointType()) {
APValue Val;
if (!FixedPointExprEvaluator(Info, Val).Visit(E))
@@ -10407,6 +10449,7 @@
static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
if (E->getType()->isIntegerType()) {
auto FXSema = Info.Ctx.getFixedPointSemantics(E->getType());
APSInt Val;
@@ -12026,6 +12069,7 @@
static bool
EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E,
SuccessCB &&Success, AfterCB &&DoAfter) {
+ assert(!E->isValueDependent());
assert(E->isComparisonOp() && "expected comparison operator");
assert((E->getOpcode() == BO_Cmp ||
E->getType()->isIntegralOrEnumerationType()) &&
@@ -13054,6 +13098,7 @@
} // end anonymous namespace
static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isRealFloatingType());
return FloatExprEvaluator(Info, Result).Visit(E);
}
@@ -13287,6 +13332,7 @@
static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isAnyComplexType());
return ComplexExprEvaluator(Info, Result).Visit(E);
}
@@ -13809,6 +13855,7 @@
static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isAtomicType());
return AtomicExprEvaluator(Info, This, Result).Visit(E);
}
@@ -13933,6 +13980,7 @@
}
static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
+ assert(!E->isValueDependent());
assert(E->isRValue() && E->getType()->isVoidType());
return VoidExprEvaluator(Info).Visit(E);
}
@@ -13942,6 +13990,7 @@
//===----------------------------------------------------------------------===//
static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
+ assert(!E->isValueDependent());
// In C, function designators are not lvalues, but we evaluate them as if they
// are.
QualType T = E->getType();
@@ -14052,6 +14101,7 @@
/// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
/// lvalue-to-rvalue cast if it is an lvalue.
static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
+ assert(!E->isValueDependent());
if (Info.EnableNewConstInterp) {
if (!Info.Ctx.getInterpContext().evaluateAsRValue(Info, E, Result))
return false;
@@ -14115,6 +14165,7 @@
static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
const ASTContext &Ctx, EvalInfo &Info) {
+ assert(!E->isValueDependent());
bool IsConst;
if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
return IsConst;
@@ -14126,6 +14177,7 @@
const ASTContext &Ctx,
Expr::SideEffectsKind AllowSideEffects,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
if (!E->getType()->isIntegralOrEnumerationType())
return false;
@@ -14141,6 +14193,7 @@
const ASTContext &Ctx,
Expr::SideEffectsKind AllowSideEffects,
EvalInfo &Info) {
+ assert(!E->isValueDependent());
if (!E->getType()->isFixedPointType())
return false;
@@ -15048,15 +15101,6 @@
if (FD->isDependentContext())
return true;
- // Bail out if a constexpr constructor has an initializer that contains an
- // error. We deliberately don't produce a diagnostic, as we have produced a
- // relevant diagnostic when parsing the error initializer.
- if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(FD)) {
- for (const auto *InitExpr : Ctor->inits()) {
- if (InitExpr->getInit() && InitExpr->getInit()->containsErrors())
- return false;
- }
- }
Expr::EvalStatus Status;
Status.Diag = &Diags;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
