maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

For P0732R2, P1907R1: ensure that template parameter objects don't refer 

to disallowed objects or have non-constant destruction.
This commit is contained in:
Richard Smith 2020-10-24 22:08:24 -07:00
parent aaa8b44d19
commit 7b3515880c
12 changed files with 369 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
clang/include/clang/AST/Expr.h
View File

@ -711,13 +711,26 @@ public:
ArrayRef<const Expr*> Args,
const Expr *This = nullptr) const;
/// Indicates how the constant expression will be used.
enum ConstExprUsage { EvaluateForCodeGen, EvaluateForMangling };
enum class ConstantExprKind {
/// An integer constant expression (an array bound, enumerator, case value,
/// bit-field width, or similar) or similar.
Normal,
/// A non-class template argument. Such a value is only used for mangling,
/// not for code generation, so can refer to dllimported functions.
NonClassTemplateArgument,
/// A class template argument. Such a value is used for code generation.
ClassTemplateArgument,
/// An immediate invocation. The destruction of the end result of this
/// evaluation is not part of the evaluation, but all other temporaries
/// are destroyed.
ImmediateInvocation,
};
/// Evaluate an expression that is required to be a constant expression.
bool EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
const ASTContext &Ctx,
bool InPlace = false) const;
/// Evaluate an expression that is required to be a constant expression. Does
/// not check the syntactic constraints for C and C++98 constant expressions.
bool EvaluateAsConstantExpr(
EvalResult &Result, const ASTContext &Ctx,
ConstantExprKind Kind = ConstantExprKind::Normal) const;
/// If the current Expr is a pointer, this will try to statically
/// determine the number of bytes available where the pointer is pointing.
@ -971,6 +984,8 @@ static_assert(llvm::PointerLikeTypeTraits<Expr *>::NumLowBitsAvailable <=
llvm::detail::ConstantLog2<alignof(Expr)>::value,
"PointerLikeTypeTraits<Expr*> assumes too much alignment.");
using ConstantExprKind = Expr::ConstantExprKind;
//===----------------------------------------------------------------------===//
// Wrapper Expressions.
//===----------------------------------------------------------------------===//
@ -1997,6 +2012,10 @@ public:
}
static StringRef getIdentKindName(IdentKind IK);
StringRef getIdentKindName() const {
return getIdentKindName(getIdentKind());
}
static std::string ComputeName(IdentKind IK, const Decl *CurrentDecl);
SourceLocation getBeginLoc() const { return getLocation(); }

6
clang/include/clang/Basic/DiagnosticCommonKinds.td
View File

