On Sat, Apr 27, 2019 at 3:29 AM Jorge Gorbe Moya via cfe-commits <cfe-commits@lists.llvm.org> wrote: > > Author: jgorbe > Date: Fri Apr 26 17:32:04 2019 > New Revision: 359361 > > URL: http://llvm.org/viewvc/llvm-project?rev=359361&view=rev > Log: > Revert Fix interactions between __builtin_constant_p and constexpr to match > current trunk GCC. > > This reverts r359059 (git commit 0b098754b73f3b96d00ecb1c7605760b11c90298) It is common to specify the *reason* for the revert, so it is recorded in change log.
> Removed: > cfe/trunk/test/SemaCXX/builtin-constant-p.cpp > Modified: > cfe/trunk/lib/AST/ExprConstant.cpp > cfe/trunk/lib/Sema/SemaChecking.cpp > cfe/trunk/test/SemaCXX/enable_if.cpp > > Modified: cfe/trunk/lib/AST/ExprConstant.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ExprConstant.cpp?rev=359361&r1=359360&r2=359361&view=diff > ============================================================================== > --- cfe/trunk/lib/AST/ExprConstant.cpp (original) > +++ cfe/trunk/lib/AST/ExprConstant.cpp Fri Apr 26 17:32:04 2019 > @@ -7801,33 +7801,19 @@ EvaluateBuiltinClassifyType(const CallEx > } > > /// EvaluateBuiltinConstantPForLValue - Determine the result of > -/// __builtin_constant_p when applied to the given pointer. > +/// __builtin_constant_p when applied to the given lvalue. > /// > -/// A pointer is only "constant" if it is null (or a pointer cast to integer) > -/// or it points to the first character of a string literal. > -static bool EvaluateBuiltinConstantPForLValue(const APValue &LV) { > - APValue::LValueBase Base = LV.getLValueBase(); > - if (Base.isNull()) { > - // A null base is acceptable. > - return true; > - } else if (const Expr *E = Base.dyn_cast<const Expr *>()) { > - if (!isa<StringLiteral>(E)) > - return false; > - return LV.getLValueOffset().isZero(); > - } else { > - // Any other base is not constant enough for GCC. > - return false; > - } > +/// An lvalue is only "constant" if it is a pointer or reference to the first > +/// character of a string literal. > +template<typename LValue> > +static bool EvaluateBuiltinConstantPForLValue(const LValue &LV) { > + const Expr *E = LV.getLValueBase().template dyn_cast<const Expr*>(); > + return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero(); > } > > /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to > /// GCC as we can manage. > -static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) { > - // Constant-folding is always enabled for the operand of > __builtin_constant_p > - // (even when the enclosing evaluation context otherwise requires a strict > - // language-specific constant expression). > - FoldConstant Fold(Info, true); > - > +static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg) { > QualType ArgType = Arg->getType(); > > // __builtin_constant_p always has one operand. The rules which gcc follows > @@ -7835,27 +7821,34 @@ static bool EvaluateBuiltinConstantP(Eva > // > // - If the operand is of integral, floating, complex or enumeration type, > // and can be folded to a known value of that type, it returns 1. > - // - If the operand can be folded to a pointer to the first character > - // of a string literal (or such a pointer cast to an integral type) > - // or to a null pointer or an integer cast to a pointer, it returns 1. > + // - If the operand and can be folded to a pointer to the first character > + // of a string literal (or such a pointer cast to an integral type), it > + // returns 1. > // > // Otherwise, it returns 0. > // > // FIXME: GCC also intends to return 1 for literals of aggregate types, but > // its support for this does not currently work. > - if (ArgType->isIntegralOrEnumerationType() || ArgType->isFloatingType() || > - ArgType->isAnyComplexType() || ArgType->isPointerType() || > - ArgType->isNullPtrType()) { > - APValue V; > - if (!::EvaluateAsRValue(Info, Arg, V)) > + if (ArgType->isIntegralOrEnumerationType()) { > + Expr::EvalResult Result; > + if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects) > return false; > > - // For a pointer (possibly cast to integer), there are special rules. > + APValue &V = Result.Val; > + if (V.getKind() == APValue::Int) > + return true; > if (V.getKind() == APValue::LValue) > return EvaluateBuiltinConstantPForLValue(V); > - > - // Otherwise, any constant value is good enough. > - return V.getKind() != APValue::Uninitialized; > + } else if (ArgType->isFloatingType() || ArgType->isAnyComplexType()) { > + return Arg->isEvaluatable(Ctx); > + } else if (ArgType->isPointerType() || Arg->isGLValue()) { > + LValue LV; > + Expr::EvalStatus Status; > + EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold); > + if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info) > + : EvaluatePointer(Arg, LV, Info)) && > + !Status.HasSideEffects) > + return EvaluateBuiltinConstantPForLValue(LV); > } > > // Anything else isn't considered to be sufficiently constant. > @@ -8266,7 +8259,7 @@ bool IntExprEvaluator::VisitBuiltinCallE > > case Builtin::BI__builtin_constant_p: { > auto Arg = E->getArg(0); > - if (EvaluateBuiltinConstantP(Info, Arg)) > + if (EvaluateBuiltinConstantP(Info.Ctx, Arg)) > return Success(true, E); > auto ArgTy = Arg->IgnoreImplicit()->getType(); > if (!Info.InConstantContext && !Arg->HasSideEffects(Info.Ctx) && > > Modified: cfe/trunk/lib/Sema/SemaChecking.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaChecking.cpp?rev=359361&r1=359360&r2=359361&view=diff > ============================================================================== > --- cfe/trunk/lib/Sema/SemaChecking.cpp (original) > +++ cfe/trunk/lib/Sema/SemaChecking.cpp Fri Apr 26 17:32:04 2019 > @@ -1199,14 +1199,10 @@ Sema::CheckBuiltinFunctionCall(FunctionD > if (checkArgCount(*this, TheCall, 1)) return true; > TheCall->setType(Context.IntTy); > break; > - case Builtin::BI__builtin_constant_p: { > + case Builtin::BI__builtin_constant_p: > if (checkArgCount(*this, TheCall, 1)) return true; > - ExprResult Arg = > DefaultFunctionArrayLvalueConversion(TheCall->getArg(0)); > - if (Arg.isInvalid()) return true; > - TheCall->setArg(0, Arg.get()); > TheCall->setType(Context.IntTy); > break; > - } > case Builtin::BI__builtin_launder: > return SemaBuiltinLaunder(*this, TheCall); > case Builtin::BI__sync_fetch_and_add: > > Removed: cfe/trunk/test/SemaCXX/builtin-constant-p.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/builtin-constant-p.cpp?rev=359360&view=auto > ============================================================================== > --- cfe/trunk/test/SemaCXX/builtin-constant-p.cpp (original) > +++ cfe/trunk/test/SemaCXX/builtin-constant-p.cpp (removed) > @@ -1,61 +0,0 @@ > -// RUN: %clang_cc1 -std=c++17 -verify %s > - > -using intptr_t = __INTPTR_TYPE__; > - > -// Test interaction of constexpr and __builtin_constant_p. > - > -template<typename T> constexpr bool bcp(T t) { > - return __builtin_constant_p(t); > -} > -template<typename T> constexpr bool bcp_fold(T t) { > - return __builtin_constant_p(((void)(intptr_t)&t, t)); > -} > - > -constexpr intptr_t ensure_fold_is_generally_not_enabled = // expected-error > {{constant expression}} > - (intptr_t)&ensure_fold_is_generally_not_enabled; // expected-note > {{cast}} > - > -constexpr intptr_t ptr_to_int(const void *p) { > - return __builtin_constant_p(1) ? (intptr_t)p : (intptr_t)p; > -} > - > -constexpr int *int_to_ptr(intptr_t n) { > - return __builtin_constant_p(1) ? (int*)n : (int*)n; > -} > - > -int x; > - > -// Integer and floating point constants encountered during constant > expression > -// evaluation are considered constant. So is nullptr_t. > -static_assert(bcp(1)); > -static_assert(bcp_fold(1)); > -static_assert(bcp(1.0)); > -static_assert(bcp_fold(1.0)); > -static_assert(bcp(nullptr)); > -static_assert(bcp_fold(nullptr)); > - > -// Pointers to the start of strings are considered constant. > -static_assert(bcp("foo")); > -static_assert(bcp_fold("foo")); > - > -// Null pointers are considered constant. > -static_assert(bcp<int*>(nullptr)); > -static_assert(bcp_fold<int*>(nullptr)); > -static_assert(bcp<const char*>(nullptr)); > -static_assert(bcp_fold<const char*>(nullptr)); > - > -// Other pointers are not. > -static_assert(!bcp(&x)); > -static_assert(!bcp_fold(&x)); > - > -// Pointers cast to integers follow the rules for pointers. > -static_assert(bcp(ptr_to_int("foo"))); > -static_assert(bcp_fold(ptr_to_int("foo"))); > -static_assert(!bcp(ptr_to_int(&x))); > -static_assert(!bcp_fold(ptr_to_int(&x))); > - > -// Integers cast to pointers follow the integer rules. > -static_assert(bcp(int_to_ptr(0))); > -static_assert(bcp_fold(int_to_ptr(0))); > -static_assert(bcp(int_to_ptr(123))); // GCC rejects these due to not > recognizing > -static_assert(bcp_fold(int_to_ptr(123))); // the bcp conditional in > 'int_to_ptr' ... > -static_assert(__builtin_constant_p((int*)123)); // ... but GCC accepts this > > Modified: cfe/trunk/test/SemaCXX/enable_if.cpp > URL: > http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/enable_if.cpp?rev=359361&r1=359360&r2=359361&view=diff > ============================================================================== > --- cfe/trunk/test/SemaCXX/enable_if.cpp (original) > +++ cfe/trunk/test/SemaCXX/enable_if.cpp Fri Apr 26 17:32:04 2019 > @@ -522,14 +522,3 @@ void test() { > InConstantContext::foo("abc"); > } > } // namespace InConstantContext > - > -namespace StringLiteralDetector { > - void need_string_literal(const char *p) > __attribute__((enable_if(__builtin_constant_p(p), "argument is not a string > literal"))); // expected-note 2{{not a string literal}} > - void test(const char *unknown) { > - need_string_literal("foo"); > - need_string_literal(unknown); // expected-error {{no matching function}} > - constexpr char str[] = "bar"; > - need_string_literal(str); // expected-error {{no matching function}} > - } > -} > - > > > _______________________________________________ > 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