Hi Richard, this makes clang assert when building chromium/win. https://bugs.chromium.org/p/chromium/issues/detail?id=1142009#c4 has a reduced repro. Could you take a look?
Thanks, Nico On Mon, Oct 19, 2020 at 10:04 PM Richard Smith via cfe-commits < cfe-commits@lists.llvm.org> wrote: > > Author: Richard Smith > Date: 2020-10-19T19:04:04-07:00 > New Revision: 76c0092665867a6defcd328ba0d0d976eb65d991 > > URL: > https://github.com/llvm/llvm-project/commit/76c0092665867a6defcd328ba0d0d976eb65d991 > DIFF: > https://github.com/llvm/llvm-project/commit/76c0092665867a6defcd328ba0d0d976eb65d991.diff > > LOG: Ensure that checkInitIsICE is called exactly once for every variable > for which it matters. > > This is a step towards separating checking for a constant initializer > (in which std::is_constant_evaluated returns true) and any other > evaluation of a variable initializer (in which it returns false). > > Added: > > > Modified: > clang/include/clang/AST/Decl.h > clang/include/clang/Serialization/ASTRecordWriter.h > clang/lib/AST/ComparisonCategories.cpp > clang/lib/AST/Decl.cpp > clang/lib/AST/ExprConstant.cpp > clang/lib/CodeGen/ItaniumCXXABI.cpp > clang/lib/Sema/SemaDecl.cpp > clang/lib/Sema/SemaDeclCXX.cpp > clang/lib/Serialization/ASTReaderDecl.cpp > clang/lib/Serialization/ASTWriter.cpp > clang/lib/Serialization/ASTWriterDecl.cpp > clang/test/CodeGen/enable_if.c > clang/test/OpenMP/threadprivate_codegen.cpp > clang/test/Sema/enable_if.c > clang/test/SemaCXX/constant-expression.cpp > clang/test/SemaCXX/i-c-e-cxx.cpp > > Removed: > > > > > ################################################################################ > diff --git a/clang/include/clang/AST/Decl.h > b/clang/include/clang/AST/Decl.h > index eae09832160d..e309819400f1 100644 > --- a/clang/include/clang/AST/Decl.h > +++ b/clang/include/clang/AST/Decl.h > @@ -807,10 +807,6 @@ struct EvaluatedStmt { > /// integral constant expression. > bool CheckedICE : 1; > > - /// Whether we are checking whether this statement is an > - /// integral constant expression. > - bool CheckingICE : 1; > - > /// Whether this statement is an integral constant expression, > /// or in C++11, whether the statement is a constant expression. Only > /// valid if CheckedICE is true. > @@ -828,7 +824,7 @@ struct EvaluatedStmt { > > EvaluatedStmt() > : WasEvaluated(false), IsEvaluating(false), CheckedICE(false), > - CheckingICE(false), IsICE(false), HasConstantDestruction(false) {} > + IsICE(false), HasConstantDestruction(false) {} > }; > > /// Represents a variable declaration or definition. > @@ -1263,14 +1259,15 @@ class VarDecl : public DeclaratorDecl, public > Redeclarable<VarDecl> { > /// constant expression, according to the relevant language standard. > /// This only checks properties of the declaration, and does not check > /// whether the initializer is in fact a constant expression. > - bool mightBeUsableInConstantExpressions(ASTContext &C) const; > + bool mightBeUsableInConstantExpressions(const ASTContext &C) const; > > /// Determine whether this variable's value can be used in a > /// constant expression, according to the relevant language standard, > /// including checking whether it was initialized by a constant > expression. > - bool isUsableInConstantExpressions(ASTContext &C) const; > + bool isUsableInConstantExpressions(const ASTContext &C) const; > > EvaluatedStmt *ensureEvaluatedStmt() const; > + EvaluatedStmt *getEvaluatedStmt() const; > > /// Attempt to evaluate the value of the initializer attached to this > /// declaration, and produce notes explaining why it cannot be > evaluated or is > @@ -1305,7 +1302,7 @@ class VarDecl : public DeclaratorDecl, public > Redeclarable<VarDecl> { > > /// Determine whether the value of the initializer attached to this > /// declaration is an integral constant expression. > - bool checkInitIsICE() const; > + bool checkInitIsICE(SmallVectorImpl<PartialDiagnosticAt> &Notes) const; > > void setInitStyle(InitializationStyle Style) { > VarDeclBits.InitStyle = Style; > > diff --git a/clang/include/clang/Serialization/ASTRecordWriter.h > b/clang/include/clang/Serialization/ASTRecordWriter.h > index edfcd9c52e2e..e362463b2309 100644 > --- a/clang/include/clang/Serialization/ASTRecordWriter.h > +++ b/clang/include/clang/Serialization/ASTRecordWriter.h > @@ -266,6 +266,9 @@ class ASTRecordWriter > > void AddCXXDefinitionData(const CXXRecordDecl *D); > > + /// Emit information about the initializer of a VarDecl. > + void AddVarDeclInit(const VarDecl *VD); > + > /// Write an OMPTraitInfo object. > void writeOMPTraitInfo(const OMPTraitInfo *TI); > > > diff --git a/clang/lib/AST/ComparisonCategories.cpp > b/clang/lib/AST/ComparisonCategories.cpp > index 6b6826c02a12..896050482644 100644 > --- a/clang/lib/AST/ComparisonCategories.cpp > +++ b/clang/lib/AST/ComparisonCategories.cpp > @@ -42,7 +42,7 @@ clang::getComparisonCategoryForBuiltinCmp(QualType T) { > > bool ComparisonCategoryInfo::ValueInfo::hasValidIntValue() const { > assert(VD && "must have var decl"); > - if (!VD->checkInitIsICE()) > + if (!VD->isUsableInConstantExpressions(VD->getASTContext())) > return false; > > // Before we attempt to get the value of the first field, ensure that we > > diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp > index a6c7f30528eb..ee7f51c5218e 100644 > --- a/clang/lib/AST/Decl.cpp > +++ b/clang/lib/AST/Decl.cpp > @@ -2277,7 +2277,7 @@ void VarDecl::setInit(Expr *I) { > Init = I; > } > > -bool VarDecl::mightBeUsableInConstantExpressions(ASTContext &C) const { > +bool VarDecl::mightBeUsableInConstantExpressions(const ASTContext &C) > const { > const LangOptions &Lang = C.getLangOpts(); > > if (!Lang.CPlusPlus) > @@ -2312,7 +2312,7 @@ bool > VarDecl::mightBeUsableInConstantExpressions(ASTContext &C) const { > return Lang.CPlusPlus11 && isConstexpr(); > } > > -bool VarDecl::isUsableInConstantExpressions(ASTContext &Context) const { > +bool VarDecl::isUsableInConstantExpressions(const ASTContext &Context) > const { > // C++2a [expr.const]p3: > // A variable is usable in constant expressions after its initializing > // declaration is encountered... > @@ -2325,7 +2325,7 @@ bool > VarDecl::isUsableInConstantExpressions(ASTContext &Context) const { > if (!DefVD->mightBeUsableInConstantExpressions(Context)) > return false; > // ... and its initializer is a constant initializer. > - return DefVD->checkInitIsICE(); > + return DefVD->isInitKnownICE() && DefVD->isInitICE(); > } > > /// Convert the initializer for this declaration to the elaborated > EvaluatedStmt > @@ -2345,6 +2345,10 @@ EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const > { > return Eval; > } > > +EvaluatedStmt *VarDecl::getEvaluatedStmt() const { > + return Init.dyn_cast<EvaluatedStmt *>(); > +} > + > APValue *VarDecl::evaluateValue() const { > SmallVector<PartialDiagnosticAt, 8> Notes; > return evaluateValue(Notes); > @@ -2354,19 +2358,17 @@ APValue *VarDecl::evaluateValue( > SmallVectorImpl<PartialDiagnosticAt> &Notes) const { > EvaluatedStmt *Eval = ensureEvaluatedStmt(); > > + const auto *Init = cast<Expr>(Eval->Value); > + assert(!Init->isValueDependent()); > + > // We only produce notes indicating why an initializer is non-constant > the > // first time it is evaluated. FIXME: The notes won't always be emitted > the > // first time we try evaluation, so might not be produced at all. > if (Eval->WasEvaluated) > return Eval->Evaluated.isAbsent() ? nullptr : &Eval->Evaluated; > > - const auto *Init = cast<Expr>(Eval->Value); > - assert(!Init->isValueDependent()); > - > if (Eval->IsEvaluating) { > // FIXME: Produce a diagnostic for self-initialization. > - Eval->CheckedICE = true; > - Eval->IsICE = false; > return nullptr; > } > > @@ -2386,18 +2388,11 @@ APValue *VarDecl::evaluateValue( > Eval->IsEvaluating = false; > Eval->WasEvaluated = true; > > - // In C++11, we have determined whether the initializer was a constant > - // expression as a side-effect. > - if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) { > - Eval->CheckedICE = true; > - Eval->IsICE = Result && Notes.empty(); > - } > - > return Result ? &Eval->Evaluated : nullptr; > } > > APValue *VarDecl::getEvaluatedValue() const { > - if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) > + if (EvaluatedStmt *Eval = getEvaluatedStmt()) > if (Eval->WasEvaluated) > return &Eval->Evaluated; > > @@ -2405,7 +2400,7 @@ APValue *VarDecl::getEvaluatedValue() const { > } > > bool VarDecl::isInitKnownICE() const { > - if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) > + if (EvaluatedStmt *Eval = getEvaluatedStmt()) > return Eval->CheckedICE; > > return false; > @@ -2417,12 +2412,16 @@ bool VarDecl::isInitICE() const { > return Init.get<EvaluatedStmt *>()->IsICE; > } > > -bool VarDecl::checkInitIsICE() const { > +bool VarDecl::checkInitIsICE( > + SmallVectorImpl<PartialDiagnosticAt> &Notes) const { > EvaluatedStmt *Eval = ensureEvaluatedStmt(); > - if (Eval->CheckedICE) > - // We have already checked whether this subexpression is an > - // integral constant expression. > - return Eval->IsICE; > + assert(!Eval->CheckedICE && > + "should check whether var has constant init at most once"); > + // If we ask for the value before we know whether we have a constant > + // initializer, we can compute the wrong value (for example, due to > + // std::is_constant_evaluated()). > + assert(!Eval->WasEvaluated && > + "already evaluated var value before checking for constant init"); > > const auto *Init = cast<Expr>(Eval->Value); > assert(!Init->isValueDependent()); > @@ -2430,8 +2429,8 @@ bool VarDecl::checkInitIsICE() const { > // In C++11, evaluate the initializer to check whether it's a constant > // expression. > if (getASTContext().getLangOpts().CPlusPlus11) { > - SmallVector<PartialDiagnosticAt, 8> Notes; > - evaluateValue(Notes); > + Eval->IsICE = evaluateValue(Notes) && Notes.empty(); > + Eval->CheckedICE = true; > return Eval->IsICE; > } > > @@ -2439,12 +2438,8 @@ bool VarDecl::checkInitIsICE() const { > // out-of-line. See DR 721 and the discussion in Clang PR > // 6206 for details. > > - if (Eval->CheckingICE) > - return false; > - Eval->CheckingICE = true; > - > - Eval->IsICE = Init->isIntegerConstantExpr(getASTContext()); > - Eval->CheckingICE = false; > + Eval->IsICE = getType()->isIntegralOrEnumerationType() && > + Init->isIntegerConstantExpr(getASTContext()); > Eval->CheckedICE = true; > return Eval->IsICE; > } > @@ -2599,7 +2594,7 @@ bool VarDecl::isNoDestroy(const ASTContext &Ctx) > const { > > QualType::DestructionKind > VarDecl::needsDestruction(const ASTContext &Ctx) const { > - if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) > + if (EvaluatedStmt *Eval = getEvaluatedStmt()) > if (Eval->HasConstantDestruction) > return QualType::DK_none; > > > diff --git a/clang/lib/AST/ExprConstant.cpp > b/clang/lib/AST/ExprConstant.cpp > index 7afc44dffffe..3014f948f9b1 100644 > --- a/clang/lib/AST/ExprConstant.cpp > +++ b/clang/lib/AST/ExprConstant.cpp > @@ -3278,12 +3278,17 @@ static bool evaluateVarDeclInit(EvalInfo &Info, > const Expr *E, > return false; > } > > - // Check that the variable is actually usable in constant expressions. > - if (!VD->checkInitIsICE()) { > - Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant, > - Notes.size() + 1) << VD; > + // Check that the variable is actually usable in constant expressions. > For a > + // const integral variable or a reference, we might have a non-constant > + // initializer that we can nonetheless evaluate the initializer for. > Such > + // variables are not usable in constant expressions. > + // > + // FIXME: It would be cleaner to check VD->isUsableInConstantExpressions > + // here, but that regresses diagnostics for things like reading from a > + // volatile constexpr variable. > + if (VD->isInitKnownICE() && !VD->isInitICE()) { > + Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant, 1) << VD; > NoteLValueLocation(Info, Base); > - Info.addNotes(Notes); > } > > // Never use the initializer of a weak variable, not even for constant > @@ -3298,11 +3303,6 @@ static bool evaluateVarDeclInit(EvalInfo &Info, > const Expr *E, > return true; > } > > -static bool IsConstNonVolatile(QualType T) { > - Qualifiers Quals = T.getQualifiers(); > - return Quals.hasConst() && !Quals.hasVolatile(); > -} > - > /// Get the base index of the given base class within an APValue > representing > /// the given derived class. > static unsigned getBaseIndex(const CXXRecordDecl *Derived, > @@ -8114,6 +8114,12 @@ bool LValueExprEvaluator::VisitVarDecl(const Expr > *E, const VarDecl *VD) { > return Success(VD); > } > > + if (!Info.getLangOpts().CPlusPlus11) { > + Info.CCEDiag(E, diag::note_constexpr_ltor_non_integral, 1) > + << VD << VD->getType(); > + Info.Note(VD->getLocation(), diag::note_declared_at); > + } > + > APValue *V; > if (!evaluateVarDeclInit(Info, E, VD, Frame, Version, V)) > return false; > @@ -15030,30 +15036,12 @@ static ICEDiag CheckICE(const Expr* E, const > ASTContext &Ctx) { > case Expr::DeclRefExprClass: { > if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) > return NoDiag(); > - const ValueDecl *D = cast<DeclRefExpr>(E)->getDecl(); > - if (Ctx.getLangOpts().CPlusPlus && > - D && IsConstNonVolatile(D->getType())) { > - // Parameter variables are never constants. Without this check, > - // getAnyInitializer() can find a default argument, which leads > - // to chaos. > - if (isa<ParmVarDecl>(D)) > - return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); > - > + const VarDecl *VD = > dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl()); > + if (VD && VD->isUsableInConstantExpressions(Ctx)) { > // C++ 7.1.5.1p2 > // A variable of non-volatile const-qualified integral or > enumeration > // type initialized by an ICE can be used in ICEs. > - if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) { > - if (!Dcl->getType()->isIntegralOrEnumerationType()) > - return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); > - > - const VarDecl *VD; > - // Look for a declaration of this variable that has an > initializer, and > - // check whether it is an ICE. > - if (Dcl->getAnyInitializer(VD) && !VD->isWeak() && > VD->checkInitIsICE()) > - return NoDiag(); > - else > - return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); > - } > + return NoDiag(); > } > return ICEDiag(IK_NotICE, E->getBeginLoc()); > } > > diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp > b/clang/lib/CodeGen/ItaniumCXXABI.cpp > index cfb736ce0ff1..40cd5c54185f 100644 > --- a/clang/lib/CodeGen/ItaniumCXXABI.cpp > +++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp > @@ -361,8 +361,9 @@ class ItaniumCXXABI : public CodeGen::CGCXXABI { > return !VD->needsDestruction(getContext()) && > InitDecl->evaluateValue(); > > // Otherwise, we need a thread wrapper unless we know that every > - // translation unit will emit the value as a constant. We rely on > - // ICE-ness not varying between translation units, which isn't > actually > + // translation unit will emit the value as a constant. We rely on the > + // variable being constant-initialized in every translation unit if > it's > + // constant-initialized in any translation unit, which isn't actually > // guaranteed by the standard but is necessary for sanity. > return InitDecl->isInitKnownICE() && InitDecl->isInitICE(); > } > > diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp > index 481b48e21942..1a27667fc106 100644 > --- a/clang/lib/Sema/SemaDecl.cpp > +++ b/clang/lib/Sema/SemaDecl.cpp > @@ -12958,18 +12958,14 @@ void > Sema::CheckCompleteVariableDeclaration(VarDecl *var) { > > // All the following checks are C++ only. > if (!getLangOpts().CPlusPlus) { > - // If this variable must be emitted, add it as an initializer for > the > - // current module. > - if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty()) > - Context.addModuleInitializer(ModuleScopes.back().Module, var); > - return; > + // If this variable must be emitted, add it as an initializer for the > + // current module. > + if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty()) > + Context.addModuleInitializer(ModuleScopes.back().Module, var); > + return; > } > > - if (auto *DD = dyn_cast<DecompositionDecl>(var)) > - CheckCompleteDecompositionDeclaration(DD); > - > QualType type = var->getType(); > - if (type->isDependentType()) return; > > if (var->hasAttr<BlocksAttr>()) > getCurFunction()->addByrefBlockVar(var); > @@ -12978,79 +12974,86 @@ void > Sema::CheckCompleteVariableDeclaration(VarDecl *var) { > bool IsGlobal = GlobalStorage && !var->isStaticLocal(); > QualType baseType = Context.getBaseElementType(type); > > - if (Init && !Init->isValueDependent()) { > - if (var->isConstexpr()) { > - SmallVector<PartialDiagnosticAt, 8> Notes; > - if (!var->evaluateValue(Notes) || !var->isInitICE()) { > - SourceLocation DiagLoc = var->getLocation(); > - // If the note doesn't add any useful information other than a > source > - // location, fold it into the primary diagnostic. > - if (Notes.size() == 1 && Notes[0].second.getDiagID() == > - diag::note_invalid_subexpr_in_const_expr) { > - DiagLoc = Notes[0].first; > - Notes.clear(); > - } > - Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) > - << var << Init->getSourceRange(); > - for (unsigned I = 0, N = Notes.size(); I != N; ++I) > - Diag(Notes[I].first, Notes[I].second); > - } > - } else if (var->mightBeUsableInConstantExpressions(Context)) { > - // Check whether the initializer of a const variable of integral or > - // enumeration type is an ICE now, since we can't tell whether it > was > - // initialized by a constant expression if we check later. > - var->checkInitIsICE(); > - } > - > - // Don't emit further diagnostics about constexpr globals since they > - // were just diagnosed. > - if (!var->isConstexpr() && GlobalStorage && > var->hasAttr<ConstInitAttr>()) { > - // FIXME: Need strict checking in C++03 here. > - bool DiagErr = getLangOpts().CPlusPlus11 > - ? !var->checkInitIsICE() : !checkConstInit(); > - if (DiagErr) { > - auto *Attr = var->getAttr<ConstInitAttr>(); > - Diag(var->getLocation(), diag::err_require_constant_init_failed) > - << Init->getSourceRange(); > - Diag(Attr->getLocation(), > - diag::note_declared_required_constant_init_here) > - << Attr->getRange() << Attr->isConstinit(); > - if (getLangOpts().CPlusPlus11) { > - APValue Value; > - SmallVector<PartialDiagnosticAt, 8> Notes; > - Init->EvaluateAsInitializer(Value, getASTContext(), var, Notes); > - for (auto &it : Notes) > - Diag(it.first, it.second); > - } else { > - Diag(CacheCulprit->getExprLoc(), > - diag::note_invalid_subexpr_in_const_expr) > - << CacheCulprit->getSourceRange(); > - } > + // Check whether the initializer is sufficiently constant. > + if (!type->isDependentType() && Init && !Init->isValueDependent() && > + (GlobalStorage || var->isConstexpr() || > + var->mightBeUsableInConstantExpressions(Context))) { > + // If this variable might have a constant initializer or might be > usable in > + // constant expressions, check whether or not it actually is now. We > can't > + // do this lazily, because the result might depend on things that > change > + // later, such as which constexpr functions happen to be defined. > + SmallVector<PartialDiagnosticAt, 8> Notes; > + bool HasConstInit = var->checkInitIsICE(Notes); > + > + // Prior to C++11, in contexts where a constant initializer is > required, > + // additional kinds of constant expression are permitted beyond ICEs, > as > + // described in [expr.const]p2-6. > + // FIXME: Stricter checking for these rules would be useful for > constinit / > + // -Wglobal-constructors. > + if (!getLangOpts().CPlusPlus11 && !HasConstInit) { > + HasConstInit = checkConstInit(); > + Notes.clear(); > + if (CacheCulprit) { > + Notes.emplace_back(CacheCulprit->getExprLoc(), > + > PDiag(diag::note_invalid_subexpr_in_const_expr)); > + Notes.back().second << CacheCulprit->getSourceRange(); > } > } > - else if (!var->isConstexpr() && IsGlobal && > - !getDiagnostics().isIgnored(diag::warn_global_constructor, > - var->getLocation())) { > + > + if (HasConstInit) { > + // FIXME: Consider replacing the initializer with a ConstantExpr. > + } else if (var->isConstexpr()) { > + SourceLocation DiagLoc = var->getLocation(); > + // If the note doesn't add any useful information other than a > source > + // location, fold it into the primary diagnostic. > + if (Notes.size() == 1 && Notes[0].second.getDiagID() == > + > diag::note_invalid_subexpr_in_const_expr) { > + DiagLoc = Notes[0].first; > + Notes.clear(); > + } > + Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) > + << var << Init->getSourceRange(); > + for (unsigned I = 0, N = Notes.size(); I != N; ++I) > + Diag(Notes[I].first, Notes[I].second); > + } else if (GlobalStorage && var->hasAttr<ConstInitAttr>()) { > + auto *Attr = var->getAttr<ConstInitAttr>(); > + Diag(var->getLocation(), diag::err_require_constant_init_failed) > + << Init->getSourceRange(); > + Diag(Attr->getLocation(), > diag::note_declared_required_constant_init_here) > + << Attr->getRange() << Attr->isConstinit(); > + for (auto &it : Notes) > + Diag(it.first, it.second); > + } else if (IsGlobal && > + !getDiagnostics().isIgnored(diag::warn_global_constructor, > + var->getLocation())) { > // Warn about globals which don't have a constant initializer. > Don't > // warn about globals with a non-trivial destructor because we > already > // warned about them. > CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); > if (!(RD && !RD->hasTrivialDestructor())) { > + // checkConstInit() here permits trivial default initialization > even in > + // C++11 onwards, where such an initializer is not a constant > initializer > + // but nonetheless doesn't require a global constructor. > if (!checkConstInit()) > Diag(var->getLocation(), diag::warn_global_constructor) > - << Init->getSourceRange(); > + << Init->getSourceRange(); > } > } > } > > // Require the destructor. > - if (const RecordType *recordType = baseType->getAs<RecordType>()) > - FinalizeVarWithDestructor(var, recordType); > + if (!type->isDependentType()) > + if (const RecordType *recordType = baseType->getAs<RecordType>()) > + FinalizeVarWithDestructor(var, recordType); > > // If this variable must be emitted, add it as an initializer for the > current > // module. > if (Context.DeclMustBeEmitted(var) && !ModuleScopes.empty()) > Context.addModuleInitializer(ModuleScopes.back().Module, var); > + > + // Build the bindings if this is a structured binding declaration. > + if (auto *DD = dyn_cast<DecompositionDecl>(var)) > + CheckCompleteDecompositionDeclaration(DD); > } > > /// Determines if a variable's alignment is dependent. > > diff --git a/clang/lib/Sema/SemaDeclCXX.cpp > b/clang/lib/Sema/SemaDeclCXX.cpp > index cbcaf3cc4360..72dfa37c321e 100644 > --- a/clang/lib/Sema/SemaDeclCXX.cpp > +++ b/clang/lib/Sema/SemaDeclCXX.cpp > @@ -1250,8 +1250,7 @@ static bool checkTupleLikeDecomposition(Sema &S, > if (E.isInvalid()) > return true; > RefVD->setInit(E.get()); > - if (!E.get()->isValueDependent()) > - RefVD->checkInitIsICE(); > + S.CheckCompleteVariableDeclaration(RefVD); > > E = S.BuildDeclarationNameExpr(CXXScopeSpec(), > DeclarationNameInfo(B->getDeclName(), > Loc), > @@ -11113,8 +11112,8 @@ QualType > Sema::CheckComparisonCategoryType(ComparisonCategoryType Kind, > // Attempt to diagnose reasons why the STL definition of this type > // might be foobar, including it failing to be a constant expression. > // TODO Handle more ways the lookup or result can be invalid. > - if (!VD->isStaticDataMember() || !VD->isConstexpr() || !VD->hasInit() > || > - VD->isWeak() || !VD->checkInitIsICE()) > + if (!VD->isStaticDataMember() || > + !VD->isUsableInConstantExpressions(Context)) > return UnsupportedSTLError(USS_InvalidMember, MemName, VD); > > // Attempt to evaluate the var decl as a constant expression and > extract > > diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp > b/clang/lib/Serialization/ASTReaderDecl.cpp > index f5a66dc3c2d1..41f2db1ef5f0 100644 > --- a/clang/lib/Serialization/ASTReaderDecl.cpp > +++ b/clang/lib/Serialization/ASTReaderDecl.cpp > @@ -1425,8 +1425,8 @@ ASTDeclReader::RedeclarableResult > ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) { > VD->setInit(Record.readExpr()); > if (Val > 1) { > EvaluatedStmt *Eval = VD->ensureEvaluatedStmt(); > - Eval->CheckedICE = true; > - Eval->IsICE = (Val & 1) != 0; > + Eval->CheckedICE = (Val & 2) != 0; > + Eval->IsICE = (Val & 3) == 3; > Eval->HasConstantDestruction = (Val & 4) != 0; > } > } > @@ -4438,10 +4438,11 @@ void ASTDeclReader::UpdateDecl(Decl *D, > uint64_t Val = Record.readInt(); > if (Val && !VD->getInit()) { > VD->setInit(Record.readExpr()); > - if (Val > 1) { // IsInitKnownICE = 1, IsInitNotICE = 2, IsInitICE > = 3 > + if (Val != 1) { > EvaluatedStmt *Eval = VD->ensureEvaluatedStmt(); > - Eval->CheckedICE = true; > - Eval->IsICE = Val == 3; > + Eval->CheckedICE = (Val & 2) != 0; > + Eval->IsICE = (Val & 3) == 3; > + Eval->HasConstantDestruction = (Val & 4) != 0; > } > } > break; > > diff --git a/clang/lib/Serialization/ASTWriter.cpp > b/clang/lib/Serialization/ASTWriter.cpp > index e793e619381b..6056ed623c69 100644 > --- a/clang/lib/Serialization/ASTWriter.cpp > +++ b/clang/lib/Serialization/ASTWriter.cpp > @@ -4980,13 +4980,7 @@ void > ASTWriter::WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord) { > const VarDecl *VD = cast<VarDecl>(D); > Record.push_back(VD->isInline()); > Record.push_back(VD->isInlineSpecified()); > - if (VD->getInit()) { > - Record.push_back(!VD->isInitKnownICE() ? 1 > - : (VD->isInitICE() ? 3 : > 2)); > - Record.AddStmt(const_cast<Expr*>(VD->getInit())); > - } else { > - Record.push_back(0); > - } > + Record.AddVarDeclInit(VD); > break; > } > > @@ -5746,6 +5740,27 @@ void ASTRecordWriter::AddCXXDefinitionData(const > CXXRecordDecl *D) { > } > } > > +void ASTRecordWriter::AddVarDeclInit(const VarDecl *VD) { > + const Expr *Init = VD->getInit(); > + if (!Init) { > + push_back(0); > + return; > + } > + > + // Bottom two bits are as follows: > + // 01 -- initializer not checked for ICE > + // 10 -- initializer not ICE > + // 11 -- initializer ICE > + unsigned Val = 1; > + if (EvaluatedStmt *ES = VD->getEvaluatedStmt()) { > + if (ES->CheckedICE) > + Val = 2 | ES->IsICE; > + Val |= (ES->HasConstantDestruction ? 4 : 0); > + } > + push_back(Val); > + writeStmtRef(Init); > +} > + > void ASTWriter::ReaderInitialized(ASTReader *Reader) { > assert(Reader && "Cannot remove chain"); > assert((!Chain || Chain == Reader) && "Cannot replace chain"); > > diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp > b/clang/lib/Serialization/ASTWriterDecl.cpp > index 911fcb409547..8778f0c02671 100644 > --- a/clang/lib/Serialization/ASTWriterDecl.cpp > +++ b/clang/lib/Serialization/ASTWriterDecl.cpp > @@ -1000,19 +1000,7 @@ void ASTDeclWriter::VisitVarDecl(VarDecl *D) { > } > Record.push_back(D->getLinkageInternal()); > > - if (D->getInit()) { > - if (!D->isInitKnownICE()) > - Record.push_back(1); > - else { > - Record.push_back( > - 2 | > - (D->isInitICE() ? 1 : 0) | > - (D->ensureEvaluatedStmt()->HasConstantDestruction ? 4 : 0)); > - } > - Record.AddStmt(D->getInit()); > - } else { > - Record.push_back(0); > - } > + Record.AddVarDeclInit(D); > > if (D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) { > BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D); > > diff --git a/clang/test/CodeGen/enable_if.c > b/clang/test/CodeGen/enable_if.c > index 5e9f904fdd3f..1d830ae68f54 100644 > --- a/clang/test/CodeGen/enable_if.c > +++ b/clang/test/CodeGen/enable_if.c > @@ -65,19 +65,19 @@ void test3() { > } > > > -const int TRUEFACTS = 1; > +enum { TRUEFACTS = 1 }; > void qux(int m) __attribute__((overloadable, enable_if(1, ""), > enable_if(TRUEFACTS, ""))); > void qux(int m) __attribute__((overloadable, enable_if(1, ""))); > // CHECK-LABEL: define void @test4 > void test4() { > - // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXL_Z9TRUEFACTSEEEi > + // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXLi1EEEi > void (*p)(int) = qux; > - // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXL_Z9TRUEFACTSEEEi > + // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXLi1EEEi > void (*p2)(int) = &qux; > - // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXL_Z9TRUEFACTSEEEi > + // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXLi1EEEi > p = qux; > - // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXL_Z9TRUEFACTSEEEi > + // CHECK: store void (i32)* @_Z3quxUa9enable_ifIXLi1EEXLi1EEEi > p = &qux; > } > > > diff --git a/clang/test/OpenMP/threadprivate_codegen.cpp > b/clang/test/OpenMP/threadprivate_codegen.cpp > index a46bb6907015..2ef6522760ab 100644 > --- a/clang/test/OpenMP/threadprivate_codegen.cpp > +++ b/clang/test/OpenMP/threadprivate_codegen.cpp > @@ -598,8 +598,8 @@ int main() { > // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]], [[INT]]* [[RES_ADDR]] > // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], > [[ST_INT_ST_VAL]] > // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] > - // CHECK-TLS: [[ST_INT_ST_ADDR:%.*]] = call i32* > [[ST_INT_ST_TLS_INITD:[^,]+]] > - // CHECK-TLS-NEXT: [[ST_INT_ST_VAL:%.*]] = load i32, i32* > [[ST_INT_ST_ADDR]] > + // > + // CHECK-TLS: [[ST_INT_ST_VAL:%.*]] = load i32, i32* > [[ST_INT_ST_ADDR:[^,]+]] > // CHECK-TLS-NEXT: [[RES:%.*]] = load i32, i32* [[RES_ADDR]] > // CHECK-TLS-NEXT: [[ADD:%.*]] = add {{.*}} i32 [[RES]], > [[ST_INT_ST_VAL]] > // CHECK-TLS-NEXT: store i32 [[ADD]], i32* [[RES_ADDR]] > @@ -620,8 +620,8 @@ int main() { > // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]], [[INT]]* [[RES_ADDR]] > // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], > [[FLOAT_TO_INT_CONV]] > // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] > - // CHECK-TLS: [[ST_FLOAT_ST_ADDR:%.*]] = call float* > [[ST_FLOAT_ST_TLS_INITD:[^,]+]] > - // CHECK-TLS-NEXT: [[ST_FLOAT_ST_VAL:%.*]] = load float, float* > [[ST_FLOAT_ST_ADDR]] > + // > + // CHECK-TLS: [[ST_FLOAT_ST_VAL:%.*]] = load float, float* > [[ST_FLOAT_ST_ADDR:[^,]+]] > // CHECK-TLS-NEXT: [[FLOAT_TO_INT_CONV:%.*]] = fptosi float > [[ST_FLOAT_ST_VAL]] to i32 > // CHECK-TLS-NEXT: [[RES:%.*]] = load i32, i32* [[RES_ADDR]] > // CHECK-TLS-NEXT: [[ADD:%.*]] = add {{.*}} i32 [[RES]], > [[FLOAT_TO_INT_CONV]] > @@ -727,14 +727,14 @@ int main() { > // CHECK-TLS: call void [[ARR_X_TLS_INIT]] > // CHECK-TLS: ret [2 x [3 x [[S1]]]]* [[ARR_X]] > // CHECK-TLS: } > -// CHECK-TLS: define {{.*}} i32* [[ST_INT_ST_TLS_INITD]] {{#[0-9]+}} > comdat { > -// CHECK-TLS-NOT: call > -// CHECK-TLS: ret i32* [[ST_INT_ST]] > -// CHECK-TLS: } > -// CHECK-TLS: define {{.*}} float* [[ST_FLOAT_ST_TLS_INITD]] {{#[0-9]+}} > comdat { > -// CHECK-TLS-NOT: call > -// CHECK-TLS: ret float* [[ST_FLOAT_ST]] > -// CHECK-TLS: } > +// > +// > +// > +// > +// > +// > +// > +// > // CHECK-TLS: define {{.*}} [[S4]]* [[ST_S4_ST_TLS_INITD]] {{#[0-9]+}} > comdat { > // CHECK-TLS: call void [[ST_S4_ST_TLS_INIT]] > // CHECK-TLS: ret [[S4]]* [[ST_S4_ST]] > @@ -874,8 +874,8 @@ int foobar() { > // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]], [[INT]]* [[RES_ADDR]] > // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], > [[ST_INT_ST_VAL]] > // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] > - // OMP45-TLS: [[ST_INT_ST_ADDR:%.*]] = call i32* > [[ST_INT_ST_TLS_INITD]] > - // OMP45-TLS-NEXT: [[ST_INT_ST_VAL:%.*]] = load [[INT]], [[INT]]* > [[ST_INT_ST_ADDR]] > + // > + // OMP45-TLS: [[ST_INT_ST_VAL:%.*]] = load [[INT]], [[INT]]* > [[ST_INT_ST_ADDR:[^,]+]] > // OMP45-TLS-NEXT: [[RES:%.*]] = load [[INT]], [[INT]]* [[RES_ADDR]] > // OMP45-TLS-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], > [[ST_INT_ST_VAL]] > // OMP45-TLS-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] > @@ -896,8 +896,8 @@ int foobar() { > // CHECK-DEBUG-NEXT: [[RES:%.*]] = load [[INT]], [[INT]]* [[RES_ADDR]] > // CHECK-DEBUG-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], > [[FLOAT_TO_INT_CONV]] > // CHECK-DEBUG-NEXT: store [[INT]] [[ADD]], [[INT]]* [[RES:.+]] > - // OMP45-TLS: [[ST_FLOAT_ST_ADDR:%.*]] = call float* > [[ST_FLOAT_ST_TLS_INITD]] > - // OMP45-TLS-NEXT: [[ST_FLOAT_ST_VAL:%.*]] = load float, float* > [[ST_FLOAT_ST_ADDR]] > + // > + // OMP45-TLS: [[ST_FLOAT_ST_VAL:%.*]] = load float, float* > [[ST_FLOAT_ST_ADDR:[^,]+]] > // OMP45-TLS-NEXT: [[FLOAT_TO_INT_CONV:%.*]] = fptosi float > [[ST_FLOAT_ST_VAL]] to [[INT]] > // OMP45-TLS-NEXT: [[RES:%.*]] = load [[INT]], [[INT]]* [[RES_ADDR]] > // OMP45-TLS-NEXT: [[ADD:%.*]] = add {{.*}} [[INT]] [[RES]], > [[FLOAT_TO_INT_CONV]] > > diff --git a/clang/test/Sema/enable_if.c b/clang/test/Sema/enable_if.c > index b4bb2ecd0d20..d96a53d94e1e 100644 > --- a/clang/test/Sema/enable_if.c > +++ b/clang/test/Sema/enable_if.c > @@ -5,7 +5,7 @@ > typedef int mode_t; > typedef unsigned long size_t; > > -const int TRUE = 1; > +enum { TRUE = 1 }; > > int open(const char *pathname, int flags) > __attribute__((enable_if(!(flags & O_CREAT), "must specify mode when using > O_CREAT"))) __attribute__((overloadable)); // expected-note{{candidate > disabled: must specify mode when using O_CREAT}} > int open(const char *pathname, int flags, mode_t mode) > __attribute__((overloadable)); // expected-note{{candidate function not > viable: requires 3 arguments, but 2 were provided}} > @@ -114,7 +114,7 @@ void f(int n) __attribute__((enable_if(unresolvedid, > "chosen when 'unresolvedid' > int global; > void f(int n) __attribute__((enable_if(global == 0, "chosen when 'global' > is zero"))); // expected-error{{'enable_if' attribute expression never > produces a constant expression}} // expected-note{{subexpression not valid > in a constant expression}} > > -const int cst = 7; > +enum { cst = 7 }; > void return_cst(void) __attribute__((overloadable)) > __attribute__((enable_if(cst == 7, "chosen when 'cst' is 7"))); > void test_return_cst() { return_cst(); } > > > diff --git a/clang/test/SemaCXX/constant-expression.cpp > b/clang/test/SemaCXX/constant-expression.cpp > index 2bec62f46b66..a5e571a97eb2 100644 > --- a/clang/test/SemaCXX/constant-expression.cpp > +++ b/clang/test/SemaCXX/constant-expression.cpp > @@ -98,9 +98,9 @@ void diags(int n) { > > namespace IntOrEnum { > const int k = 0; > - const int &p = k; > + const int &p = k; // expected-note {{declared here}} > template<int n> struct S {}; > - S<p> s; // expected-error {{not an integral constant expression}} > + S<p> s; // expected-error {{not an integral constant expression}} > expected-note {{read of variable 'p' of non-integral, non-enumeration type > 'const int &'}} > } > > extern const int recurse1; > > diff --git a/clang/test/SemaCXX/i-c-e-cxx.cpp > b/clang/test/SemaCXX/i-c-e-cxx.cpp > index a09ff5ac8d9f..da9be1229a54 100644 > --- a/clang/test/SemaCXX/i-c-e-cxx.cpp > +++ b/clang/test/SemaCXX/i-c-e-cxx.cpp > @@ -19,9 +19,6 @@ void f() { > > int a() { > const int t=t; // expected-note {{declared here}} > -#if __cplusplus <= 199711L > - // expected-note@-2 {{read of object outside its lifetime}} > -#endif > > switch(1) { // do not warn that 1 is not a case value; > // 't' might have been expected to evalaute to 1 > > > > _______________________________________________ > cfe-commits mailing list > cfe-commits@lists.llvm.org > https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