@ -234,6 +234,12 @@ def err_seh___finally_block : Error<
// Sema && AST
def note_invalid_subexpr_in_const_expr : Note<
"subexpression not valid in a constant expression">;
def note_constexpr_invalid_template_arg : Note<
"%select{pointer|reference}0 to %select{|subobject of }1"
"%select{type_info object|string literal|temporary object|"
"predefined '%3' variable}2 is not allowed in a template argument">;
def err_constexpr_invalid_template_arg : Error<
note_constexpr_invalid_template_arg.Text>;
// Sema && Frontend
let CategoryName = "Inline Assembly Issue" in {

1
clang/include/clang/Basic/LLVM.h
View File

@ -54,6 +54,7 @@ namespace llvm {
namespace clang {
// Casting operators.
using llvm::isa;
using llvm::isa_and_nonnull;
using llvm::cast;
using llvm::dyn_cast;
using llvm::dyn_cast_or_null;

1
clang/include/clang/Basic/PartialDiagnostic.h
View File

@ -142,6 +142,7 @@ public:
}
unsigned getDiagID() const { return DiagID; }
void setDiagID(unsigned ID) { DiagID = ID; }
void Emit(const DiagnosticBuilder &DB) const {
if (!DiagStorage)

276
clang/lib/AST/ExprConstant.cpp
View File

@ -183,6 +183,37 @@ namespace {
return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
}
/// Determines whether the given kind of constant expression is only ever
/// used for name mangling. If so, it's permitted to reference things that we
/// can't generate code for (in particular, dllimported functions).
static bool isForManglingOnly(ConstantExprKind Kind) {
switch (Kind) {
case ConstantExprKind::Normal:
case ConstantExprKind::ClassTemplateArgument:
case ConstantExprKind::ImmediateInvocation:
// Note that non-type template arguments of class type are emitted as
// template parameter objects.
return false;
case ConstantExprKind::NonClassTemplateArgument:
return true;
}
llvm_unreachable("unknown ConstantExprKind");
}
static bool isTemplateArgument(ConstantExprKind Kind) {
switch (Kind) {
case ConstantExprKind::Normal:
case ConstantExprKind::ImmediateInvocation:
return false;
case ConstantExprKind::ClassTemplateArgument:
case ConstantExprKind::NonClassTemplateArgument:
return true;
}
llvm_unreachable("unknown ConstantExprKind");
}
/// The bound to claim that an array of unknown bound has.
/// The value in MostDerivedArraySize is undefined in this case. So, set it
/// to an arbitrary value that's likely to loudly break things if it's used.
@ -2114,7 +2145,7 @@ using CheckedTemporaries =
static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
EvalInfo &Info, SourceLocation DiagLoc,
QualType Type, const APValue &Value,
Expr::ConstExprUsage Usage,
ConstantExprKind Kind,
SourceLocation SubobjectLoc,
CheckedTemporaries &CheckedTemps);
@ -2123,21 +2154,48 @@ static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
/// can fold this expression, whether or not it's a constant expression.
static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
QualType Type, const LValue &LVal,
Expr::ConstExprUsage Usage,
ConstantExprKind Kind,
CheckedTemporaries &CheckedTemps) {
bool IsReferenceType = Type->isReferenceType();
APValue::LValueBase Base = LVal.getLValueBase();
const SubobjectDesignator &Designator = LVal.getLValueDesignator();
if (auto *VD = LVal.getLValueBase().dyn_cast<const ValueDecl *>()) {
if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
if (FD->isConsteval()) {
Info.FFDiag(Loc, diag::note_consteval_address_accessible)
<< !Type->isAnyPointerType();
Info.Note(FD->getLocation(), diag::note_declared_at);
return false;
}
const Expr *BaseE = Base.dyn_cast<const Expr *>();
const ValueDecl *BaseVD = Base.dyn_cast<const ValueDecl*>();
// Additional restrictions apply in a template argument. We only enforce the
// C++20 restrictions here; additional syntactic and semantic restrictions
// are applied elsewhere.
if (isTemplateArgument(Kind)) {
int InvalidBaseKind = -1;
StringRef Ident;
if (Base.is<TypeInfoLValue>())
InvalidBaseKind = 0;
else if (isa_and_nonnull<StringLiteral>(BaseE))
InvalidBaseKind = 1;
else if (isa_and_nonnull<MaterializeTemporaryExpr>(BaseE) ||
isa_and_nonnull<LifetimeExtendedTemporaryDecl>(BaseVD))
InvalidBaseKind = 2;
else if (auto *PE = dyn_cast_or_null<PredefinedExpr>(BaseE)) {
InvalidBaseKind = 3;
Ident = PE->getIdentKindName();
}
if (InvalidBaseKind != -1) {
Info.FFDiag(Loc, diag::note_constexpr_invalid_template_arg)
<< IsReferenceType << !Designator.Entries.empty() << InvalidBaseKind
<< Ident;
return false;
}
}
if (auto *FD = dyn_cast_or_null<FunctionDecl>(BaseVD)) {
if (FD->isConsteval()) {
Info.FFDiag(Loc, diag::note_consteval_address_accessible)
<< !Type->isAnyPointerType();
Info.Note(FD->getLocation(), diag::note_declared_at);
return false;
}
}
@ -2181,19 +2239,20 @@ static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
return false;
}
if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
if (BaseVD) {
if (const VarDecl *Var = dyn_cast<const VarDecl>(BaseVD)) {
// Check if this is a thread-local variable.
if (Var->getTLSKind())
// FIXME: Diagnostic!
return false;
// A dllimport variable never acts like a constant.
if (Usage == Expr::EvaluateForCodeGen && Var->hasAttr<DLLImportAttr>())
// A dllimport variable never acts like a constant, unless we're
// evaluating a value for use only in name mangling.
if (!isForManglingOnly(Kind) && Var->hasAttr<DLLImportAttr>())
// FIXME: Diagnostic!
return false;
}
if (const auto *FD = dyn_cast<const FunctionDecl>(VD)) {
if (const auto *FD = dyn_cast<const FunctionDecl>(BaseVD)) {
// __declspec(dllimport) must be handled very carefully:
// We must never initialize an expression with the thunk in C++.
// Doing otherwise would allow the same id-expression to yield
@ -2204,13 +2263,13 @@ static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
// The C language has no notion of ODR; furthermore, it has no notion of
// dynamic initialization. This means that we are permitted to
// perform initialization with the address of the thunk.
if (Info.getLangOpts().CPlusPlus && Usage == Expr::EvaluateForCodeGen &&
if (Info.getLangOpts().CPlusPlus && !isForManglingOnly(Kind) &&
FD->hasAttr<DLLImportAttr>())
// FIXME: Diagnostic!
return false;
}
} else if (const auto *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>(
Base.dyn_cast<const Expr *>())) {
} else if (const auto *MTE =
dyn_cast_or_null<MaterializeTemporaryExpr>(BaseE)) {
if (CheckedTemps.insert(MTE).second) {
QualType TempType = getType(Base);
if (TempType.isDestructedType()) {
@ -2224,7 +2283,7 @@ static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
assert(V && "evasluation result refers to uninitialised temporary");
if (!CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
Info, MTE->getExprLoc(), TempType, *V,
Usage, SourceLocation(), CheckedTemps))
Kind, SourceLocation(), CheckedTemps))
return false;
}
}
@ -2243,9 +2302,8 @@ static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
// Does this refer one past the end of some object?
if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
<< !Designator.Entries.empty() << !!VD << VD;
<< !Designator.Entries.empty() << !!BaseVD << BaseVD;
NoteLValueLocation(Info, Base);
}
@ -2258,7 +2316,7 @@ static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
SourceLocation Loc,
QualType Type,
const APValue &Value,
Expr::ConstExprUsage Usage) {
ConstantExprKind Kind) {
const ValueDecl *Member = Value.getMemberPointerDecl();
const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
if (!FD)
@ -2268,7 +2326,7 @@ static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
Info.Note(FD->getLocation(), diag::note_declared_at);
return false;
}
return Usage == Expr::EvaluateForMangling || FD->isVirtual() ||
return isForManglingOnly(Kind) || FD->isVirtual() ||
!FD->hasAttr<DLLImportAttr>();
}
@ -2307,7 +2365,7 @@ static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
EvalInfo &Info, SourceLocation DiagLoc,
QualType Type, const APValue &Value,
Expr::ConstExprUsage Usage,
ConstantExprKind Kind,
SourceLocation SubobjectLoc,
CheckedTemporaries &CheckedTemps) {
if (!Value.hasValue()) {
@ -2330,20 +2388,20 @@ static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
if (!CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
Value.getArrayInitializedElt(I), Usage,
Value.getArrayInitializedElt(I), Kind,
SubobjectLoc, CheckedTemps))
return false;
}
if (!Value.hasArrayFiller())
return true;
return CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
Value.getArrayFiller(), Usage, SubobjectLoc,
Value.getArrayFiller(), Kind, SubobjectLoc,
CheckedTemps);
}
if (Value.isUnion() && Value.getUnionField()) {
return CheckEvaluationResult(
CERK, Info, DiagLoc, Value.getUnionField()->getType(),
Value.getUnionValue(), Usage, Value.getUnionField()->getLocation(),
Value.getUnionValue(), Kind, Value.getUnionField()->getLocation(),
CheckedTemps);
}
if (Value.isStruct()) {
@ -2352,7 +2410,7 @@ static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
unsigned BaseIndex = 0;
for (const CXXBaseSpecifier &BS : CD->bases()) {
if (!CheckEvaluationResult(CERK, Info, DiagLoc, BS.getType(),
Value.getStructBase(BaseIndex), Usage,
Value.getStructBase(BaseIndex), Kind,
BS.getBeginLoc(), CheckedTemps))
return false;
++BaseIndex;
@ -2364,7 +2422,7 @@ static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
if (!CheckEvaluationResult(CERK, Info, DiagLoc, I->getType(),
Value.getStructField(I->getFieldIndex()),
Usage, I->getLocation(), CheckedTemps))
Kind, I->getLocation(), CheckedTemps))
return false;
}
}
@ -2373,13 +2431,13 @@ static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
CERK == CheckEvaluationResultKind::ConstantExpression) {
LValue LVal;
LVal.setFrom(Info.Ctx, Value);
return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Usage,
return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Kind,
CheckedTemps);
}
if (Value.isMemberPointer() &&
CERK == CheckEvaluationResultKind::ConstantExpression)
return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Usage);
return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Kind);
// Everything else is fine.
return true;
@ -2388,17 +2446,16 @@ static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
/// Check that this core constant expression value is a valid value for a
/// constant expression. If not, report an appropriate diagnostic. Does not
/// check that the expression is of literal type.
static bool
CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type,
const APValue &Value,
Expr::ConstExprUsage Usage = Expr::EvaluateForCodeGen) {
static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc,
QualType Type, const APValue &Value,
ConstantExprKind Kind) {
// Nothing to check for a constant expression of type 'cv void'.
if (Type->isVoidType())
return true;
CheckedTemporaries CheckedTemps;
return CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
Info, DiagLoc, Type, Value, Usage,
Info, DiagLoc, Type, Value, Kind,
SourceLocation(), CheckedTemps);
}
@ -2409,7 +2466,7 @@ static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc,
CheckedTemporaries CheckedTemps;
return CheckEvaluationResult(
CheckEvaluationResultKind::FullyInitialized, Info, DiagLoc, Type, Value,
Expr::EvaluateForCodeGen, SourceLocation(), CheckedTemps);
ConstantExprKind::Normal, SourceLocation(), CheckedTemps);
}
/// Enforce C++2a [expr.const]/4.17, which disallows new-expressions unless
@ -3212,6 +3269,13 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
}
}
// If we're currently evaluating the initializer of this declaration, use that
// in-flight value.
if (Info.EvaluatingDecl == Base) {
Result = Info.EvaluatingDeclValue;
return true;
}
if (isa<ParmVarDecl>(VD)) {
// Assume parameters of a potential constant expression are usable in
// constant expressions.
@ -3261,14 +3325,6 @@ static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
return false;
}
// If we're currently evaluating the initializer of this declaration, use that
// in-flight value.
if (declaresSameEntity(Info.EvaluatingDecl.dyn_cast<const ValueDecl *>(),
VD)) {
Result = Info.EvaluatingDeclValue;
return true;
}
// 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()) {
@ -3470,26 +3526,20 @@ static bool lifetimeStartedInEvaluation(EvalInfo &Info,
if (Base.getCallIndex())
return true;
auto *Evaluating = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>();
if (!Evaluating)
return false;
auto *BaseD = Base.dyn_cast<const ValueDecl*>();
switch (Info.IsEvaluatingDecl) {
case EvalInfo::EvaluatingDeclKind::None:
return false;
case EvalInfo::EvaluatingDeclKind::Ctor:
// The variable whose initializer we're evaluating.
if (BaseD)
return declaresSameEntity(Evaluating, BaseD);
if (Info.EvaluatingDecl == Base)
return true;
// A temporary lifetime-extended by the variable whose initializer we're
// evaluating.
if (auto *BaseE = Base.dyn_cast<const Expr *>())
if (auto *BaseMTE = dyn_cast<MaterializeTemporaryExpr>(BaseE))
return declaresSameEntity(BaseMTE->getExtendingDecl(), Evaluating);
return Info.EvaluatingDecl == BaseMTE->getExtendingDecl();
return false;
case EvalInfo::EvaluatingDeclKind::Dtor:
@ -3497,16 +3547,13 @@ static bool lifetimeStartedInEvaluation(EvalInfo &Info,
// [during constant destruction] the lifetime of a and its non-mutable
// subobjects (but not its mutable subobjects) [are] considered to start
// within e.
//
if (MutableSubobject || Base != Info.EvaluatingDecl)
return false;
// FIXME: We can meaningfully extend this to cover non-const objects, but
// we will need special handling: we should be able to access only
// subobjects of such objects that are themselves declared const.
if (!BaseD ||
!(BaseD->getType().isConstQualified() ||
BaseD->getType()->isReferenceType()) ||
MutableSubobject)
return false;
return declaresSameEntity(Evaluating, BaseD);
QualType T = getType(Base);
return T.isConstQualified() || T->isReferenceType();
}
llvm_unreachable("unknown evaluating decl kind");
@ -3958,12 +4005,10 @@ static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
APValue *BaseVal = nullptr;
QualType BaseType = getType(LVal.Base);
if (const ConstantExpr *CE =
dyn_cast_or_null<ConstantExpr>(LVal.Base.dyn_cast<const Expr *>())) {
/// Nested immediate invocation have been previously removed so if we found
/// a ConstantExpr it can only be the EvaluatingDecl.
assert(CE->isImmediateInvocation() && CE == Info.EvaluatingDecl);
(void)CE;
if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl &&
lifetimeStartedInEvaluation(Info, LVal.Base)) {
// This is the object whose initializer we're evaluating, so its lifetime
// started in the current evaluation.
BaseVal = Info.EvaluatingDeclValue;
} else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {
// Allow reading from a GUID declaration.
@ -12736,7 +12781,8 @@ bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) {
LV.set(VD);
if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
return false;
return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result,
ConstantExprKind::Normal);
};
return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
return ExprEvaluatorBaseTy::VisitBinCmp(E);
@ -14506,7 +14552,8 @@ static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
}
// Check this core constant expression is a constant expression.
return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result) &&
return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result,
ConstantExprKind::Normal) &&
CheckMemoryLeaks(Info);
}
@ -14661,15 +14708,36 @@ bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
Result.HasSideEffects ||
!CheckLValueConstantExpression(Info, getExprLoc(),
Ctx.getLValueReferenceType(getType()), LV,
Expr::EvaluateForCodeGen, CheckedTemps))
ConstantExprKind::Normal, CheckedTemps))
return false;
LV.moveInto(Result.Val);
return true;
}
bool Expr::EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
const ASTContext &Ctx, bool InPlace) const {
static bool EvaluateDestruction(const ASTContext &Ctx, APValue::LValueBase Base,
APValue DestroyedValue, QualType Type,
SourceLocation Loc, Expr::EvalStatus &EStatus) {
EvalInfo Info(Ctx, EStatus, EvalInfo::EM_ConstantExpression);
Info.setEvaluatingDecl(Base, DestroyedValue,
EvalInfo::EvaluatingDeclKind::Dtor);
Info.InConstantContext = true;
LValue LVal;
LVal.set(Base);
if (!HandleDestruction(Info, Loc, Base, DestroyedValue, Type) ||
EStatus.HasSideEffects)
return false;
if (!Info.discardCleanups())
llvm_unreachable("Unhandled cleanup; missing full expression marker?");
return true;
}
bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
ConstantExprKind Kind) const {
assert(!isValueDependent() &&
"Expression evaluator can't be called on a dependent expression.");
@ -14677,22 +14745,44 @@ bool Expr::EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage,
EvalInfo Info(Ctx, Result, EM);
Info.InConstantContext = true;
if (InPlace) {
Info.setEvaluatingDecl(this, Result.Val);
LValue LVal;
LVal.set(this);
if (!::EvaluateInPlace(Result.Val, Info, LVal, this) ||
Result.HasSideEffects)
return false;
} else if (!::Evaluate(Result.Val, Info, this) || Result.HasSideEffects)
// The type of the object we're initializing is 'const T' for a class NTTP.
QualType T = getType();
if (Kind == ConstantExprKind::ClassTemplateArgument)
T.addConst();
// If we're evaluating a prvalue, fake up a MaterializeTemporaryExpr to
// represent the result of the evaluation. CheckConstantExpression ensures
// this doesn't escape.
MaterializeTemporaryExpr BaseMTE(T, const_cast<Expr*>(this), true);
APValue::LValueBase Base(&BaseMTE);
Info.setEvaluatingDecl(Base, Result.Val);
LValue LVal;
LVal.set(Base);
if (!::EvaluateInPlace(Result.Val, Info, LVal, this) || Result.HasSideEffects)
return false;
if (!Info.discardCleanups())
llvm_unreachable("Unhandled cleanup; missing full expression marker?");
return CheckConstantExpression(Info, getExprLoc(), getStorageType(Ctx, this),
Result.Val, Usage) &&
CheckMemoryLeaks(Info);
if (!CheckConstantExpression(Info, getExprLoc(), getStorageType(Ctx, this),
Result.Val, Kind))
return false;
if (!CheckMemoryLeaks(Info))
return false;
// If this is a class template argument, it's required to have constant
// destruction too.
if (Kind == ConstantExprKind::ClassTemplateArgument &&
(!EvaluateDestruction(Ctx, Base, Result.Val, T, getBeginLoc(), Result) ||
Result.HasSideEffects)) {
// FIXME: Prefix a note to indicate that the problem is lack of constant
// destruction.
return false;
}
return true;
}
bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx,
@ -14741,7 +14831,8 @@ bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx,
if (!Info.discardCleanups())
llvm_unreachable("Unhandled cleanup; missing full expression marker?");
}
return CheckConstantExpression(Info, DeclLoc, DeclTy, Value) &&
return CheckConstantExpression(Info, DeclLoc, DeclTy, Value,
ConstantExprKind::Normal) &&
CheckMemoryLeaks(Info);
}
@ -14759,24 +14850,11 @@ bool VarDecl::evaluateDestruction(
else if (!getDefaultInitValue(getType(), DestroyedValue))
return false;
EvalInfo Info(getASTContext(), EStatus, EvalInfo::EM_ConstantExpression);
Info.setEvaluatingDecl(this, DestroyedValue,
EvalInfo::EvaluatingDeclKind::Dtor);
Info.InConstantContext = true;
SourceLocation DeclLoc = getLocation();
QualType DeclTy = getType();
LValue LVal;
LVal.set(this);
if (!HandleDestruction(Info, DeclLoc, LVal.Base, DestroyedValue, DeclTy) ||
if (!EvaluateDestruction(getASTContext(), this, std::move(DestroyedValue),
getType(), getLocation(), EStatus) ||
EStatus.HasSideEffects)
return false;
if (!Info.discardCleanups())
llvm_unreachable("Unhandled cleanup; missing full expression marker?");
ensureEvaluatedStmt()->HasConstantDestruction = true;
return true;
}

6
clang/lib/Sema/SemaChecking.cpp
View File

@ -1814,8 +1814,7 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
SmallVector<PartialDiagnosticAt, 8> Notes;
Expr::EvalResult Eval;
Eval.Diag = &Notes;
if ((!ProbArg->EvaluateAsConstantExpr(Eval, Expr::EvaluateForCodeGen,
Context)) ||
if ((!ProbArg->EvaluateAsConstantExpr(Eval, Context)) ||
!Eval.Val.isFloat()) {
Diag(ProbArg->getBeginLoc(), diag::err_probability_not_constant_float)
<< ProbArg->getSourceRange();
@ -3295,8 +3294,7 @@ bool Sema::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID,
ArgExpr = Arg.get();
Expr::EvalResult ArgResult1;
// Check that sync scope is a constant literal
if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1, Expr::EvaluateForCodeGen,
Context))
if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1, Context))
return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
<< ArgExpr->getType();

4
clang/lib/Sema/SemaExpr.cpp
View File

@ -16224,8 +16224,8 @@ static void EvaluateAndDiagnoseImmediateInvocation(
Expr::EvalResult Eval;
Eval.Diag = &Notes;
ConstantExpr *CE = Candidate.getPointer();
bool Result = CE->EvaluateAsConstantExpr(Eval, Expr::EvaluateForCodeGen,
SemaRef.getASTContext(), true);
bool Result = CE->EvaluateAsConstantExpr(
Eval, SemaRef.getASTContext(), ConstantExprKind::ImmediateInvocation);
if (!Result || !Notes.empty()) {
Expr *InnerExpr = CE->getSubExpr()->IgnoreImplicit();
if (auto *FunctionalCast = dyn_cast<CXXFunctionalCastExpr>(InnerExpr))

22
clang/lib/Sema/SemaOverload.cpp
View File

@ -5703,11 +5703,16 @@ static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
SmallVector<PartialDiagnosticAt, 8> Notes;
Expr::EvalResult Eval;
Eval.Diag = &Notes;
Expr::ConstExprUsage Usage = CCE == Sema::CCEK_TemplateArg
? Expr::EvaluateForMangling
: Expr::EvaluateForCodeGen;
if (!Result.get()->EvaluateAsConstantExpr(Eval, Usage, S.Context) ||
ConstantExprKind Kind;
if (CCE == Sema::CCEK_TemplateArg && T->isRecordType())
Kind = ConstantExprKind::ClassTemplateArgument;
else if (CCE == Sema::CCEK_TemplateArg)
Kind = ConstantExprKind::NonClassTemplateArgument;
else
Kind = ConstantExprKind::Normal;
if (!Result.get()->EvaluateAsConstantExpr(Eval, S.Context, Kind) ||
(RequireInt && !Eval.Val.isInt())) {
// The expression can't be folded, so we can't keep it at this position in
// the AST.
@ -5726,9 +5731,14 @@ static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
// It's not a constant expression. Produce an appropriate diagnostic.
if (Notes.size() == 1 &&
Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
else {
} else if (!Notes.empty() && Notes[0].second.getDiagID() ==
diag::note_constexpr_invalid_template_arg) {
Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
for (unsigned I = 0; I < Notes.size(); ++I)
S.Diag(Notes[I].first, Notes[I].second);
} else {
S.Diag(From->getBeginLoc(), diag::err_expr_not_cce)
<< CCE << From->getSourceRange();
for (unsigned I = 0; I < Notes.size(); ++I)

21
clang/test/CXX/drs/dr1xx.cpp
View File

@ -4,10 +4,25 @@
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr100 { // dr100: yes
template<const char *> struct A {}; // expected-note 0-1{{declared here}}
template<const char (*)[4]> struct A {}; // expected-note 0-1{{declared here}}
template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}}
A<"foo"> a; // expected-error {{does not refer to any declaration}}
B<"bar"> b; // expected-error {{does not refer to any declaration}}
template<const char *> struct C {}; // expected-note 0-1{{declared here}}
template<const char &> struct D {}; // expected-note 0-1{{declared here}}
A<&"foo"> a; // #100a
B<"bar"> b; // #100b
C<"baz"> c; // #100c
D<*"quux"> d; // #100d
#if __cplusplus < 201703L
// expected-error@#100a {{does not refer to any declaration}}
// expected-error@#100b {{does not refer to any declaration}}
// expected-error@#100c {{does not refer to any declaration}}
// expected-error@#100d {{does not refer to any declaration}}
#else
// expected-error@#100a {{pointer to string literal is not allowed in a template argument}}
// expected-error@#100b {{reference to string literal is not allowed in a template argument}}
// expected-error@#100c {{pointer to subobject of string literal is not allowed in a template argument}}
// expected-error@#100d {{reference to subobject of string literal is not allowed in a template argument}}
#endif
}
namespace dr101 { // dr101: 3.5

39
clang/test/CXX/temp/temp.param/p8-cxx20.cpp
View File

@ -1,4 +1,4 @@
// RUN: %clang_cc1 -std=c++20 -verify %s
// RUN: %clang_cc1 -std=c++20 -fcxx-exceptions -verify %s
struct A { int n; };
@ -26,3 +26,40 @@ template<A2 a2> struct C2 {
static constexpr const A2 &v = a2;
};
static_assert((void*)&C<A{}>::v != (void*)&C2<A2{}>::v);
// A template parameter object shall have constant destruction.
namespace ConstDestruction {
struct D {
int n;
bool can_destroy;
constexpr ~D() {
if (!can_destroy)
throw "oh no"; // expected-note {{subexpression not valid}}
}
};
template<D d>
void f() {} // expected-note 2{{invalid explicitly-specified argument}}
void g() {
f<D{0, true}>();
f<D{0, false}>(); // expected-error {{no matching function}}
}
// We can SFINAE on constant destruction.
template<typename T> auto h(T t) -> decltype(f<T{1, false}>());
template<typename T> auto h(T t) -> decltype(f<T{1, true}>());
void i() {
h(D());
// Ensure we don't cache an invalid template argument after we've already
// seen it in a SFINAE context.
f<D{1, false}>(); // expected-error {{no matching function}}
f<D{1, true}>();
}
template<D d> struct Z {};
Z<D{2, true}> z1;
Z<D{2, false}> z2; // expected-error {{non-type template argument is not a constant expression}} expected-note-re {{in call to '{{.*}}->~D()'}}
}

24
clang/test/SemaTemplate/temp_arg_nontype_cxx1z.cpp
View File

@ -6,8 +6,8 @@ template<typename T, typename U> constexpr bool is_same = false; // expected-not
template<typename T> constexpr bool is_same<T, T> = true;
namespace String {
A<const char*, "test"> a; // expected-error {{does not refer to any declaration}}
A<const char (&)[5], "test"> b; // expected-error {{does not refer to any declaration}}
A<const char*, "test"> a; // expected-error {{pointer to subobject of string literal}}
A<const char (&)[5], "test"> b; // expected-error {{reference to string literal}}
}
namespace Array {
@ -50,7 +50,7 @@ namespace Function {
}
void Func() {
A<const char*, __func__> a; // expected-error {{does not refer to any declaration}}
A<const char*, __func__> a; // expected-error {{pointer to subobject of predefined '__func__' variable}}
}
namespace LabelAddrDiff {
@ -62,17 +62,17 @@ namespace LabelAddrDiff {
namespace Temp {
struct S { int n; };
constexpr S &addr(S &&s) { return s; }
A<S &, addr({})> a; // expected-error {{constant}} expected-note 2{{temporary}}
A<S *, &addr({})> b; // expected-error {{constant}} expected-note 2{{temporary}}
A<int &, addr({}).n> c; // expected-error {{constant}} expected-note 2{{temporary}}
A<int *, &addr({}).n> d; // expected-error {{constant}} expected-note 2{{temporary}}
A<S &, addr({})> a; // expected-error {{reference to temporary object}}
A<S *, &addr({})> b; // expected-error {{pointer to temporary object}}
A<int &, addr({}).n> c; // expected-error {{reference to subobject of temporary object}}
A<int *, &addr({}).n> d; // expected-error {{pointer to subobject of temporary object}}
}
namespace std { struct type_info; }
namespace RTTI {
A<const std::type_info&, typeid(int)> a; // expected-error {{does not refer to any declaration}}
A<const std::type_info*, &typeid(int)> b; // expected-error {{does not refer to any declaration}}
A<const std::type_info&, typeid(int)> a; // expected-error {{reference to type_info object}}
A<const std::type_info*, &typeid(int)> b; // expected-error {{pointer to type_info object}}
}
namespace PtrMem {
@ -442,10 +442,8 @@ namespace PR42108 {
template <const S &> struct A {};
void f() {
A<R{}>(); // expected-error {{would bind reference to a temporary}}
A<S{}>(); // expected-error {{non-type template argument is not a constant expression}} expected-note 2{{temporary}}
// FIXME: We could diagnose this better if we treated this as not binding
// directly. It's unclear whether that's the intent.
A<T{}>(); // expected-error {{non-type template argument is not a constant expression}} expected-note 2{{temporary}}
A<S{}>(); // expected-error {{reference to temporary object}}
A<T{}>(); // expected-error {{reference to temporary object}}
}
}

72
clang/test/SemaTemplate/temp_arg_nontype_cxx20.cpp
View File

@ -2,6 +2,10 @@
using size_t = __SIZE_TYPE__;
namespace std {
struct type_info;
}
// floating-point arguments
template<float> struct Float {};
using F1 = Float<1.0f>; // FIXME expected-error {{sorry}}
@ -220,3 +224,71 @@ namespace UnnamedBitfield {
// Once we support bit-casts involving bit-fields, this should be valid too.
using T = X<__builtin_bit_cast(A, 0)>; // expected-error {{constant}} expected-note {{not yet supported}}
}
namespace Temporary {
template<const int &> struct A {};
A<0> a0; // expected-error {{conversion from 'int' to 'const int &' in converted constant expression would bind reference to a temporary}}
A<(const int&)1> a1; // expected-error {{reference to temporary object is not allowed in a template argument}}
A<(int&&)2> a2; // expected-error {{reference to temporary object is not allowed in a template argument}}
// FIXME: There's really no good reason to reject these cases.
int &&r3 = 3;
const int &r4 = 4;
A<r3> a3; // expected-error {{reference to temporary object is not allowed in a template argument}}
A<r4> a4; // expected-error {{reference to temporary object is not allowed in a template argument}}
struct X { int a[5]; };
X &&x = X{};
A<x.a[3]> a5; // expected-error {{reference to subobject of temporary object}}
template<const int*> struct B {};
B<&(int&)(int&&)0> b0; // expected-error {{pointer to temporary object}}
B<&r3> b3; // expected-error {{pointer to temporary object}}
B<&x.a[3]> b5; // expected-error {{pointer to subobject of temporary object}}
struct C { const int *p[2]; };
template<C> struct D {};
D<C{nullptr, &r3}> d; // expected-error {{pointer to temporary object}}
}
namespace StringLiteral {
template<decltype(auto)> struct Y {};
Y<&"hello"> y1; // expected-error {{pointer to string literal}}
Y<"hello"> y2; // expected-error {{reference to string literal}}
Y<+"hello"> y3; // expected-error {{pointer to subobject of string literal}}
Y<"hello"[2]> y4; // expected-error {{reference to subobject of string literal}}
struct A { const char *p; };
struct B { const char &r; };
Y<A{"hello"}> y5; // expected-error {{pointer to subobject of string literal}}
Y<B{"hello"[2]}> y6; // expected-error {{reference to subobject of string literal}}
}
namespace TypeInfo {
template<decltype(auto)> struct Y {};
Y<&typeid(int)> y1; // expected-error {{pointer to type_info object}}
Y<typeid(int)> y2; // expected-error {{reference to type_info object}}
struct A { const std::type_info *p; };
struct B { const std::type_info &r; };
Y<A{&typeid(int)}> y3; // expected-error {{pointer to type_info object}}
Y<B{typeid(int)}> y4; // expected-error {{reference to type_info object}}
}
namespace Predefined {
template<decltype(auto)> struct Y {};
struct A { const char *p; };
struct B { const char &r; };
void f() {
// decltype(__func__) is an array, which decays to a pointer parameter.
Y<__func__>(); // expected-error {{pointer to subobject of predefined '__func__' variable}}
Y<__PRETTY_FUNCTION__>(); // expected-error {{pointer to subobject}}
Y<(__func__)>(); // expected-error {{reference to predefined '__func__' variable}}
Y<&__func__>(); // expected-error {{pointer to predefined '__func__' variable}}
Y<*&__func__>(); // expected-error {{reference to predefined '__func__' variable}}
Y<A{__func__}>(); // expected-error {{pointer to subobject of predefined '__func__' variable}}
Y<B{__func__[0]}>(); // expected-error {{reference to subobject of predefined '__func__' variable}}
}
}