r347364 - Reinstate 347294 with a fix for the failures.

Bill Wendling via cfe-commits cfe-commits at lists.llvm.org
Wed Nov 21 13:21:58 PST 2018


Should be fixed now. Sorry about the breakage.

On Wed, Nov 21, 2018 at 4:51 AM Nico Weber <thakis at chromium.org> wrote:

> I've reverted this again in r347389. The standalone repro at
> https://bugs.chromium.org/p/chromium/issues/detail?id=907099#c2 still
> asserts.
>
>
> On Tue, Nov 20, 2018 at 6:26 PM Bill Wendling via cfe-commits <
> cfe-commits at lists.llvm.org> wrote:
>
>> Author: void
>> Date: Tue Nov 20 15:24:16 2018
>> New Revision: 347364
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=347364&view=rev
>> Log:
>> Reinstate 347294 with a fix for the failures.
>>
>> EvaluateAsInt() is sometimes called in a constant context. When that's the
>> case, we need to specify it as so.
>>
>> Modified:
>>     cfe/trunk/include/clang/AST/Expr.h
>>     cfe/trunk/lib/AST/ASTImporter.cpp
>>     cfe/trunk/lib/AST/Expr.cpp
>>     cfe/trunk/lib/AST/ExprConstant.cpp
>>     cfe/trunk/lib/Analysis/CFG.cpp
>>     cfe/trunk/lib/CodeGen/CGBuiltin.cpp
>>     cfe/trunk/lib/CodeGen/CGDebugInfo.cpp
>>     cfe/trunk/lib/CodeGen/CGExprScalar.cpp
>>     cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
>>     cfe/trunk/lib/CodeGen/CGStmt.cpp
>>     cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
>>     cfe/trunk/lib/CodeGen/CodeGenFunction.cpp
>>     cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp
>>     cfe/trunk/lib/Sema/SemaCast.cpp
>>     cfe/trunk/lib/Sema/SemaChecking.cpp
>>     cfe/trunk/lib/Sema/SemaDecl.cpp
>>     cfe/trunk/lib/Sema/SemaDeclCXX.cpp
>>     cfe/trunk/lib/Sema/SemaExpr.cpp
>>     cfe/trunk/lib/Sema/SemaInit.cpp
>>     cfe/trunk/lib/Sema/SemaOpenMP.cpp
>>     cfe/trunk/lib/Sema/SemaOverload.cpp
>>     cfe/trunk/lib/Sema/SemaStmt.cpp
>>     cfe/trunk/lib/Sema/SemaStmtAsm.cpp
>>     cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp
>>     cfe/trunk/lib/Sema/SemaType.cpp
>>     cfe/trunk/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
>>     cfe/trunk/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
>>
>> cfe/trunk/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
>>
>> cfe/trunk/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
>>     cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp
>>     cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp
>>     cfe/trunk/lib/StaticAnalyzer/Core/SValBuilder.cpp
>>     cfe/trunk/test/Analysis/builtin-functions.cpp
>>     cfe/trunk/test/Sema/builtins.c
>>     cfe/trunk/test/SemaCXX/compound-literal.cpp
>>
>> Modified: cfe/trunk/include/clang/AST/Expr.h
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/Expr.h?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/include/clang/AST/Expr.h (original)
>> +++ cfe/trunk/include/clang/AST/Expr.h Tue Nov 20 15:24:16 2018
>> @@ -600,7 +600,7 @@ public:
>>
>>    /// EvaluateAsInt - Return true if this is a constant which we can
>> fold and
>>    /// convert to an integer, using any crazy technique that we want to.
>> -  bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx,
>> +  bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
>>                       SideEffectsKind AllowSideEffects =
>> SE_NoSideEffects) const;
>>
>>    /// EvaluateAsFloat - Return true if this is a constant which we can
>> fold and
>> @@ -901,10 +901,15 @@ public:
>>
>>  /// ConstantExpr - An expression that occurs in a constant context.
>>  class ConstantExpr : public FullExpr {
>> -public:
>>    ConstantExpr(Expr *subexpr)
>>      : FullExpr(ConstantExprClass, subexpr) {}
>>
>> +public:
>> +  static ConstantExpr *Create(const ASTContext &Context, Expr *E) {
>> +    assert(!isa<ConstantExpr>(E));
>> +    return new (Context) ConstantExpr(E);
>> +  }
>> +
>>    /// Build an empty constant expression wrapper.
>>    explicit ConstantExpr(EmptyShell Empty)
>>      : FullExpr(ConstantExprClass, Empty) {}
>> @@ -3087,8 +3092,8 @@ inline Expr *Expr::IgnoreImpCasts() {
>>    while (true)
>>      if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
>>        e = ice->getSubExpr();
>> -    else if (ConstantExpr *ce = dyn_cast<ConstantExpr>(e))
>> -      e = ce->getSubExpr();
>> +    else if (FullExpr *fe = dyn_cast<FullExpr>(e))
>> +      e = fe->getSubExpr();
>>      else
>>        break;
>>    return e;
>>
>> Modified: cfe/trunk/lib/AST/ASTImporter.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTImporter.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/ASTImporter.cpp (original)
>> +++ cfe/trunk/lib/AST/ASTImporter.cpp Tue Nov 20 15:24:16 2018
>> @@ -6380,7 +6380,7 @@ ExpectedStmt ASTNodeImporter::VisitConst
>>    Expr *ToSubExpr;
>>    std::tie(ToSubExpr) = *Imp;
>>
>> -  return new (Importer.getToContext()) ConstantExpr(ToSubExpr);
>> +  return ConstantExpr::Create(Importer.getToContext(), ToSubExpr);
>>  }
>>
>>  ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
>>
>> Modified: cfe/trunk/lib/AST/Expr.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Expr.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/Expr.cpp (original)
>> +++ cfe/trunk/lib/AST/Expr.cpp Tue Nov 20 15:24:16 2018
>> @@ -2594,8 +2594,8 @@ Expr *Expr::IgnoreParenCasts() {
>>        E = NTTP->getReplacement();
>>        continue;
>>      }
>> -    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
>> -      E = CE->getSubExpr();
>> +    if (FullExpr *FE = dyn_cast<FullExpr>(E)) {
>> +      E = FE->getSubExpr();
>>        continue;
>>      }
>>      return E;
>> @@ -2619,8 +2619,8 @@ Expr *Expr::IgnoreCasts() {
>>        E = NTTP->getReplacement();
>>        continue;
>>      }
>> -    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
>> -      E = CE->getSubExpr();
>> +    if (FullExpr *FE = dyn_cast<FullExpr>(E)) {
>> +      E = FE->getSubExpr();
>>        continue;
>>      }
>>      return E;
>> @@ -2648,8 +2648,8 @@ Expr *Expr::IgnoreParenLValueCasts() {
>>                                    =
>> dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
>>        E = NTTP->getReplacement();
>>        continue;
>> -    } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
>> -      E = CE->getSubExpr();
>> +    } else if (FullExpr *FE = dyn_cast<FullExpr>(E)) {
>> +      E = FE->getSubExpr();
>>        continue;
>>      }
>>      break;
>> @@ -2920,6 +2920,12 @@ bool Expr::isConstantInitializer(ASTCont
>>
>>      break;
>>    }
>> +  case ConstantExprClass: {
>> +    // FIXME: We should be able to return "true" here, but it can lead
>> to extra
>> +    // error messages. E.g. in Sema/array-init.c.
>> +    const Expr *Exp = cast<ConstantExpr>(this)->getSubExpr();
>> +    return Exp->isConstantInitializer(Ctx, false, Culprit);
>> +  }
>>    case CompoundLiteralExprClass: {
>>      // This handles gcc's extension that allows global initializers like
>>      // "struct x {int x;} x = (struct x) {};".
>> @@ -2959,8 +2965,8 @@ bool Expr::isConstantInitializer(ASTCont
>>            const Expr *Elt = ILE->getInit(ElementNo++);
>>            if (Field->isBitField()) {
>>              // Bitfields have to evaluate to an integer.
>> -            llvm::APSInt ResultTmp;
>> -            if (!Elt->EvaluateAsInt(ResultTmp, Ctx)) {
>> +            EvalResult Result;
>> +            if (!Elt->EvaluateAsInt(Result, Ctx)) {
>>                if (Culprit)
>>                  *Culprit = Elt;
>>                return false;
>>
>> Modified: cfe/trunk/lib/AST/ExprConstant.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ExprConstant.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/AST/ExprConstant.cpp (original)
>> +++ cfe/trunk/lib/AST/ExprConstant.cpp Tue Nov 20 15:24:16 2018
>> @@ -45,6 +45,7 @@
>>  #include "clang/AST/TypeLoc.h"
>>  #include "clang/Basic/Builtins.h"
>>  #include "clang/Basic/TargetInfo.h"
>> +#include "llvm/Support/SaveAndRestore.h"
>>  #include "llvm/Support/raw_ostream.h"
>>  #include <cstring>
>>  #include <functional>
>> @@ -721,6 +722,10 @@ namespace {
>>      /// Whether or not we're currently speculatively evaluating.
>>      bool IsSpeculativelyEvaluating;
>>
>> +    /// Whether or not we're in a context where the front end requires a
>> +    /// constant value.
>> +    bool InConstantContext;
>> +
>>      enum EvaluationMode {
>>        /// Evaluate as a constant expression. Stop if we find that the
>> expression
>>        /// is not a constant expression.
>> @@ -782,7 +787,7 @@ namespace {
>>          EvaluatingDecl((const ValueDecl *)nullptr),
>>          EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
>>          HasFoldFailureDiagnostic(false),
>> IsSpeculativelyEvaluating(false),
>> -        EvalMode(Mode) {}
>> +        InConstantContext(false), EvalMode(Mode) {}
>>
>>      void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value) {
>>        EvaluatingDecl = Base;
>> @@ -5625,8 +5630,10 @@ static bool getBytesReturnedByAllocSizeC
>>      return false;
>>
>>    auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
>> -    if (!E->EvaluateAsInt(Into, Ctx, Expr::SE_AllowSideEffects))
>> +    Expr::EvalResult ExprResult;
>> +    if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects))
>>        return false;
>> +    Into = ExprResult.Val.getInt();
>>      if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
>>        return false;
>>      Into = Into.zextOrSelf(BitsInSizeT);
>> @@ -7348,6 +7355,8 @@ public:
>>    //                            Visitor Methods
>>
>>  //===--------------------------------------------------------------------===//
>>
>> +  bool VisitConstantExpr(const ConstantExpr *E);
>> +
>>    bool VisitIntegerLiteral(const IntegerLiteral *E) {
>>      return Success(E->getValue(), E);
>>    }
>> @@ -8088,6 +8097,11 @@ static bool tryEvaluateBuiltinObjectSize
>>    return true;
>>  }
>>
>> +bool IntExprEvaluator::VisitConstantExpr(const ConstantExpr *E) {
>> +  llvm::SaveAndRestore<bool> InConstantContext(Info.InConstantContext,
>> true);
>> +  return ExprEvaluatorBaseTy::VisitConstantExpr(E);
>> +}
>> +
>>  bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
>>    if (unsigned BuiltinOp = E->getBuiltinCallee())
>>      return VisitBuiltinCallExpr(E, BuiltinOp);
>> @@ -8175,8 +8189,20 @@ bool IntExprEvaluator::VisitBuiltinCallE
>>      return Success(Val.countLeadingZeros(), E);
>>    }
>>
>> -  case Builtin::BI__builtin_constant_p:
>> -    return Success(EvaluateBuiltinConstantP(Info.Ctx, E->getArg(0)), E);
>> +  case Builtin::BI__builtin_constant_p: {
>> +    auto Arg = E->getArg(0);
>> +    if (EvaluateBuiltinConstantP(Info.Ctx, Arg))
>> +      return Success(true, E);
>> +    auto ArgTy = Arg->IgnoreImplicit()->getType();
>> +    if (!Info.InConstantContext && !Arg->HasSideEffects(Info.Ctx) &&
>> +        !ArgTy->isAggregateType() && !ArgTy->isPointerType()) {
>> +      // We can delay calculation of __builtin_constant_p until after
>> +      // inlining. Note: This diagnostic won't be shown to the user.
>> +      Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
>> +      return false;
>> +    }
>> +    return Success(false, E);
>> +  }
>>
>>    case Builtin::BI__builtin_ctz:
>>    case Builtin::BI__builtin_ctzl:
>> @@ -10746,6 +10772,35 @@ static bool FastEvaluateAsRValue(const E
>>    return false;
>>  }
>>
>> +static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
>> +                                      Expr::SideEffectsKind SEK) {
>> +  return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
>> +         (SEK < Expr::SE_AllowUndefinedBehavior &&
>> Result.HasUndefinedBehavior);
>> +}
>> +
>> +static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
>> +                             const ASTContext &Ctx, EvalInfo &Info) {
>> +  bool IsConst;
>> +  if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
>> +    return IsConst;
>> +
>> +  return EvaluateAsRValue(Info, E, Result.Val);
>> +}
>> +
>> +static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
>> +                          const ASTContext &Ctx,
>> +                          Expr::SideEffectsKind AllowSideEffects,
>> +                          EvalInfo &Info) {
>> +  if (!E->getType()->isIntegralOrEnumerationType())
>> +    return false;
>> +
>> +  if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) ||
>> +      !ExprResult.Val.isInt() ||
>> +      hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
>> +    return false;
>> +
>> +  return true;
>> +}
>>
>>  /// EvaluateAsRValue - Return true if this is a constant which we can
>> fold using
>>  /// any crazy technique (that has nothing to do with language standards)
>> that
>> @@ -10753,12 +10808,8 @@ static bool FastEvaluateAsRValue(const E
>>  /// in Result. If this expression is a glvalue, an lvalue-to-rvalue
>> conversion
>>  /// will be applied to the result.
>>  bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx)
>> const {
>> -  bool IsConst;
>> -  if (FastEvaluateAsRValue(this, Result, Ctx, IsConst))
>> -    return IsConst;
>> -
>>    EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
>> -  return ::EvaluateAsRValue(Info, this, Result.Val);
>> +  return ::EvaluateAsRValue(this, Result, Ctx, Info);
>>  }
>>
>>  bool Expr::EvaluateAsBooleanCondition(bool &Result,
>> @@ -10768,24 +10819,10 @@ bool Expr::EvaluateAsBooleanCondition(bo
>>           HandleConversionToBool(Scratch.Val, Result);
>>  }
>>
>> -static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
>> -                                      Expr::SideEffectsKind SEK) {
>> -  return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
>> -         (SEK < Expr::SE_AllowUndefinedBehavior &&
>> Result.HasUndefinedBehavior);
>> -}
>> -
>> -bool Expr::EvaluateAsInt(APSInt &Result, const ASTContext &Ctx,
>> +bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
>>                           SideEffectsKind AllowSideEffects) const {
>> -  if (!getType()->isIntegralOrEnumerationType())
>> -    return false;
>> -
>> -  EvalResult ExprResult;
>> -  if (!EvaluateAsRValue(ExprResult, Ctx) || !ExprResult.Val.isInt() ||
>> -      hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
>> -    return false;
>> -
>> -  Result = ExprResult.Val.getInt();
>> -  return true;
>> +  EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
>> +  return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info);
>>  }
>>
>>  bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
>> @@ -10878,35 +10915,40 @@ bool Expr::isEvaluatable(const ASTContex
>>
>>  APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx,
>>                      SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
>> -  EvalResult EvalResult;
>> -  EvalResult.Diag = Diag;
>> -  bool Result = EvaluateAsRValue(EvalResult, Ctx);
>> +  EvalResult EVResult;
>> +  EVResult.Diag = Diag;
>> +  EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
>> +  Info.InConstantContext = true;
>> +
>> +  bool Result = ::EvaluateAsRValue(this, EVResult, Ctx, Info);
>>    (void)Result;
>>    assert(Result && "Could not evaluate expression");
>> -  assert(EvalResult.Val.isInt() && "Expression did not evaluate to
>> integer");
>> +  assert(EVResult.Val.isInt() && "Expression did not evaluate to
>> integer");
>>
>> -  return EvalResult.Val.getInt();
>> +  return EVResult.Val.getInt();
>>  }
>>
>>  APSInt Expr::EvaluateKnownConstIntCheckOverflow(
>>      const ASTContext &Ctx, SmallVectorImpl<PartialDiagnosticAt> *Diag)
>> const {
>> -  EvalResult EvalResult;
>> -  EvalResult.Diag = Diag;
>> -  EvalInfo Info(Ctx, EvalResult, EvalInfo::EM_EvaluateForOverflow);
>> -  bool Result = ::EvaluateAsRValue(Info, this, EvalResult.Val);
>> +  EvalResult EVResult;
>> +  EVResult.Diag = Diag;
>> +  EvalInfo Info(Ctx, EVResult, EvalInfo::EM_EvaluateForOverflow);
>> +  Info.InConstantContext = true;
>> +
>> +  bool Result = ::EvaluateAsRValue(Info, this, EVResult.Val);
>>    (void)Result;
>>    assert(Result && "Could not evaluate expression");
>> -  assert(EvalResult.Val.isInt() && "Expression did not evaluate to
>> integer");
>> +  assert(EVResult.Val.isInt() && "Expression did not evaluate to
>> integer");
>>
>> -  return EvalResult.Val.getInt();
>> +  return EVResult.Val.getInt();
>>  }
>>
>>  void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
>>    bool IsConst;
>> -  EvalResult EvalResult;
>> -  if (!FastEvaluateAsRValue(this, EvalResult, Ctx, IsConst)) {
>> -    EvalInfo Info(Ctx, EvalResult, EvalInfo::EM_EvaluateForOverflow);
>> -    (void)::EvaluateAsRValue(Info, this, EvalResult.Val);
>> +  EvalResult EVResult;
>> +  if (!FastEvaluateAsRValue(this, EVResult, Ctx, IsConst)) {
>> +    EvalInfo Info(Ctx, EVResult, EvalInfo::EM_EvaluateForOverflow);
>> +    (void)::EvaluateAsRValue(Info, this, EVResult.Val);
>>    }
>>  }
>>
>> @@ -10959,7 +11001,11 @@ static ICEDiag Worst(ICEDiag A, ICEDiag
>>
>>  static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
>>    Expr::EvalResult EVResult;
>> -  if (!E->EvaluateAsRValue(EVResult, Ctx) || EVResult.HasSideEffects ||
>> +  Expr::EvalStatus Status;
>> +  EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
>> +
>> +  Info.InConstantContext = true;
>> +  if (!::EvaluateAsRValue(E, EVResult, Ctx, Info) ||
>> EVResult.HasSideEffects ||
>>        !EVResult.Val.isInt())
>>      return ICEDiag(IK_NotICE, E->getBeginLoc());
>>
>> @@ -11397,12 +11443,20 @@ bool Expr::isIntegerConstantExpr(llvm::A
>>
>>    if (!isIntegerConstantExpr(Ctx, Loc))
>>      return false;
>> +
>>    // The only possible side-effects here are due to UB discovered in the
>>    // evaluation (for instance, INT_MAX + 1). In such a case, we are still
>>    // required to treat the expression as an ICE, so we produce the folded
>>    // value.
>> -  if (!EvaluateAsInt(Value, Ctx, SE_AllowSideEffects))
>> +  EvalResult ExprResult;
>> +  Expr::EvalStatus Status;
>> +  EvalInfo Info(Ctx, Status, EvalInfo::EM_IgnoreSideEffects);
>> +  Info.InConstantContext = true;
>> +
>> +  if (!::EvaluateAsInt(this, ExprResult, Ctx, SE_AllowSideEffects, Info))
>>      llvm_unreachable("ICE cannot be evaluated!");
>> +
>> +  Value = ExprResult.Val.getInt();
>>    return true;
>>  }
>>
>>
>> Modified: cfe/trunk/lib/Analysis/CFG.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/CFG.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Analysis/CFG.cpp (original)
>> +++ cfe/trunk/lib/Analysis/CFG.cpp Tue Nov 20 15:24:16 2018
>> @@ -1039,12 +1039,14 @@ private:
>>      if (!areExprTypesCompatible(Expr1, Expr2))
>>        return {};
>>
>> -    llvm::APSInt L1, L2;
>> -
>> -    if (!Expr1->EvaluateAsInt(L1, *Context) ||
>> -        !Expr2->EvaluateAsInt(L2, *Context))
>> +    Expr::EvalResult L1Result, L2Result;
>> +    if (!Expr1->EvaluateAsInt(L1Result, *Context) ||
>> +        !Expr2->EvaluateAsInt(L2Result, *Context))
>>        return {};
>>
>> +    llvm::APSInt L1 = L1Result.Val.getInt();
>> +    llvm::APSInt L2 = L2Result.Val.getInt();
>> +
>>      // Can't compare signed with unsigned or with different bit width.
>>      if (L1.isSigned() != L2.isSigned() || L1.getBitWidth() !=
>> L2.getBitWidth())
>>        return {};
>> @@ -1134,13 +1136,16 @@ private:
>>            case BO_And: {
>>              // If either operand is zero, we know the value
>>              // must be false.
>> -            llvm::APSInt IntVal;
>> -            if (Bop->getLHS()->EvaluateAsInt(IntVal, *Context)) {
>> +            Expr::EvalResult LHSResult;
>> +            if (Bop->getLHS()->EvaluateAsInt(LHSResult, *Context)) {
>> +              llvm::APSInt IntVal = LHSResult.Val.getInt();
>>                if (!IntVal.getBoolValue()) {
>>                  return TryResult(false);
>>                }
>>              }
>> -            if (Bop->getRHS()->EvaluateAsInt(IntVal, *Context)) {
>> +            Expr::EvalResult RHSResult;
>> +            if (Bop->getRHS()->EvaluateAsInt(RHSResult, *Context)) {
>> +              llvm::APSInt IntVal = RHSResult.Val.getInt();
>>                if (!IntVal.getBoolValue()) {
>>                  return TryResult(false);
>>                }
>>
>> Modified: cfe/trunk/lib/CodeGen/CGBuiltin.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGBuiltin.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CGBuiltin.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CGBuiltin.cpp Tue Nov 20 15:24:16 2018
>> @@ -1926,6 +1926,26 @@ RValue CodeGenFunction::EmitBuiltinExpr(
>>    case Builtin::BI__builtin_rotateright64:
>>      return emitRotate(E, true);
>>
>> +  case Builtin::BI__builtin_constant_p: {
>> +    llvm::Type *ResultType = ConvertType(E->getType());
>> +    if (CGM.getCodeGenOpts().OptimizationLevel == 0)
>> +      // At -O0, we don't perform inlining, so we don't need to delay the
>> +      // processing.
>> +      return RValue::get(ConstantInt::get(ResultType, 0));
>> +    if (auto *DRE =
>> dyn_cast<DeclRefExpr>(E->getArg(0)->IgnoreImplicit())) {
>> +      auto DREType = DRE->getType();
>> +      if (DREType->isAggregateType() || DREType->isFunctionType())
>> +        return RValue::get(ConstantInt::get(ResultType, 0));
>> +    }
>> +    Value *ArgValue = EmitScalarExpr(E->getArg(0));
>> +    llvm::Type *ArgType = ArgValue->getType();
>> +
>> +    Value *F = CGM.getIntrinsic(Intrinsic::is_constant, ArgType);
>> +    Value *Result = Builder.CreateCall(F, ArgValue);
>> +    if (Result->getType() != ResultType)
>> +      Result = Builder.CreateIntCast(Result, ResultType,
>> /*isSigned*/true);
>> +    return RValue::get(Result);
>> +  }
>>    case Builtin::BI__builtin_object_size: {
>>      unsigned Type =
>>          E->getArg(1)->EvaluateKnownConstInt(getContext()).getZExtValue();
>> @@ -2190,10 +2210,12 @@ RValue CodeGenFunction::EmitBuiltinExpr(
>>
>>    case Builtin::BI__builtin___memcpy_chk: {
>>      // fold __builtin_memcpy_chk(x, y, cst1, cst2) to memcpy iff
>> cst1<=cst2.
>> -    llvm::APSInt Size, DstSize;
>> -    if (!E->getArg(2)->EvaluateAsInt(Size, CGM.getContext()) ||
>> -        !E->getArg(3)->EvaluateAsInt(DstSize, CGM.getContext()))
>> +    Expr::EvalResult SizeResult, DstSizeResult;
>> +    if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
>> +        !E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
>>        break;
>> +    llvm::APSInt Size = SizeResult.Val.getInt();
>> +    llvm::APSInt DstSize = DstSizeResult.Val.getInt();
>>      if (Size.ugt(DstSize))
>>        break;
>>      Address Dest = EmitPointerWithAlignment(E->getArg(0));
>> @@ -2214,10 +2236,12 @@ RValue CodeGenFunction::EmitBuiltinExpr(
>>
>>    case Builtin::BI__builtin___memmove_chk: {
>>      // fold __builtin_memmove_chk(x, y, cst1, cst2) to memmove iff
>> cst1<=cst2.
>> -    llvm::APSInt Size, DstSize;
>> -    if (!E->getArg(2)->EvaluateAsInt(Size, CGM.getContext()) ||
>> -        !E->getArg(3)->EvaluateAsInt(DstSize, CGM.getContext()))
>> +    Expr::EvalResult SizeResult, DstSizeResult;
>> +    if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
>> +        !E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
>>        break;
>> +    llvm::APSInt Size = SizeResult.Val.getInt();
>> +    llvm::APSInt DstSize = DstSizeResult.Val.getInt();
>>      if (Size.ugt(DstSize))
>>        break;
>>      Address Dest = EmitPointerWithAlignment(E->getArg(0));
>> @@ -2252,10 +2276,12 @@ RValue CodeGenFunction::EmitBuiltinExpr(
>>    }
>>    case Builtin::BI__builtin___memset_chk: {
>>      // fold __builtin_memset_chk(x, y, cst1, cst2) to memset iff
>> cst1<=cst2.
>> -    llvm::APSInt Size, DstSize;
>> -    if (!E->getArg(2)->EvaluateAsInt(Size, CGM.getContext()) ||
>> -        !E->getArg(3)->EvaluateAsInt(DstSize, CGM.getContext()))
>> +    Expr::EvalResult SizeResult, DstSizeResult;
>> +    if (!E->getArg(2)->EvaluateAsInt(SizeResult, CGM.getContext()) ||
>> +        !E->getArg(3)->EvaluateAsInt(DstSizeResult, CGM.getContext()))
>>        break;
>> +    llvm::APSInt Size = SizeResult.Val.getInt();
>> +    llvm::APSInt DstSize = DstSizeResult.Val.getInt();
>>      if (Size.ugt(DstSize))
>>        break;
>>      Address Dest = EmitPointerWithAlignment(E->getArg(0));
>> @@ -5769,10 +5795,11 @@ Value *CodeGenFunction::EmitARMBuiltinEx
>>      llvm::FunctionType *FTy =
>>          llvm::FunctionType::get(VoidTy, /*Variadic=*/false);
>>
>> -    APSInt Value;
>> -    if (!E->getArg(0)->EvaluateAsInt(Value, CGM.getContext()))
>> +    Expr::EvalResult Result;
>> +    if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
>>        llvm_unreachable("Sema will ensure that the parameter is
>> constant");
>>
>> +    llvm::APSInt Value = Result.Val.getInt();
>>      uint64_t ZExtValue = Value.zextOrTrunc(IsThumb ? 16 :
>> 32).getZExtValue();
>>
>>      llvm::InlineAsm *Emit =
>> @@ -6875,10 +6902,11 @@ Value *CodeGenFunction::EmitAArch64Built
>>    }
>>
>>    if (BuiltinID == AArch64::BI__getReg) {
>> -    APSInt Value;
>> -    if (!E->getArg(0)->EvaluateAsInt(Value, CGM.getContext()))
>> +    Expr::EvalResult Result;
>> +    if (!E->getArg(0)->EvaluateAsInt(Result, CGM.getContext()))
>>        llvm_unreachable("Sema will ensure that the parameter is
>> constant");
>>
>> +    llvm::APSInt Value = Result.Val.getInt();
>>      LLVMContext &Context = CGM.getLLVMContext();
>>      std::string Reg = Value == 31 ? "sp" : "x" + Value.toString(10);
>>
>>
>> Modified: cfe/trunk/lib/CodeGen/CGDebugInfo.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDebugInfo.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CGDebugInfo.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CGDebugInfo.cpp Tue Nov 20 15:24:16 2018
>> @@ -2522,9 +2522,9 @@ llvm::DIType *CGDebugInfo::CreateType(co
>>        Count = CAT->getSize().getZExtValue();
>>      else if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
>>        if (Expr *Size = VAT->getSizeExpr()) {
>> -        llvm::APSInt V;
>> -        if (Size->EvaluateAsInt(V, CGM.getContext()))
>> -          Count = V.getExtValue();
>> +        Expr::EvalResult Result;
>> +        if (Size->EvaluateAsInt(Result, CGM.getContext()))
>> +          Count = Result.Val.getInt().getExtValue();
>>        }
>>      }
>>
>>
>> Modified: cfe/trunk/lib/CodeGen/CGExprScalar.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGExprScalar.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CGExprScalar.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CGExprScalar.cpp Tue Nov 20 15:24:16 2018
>> @@ -1717,8 +1717,9 @@ Value *ScalarExprEmitter::VisitMemberExp
>>      CGF.EmitIgnoredExpr(E->getBase());
>>      return CGF.emitScalarConstant(Constant, E);
>>    } else {
>> -    llvm::APSInt Value;
>> -    if (E->EvaluateAsInt(Value, CGF.getContext(),
>> Expr::SE_AllowSideEffects)) {
>> +    Expr::EvalResult Result;
>> +    if (E->EvaluateAsInt(Result, CGF.getContext(),
>> Expr::SE_AllowSideEffects)) {
>> +      llvm::APSInt Value = Result.Val.getInt();
>>        CGF.EmitIgnoredExpr(E->getBase());
>>        return Builder.getInt(Value);
>>      }
>> @@ -2597,9 +2598,11 @@ Value *ScalarExprEmitter::VisitUnaryLNot
>>
>>  Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) {
>>    // Try folding the offsetof to a constant.
>> -  llvm::APSInt Value;
>> -  if (E->EvaluateAsInt(Value, CGF.getContext()))
>> +  Expr::EvalResult EVResult;
>> +  if (E->EvaluateAsInt(EVResult, CGF.getContext())) {
>> +    llvm::APSInt Value = EVResult.Val.getInt();
>>      return Builder.getInt(Value);
>> +  }
>>
>>    // Loop over the components of the offsetof to compute the value.
>>    unsigned n = E->getNumComponents();
>>
>> Modified: cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp Tue Nov 20 15:24:16 2018
>> @@ -6795,10 +6795,11 @@ private:
>>      }
>>
>>      // Check if the length evaluates to 1.
>> -    llvm::APSInt ConstLength;
>> -    if (!Length->EvaluateAsInt(ConstLength, CGF.getContext()))
>> +    Expr::EvalResult Result;
>> +    if (!Length->EvaluateAsInt(Result, CGF.getContext()))
>>        return true; // Can have more that size 1.
>>
>> +    llvm::APSInt ConstLength = Result.Val.getInt();
>>      return ConstLength.getSExtValue() != 1;
>>    }
>>
>> @@ -9162,8 +9163,8 @@ void CGOpenMPRuntime::emitDeclareSimdFun
>>          ParamAttrTy &ParamAttr = ParamAttrs[Pos];
>>          ParamAttr.Kind = Linear;
>>          if (*SI) {
>> -          if (!(*SI)->EvaluateAsInt(ParamAttr.StrideOrArg, C,
>> -                                    Expr::SE_AllowSideEffects)) {
>> +          Expr::EvalResult Result;
>> +          if (!(*SI)->EvaluateAsInt(Result, C,
>> Expr::SE_AllowSideEffects)) {
>>              if (const auto *DRE =
>>                      cast<DeclRefExpr>((*SI)->IgnoreParenImpCasts())) {
>>                if (const auto *StridePVD =
>> cast<ParmVarDecl>(DRE->getDecl())) {
>> @@ -9172,6 +9173,8 @@ void CGOpenMPRuntime::emitDeclareSimdFun
>>                      ParamPositions[StridePVD->getCanonicalDecl()]);
>>                }
>>              }
>> +          } else {
>> +            ParamAttr.StrideOrArg = Result.Val.getInt();
>>            }
>>          }
>>          ++SI;
>>
>> Modified: cfe/trunk/lib/CodeGen/CGStmt.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmt.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CGStmt.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CGStmt.cpp Tue Nov 20 15:24:16 2018
>> @@ -1822,9 +1822,9 @@ llvm::Value* CodeGenFunction::EmitAsmInp
>>    // If this can't be a register or memory, i.e., has to be a constant
>>    // (immediate or symbolic), try to emit it as such.
>>    if (!Info.allowsRegister() && !Info.allowsMemory()) {
>> -    llvm::APSInt Result;
>> +    Expr::EvalResult Result;
>>      if (InputExpr->EvaluateAsInt(Result, getContext()))
>> -      return llvm::ConstantInt::get(getLLVMContext(), Result);
>> +      return llvm::ConstantInt::get(getLLVMContext(),
>> Result.Val.getInt());
>>      assert(!Info.requiresImmediateConstant() &&
>>             "Required-immediate inlineasm arg isn't constant?");
>>    }
>>
>> Modified: cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp Tue Nov 20 15:24:16 2018
>> @@ -2321,9 +2321,11 @@ bool CodeGenFunction::EmitOMPWorksharing
>>          Chunk = EmitScalarConversion(Chunk, ChunkExpr->getType(),
>>                                       S.getIterationVariable()->getType(),
>>                                       S.getBeginLoc());
>> -        llvm::APSInt EvaluatedChunk;
>> -        if (ChunkExpr->EvaluateAsInt(EvaluatedChunk, getContext()))
>> +        Expr::EvalResult Result;
>> +        if (ChunkExpr->EvaluateAsInt(Result, getContext())) {
>> +          llvm::APSInt EvaluatedChunk = Result.Val.getInt();
>>            HasChunkSizeOne = (EvaluatedChunk.getLimitedValue() == 1);
>> +        }
>>        }
>>        const unsigned IVSize =
>> getContext().getTypeSize(IVExpr->getType());
>>        const bool IVSigned =
>> IVExpr->getType()->hasSignedIntegerRepresentation();
>>
>> Modified: cfe/trunk/lib/CodeGen/CodeGenFunction.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/CodeGen/CodeGenFunction.cpp (original)
>> +++ cfe/trunk/lib/CodeGen/CodeGenFunction.cpp Tue Nov 20 15:24:16 2018
>> @@ -1513,10 +1513,11 @@ bool CodeGenFunction::ConstantFoldsToSim
>>                                                     bool AllowLabels) {
>>    // FIXME: Rename and handle conversion of other evaluatable things
>>    // to bool.
>> -  llvm::APSInt Int;
>> -  if (!Cond->EvaluateAsInt(Int, getContext()))
>> +  Expr::EvalResult Result;
>> +  if (!Cond->EvaluateAsInt(Result, getContext()))
>>      return false;  // Not foldable, not integer or not fully evaluatable.
>>
>> +  llvm::APSInt Int = Result.Val.getInt();
>>    if (!AllowLabels && CodeGenFunction::ContainsLabel(Cond))
>>      return false;  // Contains a label.
>>
>>
>> Modified: cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp (original)
>> +++ cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp Tue Nov 20 15:24:16 2018
>> @@ -1309,11 +1309,10 @@ static bool isInLoop(const ASTContext &C
>>      case Stmt::ObjCForCollectionStmtClass:
>>        return true;
>>      case Stmt::DoStmtClass: {
>> -      const Expr *Cond = cast<DoStmt>(S)->getCond();
>> -      llvm::APSInt Val;
>> -      if (!Cond->EvaluateAsInt(Val, Ctx))
>> +      Expr::EvalResult Result;
>> +      if (!cast<DoStmt>(S)->getCond()->EvaluateAsInt(Result, Ctx))
>>          return true;
>> -      return Val.getBoolValue();
>> +      return Result.Val.getInt().getBoolValue();
>>      }
>>      default:
>>        break;
>>
>> Modified: cfe/trunk/lib/Sema/SemaCast.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaCast.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaCast.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaCast.cpp Tue Nov 20 15:24:16 2018
>> @@ -2554,8 +2554,9 @@ void CastOperation::CheckCStyleCast() {
>>
>>      // OpenCL v2.0 s6.13.10 - Allow casts from '0' to event_t type.
>>      if (Self.getLangOpts().OpenCL && DestType->isEventT()) {
>> -      llvm::APSInt CastInt;
>> -      if (SrcExpr.get()->EvaluateAsInt(CastInt, Self.Context)) {
>> +      Expr::EvalResult Result;
>> +      if (SrcExpr.get()->EvaluateAsInt(Result, Self.Context)) {
>> +        llvm::APSInt CastInt = Result.Val.getInt();
>>          if (0 == CastInt) {
>>            Kind = CK_ZeroToOCLOpaqueType;
>>            return;
>>
>> Modified: cfe/trunk/lib/Sema/SemaChecking.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaChecking.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaChecking.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaChecking.cpp Tue Nov 20 15:24:16 2018
>> @@ -247,13 +247,16 @@ static void SemaBuiltinMemChkCall(Sema &
>>    const Expr *SizeArg = TheCall->getArg(SizeIdx);
>>    const Expr *DstSizeArg = TheCall->getArg(DstSizeIdx);
>>
>> -  llvm::APSInt Size, DstSize;
>> +  Expr::EvalResult SizeResult, DstSizeResult;
>>
>>    // find out if both sizes are known at compile time
>> -  if (!SizeArg->EvaluateAsInt(Size, S.Context) ||
>> -      !DstSizeArg->EvaluateAsInt(DstSize, S.Context))
>> +  if (!SizeArg->EvaluateAsInt(SizeResult, S.Context) ||
>> +      !DstSizeArg->EvaluateAsInt(DstSizeResult, S.Context))
>>      return;
>>
>> +  llvm::APSInt Size = SizeResult.Val.getInt();
>> +  llvm::APSInt DstSize = DstSizeResult.Val.getInt();
>> +
>>    if (Size.ule(DstSize))
>>      return;
>>
>> @@ -6483,13 +6486,12 @@ checkFormatStringExpr(Sema &S, const Exp
>>      return SLCT_NotALiteral;
>>    }
>>    case Stmt::BinaryOperatorClass: {
>> -    llvm::APSInt LResult;
>> -    llvm::APSInt RResult;
>> -
>>      const BinaryOperator *BinOp = cast<BinaryOperator>(E);
>>
>>      // A string literal + an int offset is still a string literal.
>>      if (BinOp->isAdditiveOp()) {
>> +      Expr::EvalResult LResult, RResult;
>> +
>>        bool LIsInt = BinOp->getLHS()->EvaluateAsInt(LResult, S.Context);
>>        bool RIsInt = BinOp->getRHS()->EvaluateAsInt(RResult, S.Context);
>>
>> @@ -6498,12 +6500,12 @@ checkFormatStringExpr(Sema &S, const Exp
>>
>>          if (LIsInt) {
>>            if (BinOpKind == BO_Add) {
>> -            sumOffsets(Offset, LResult, BinOpKind, RIsInt);
>> +            sumOffsets(Offset, LResult.Val.getInt(), BinOpKind, RIsInt);
>>              E = BinOp->getRHS();
>>              goto tryAgain;
>>            }
>>          } else {
>> -          sumOffsets(Offset, RResult, BinOpKind, RIsInt);
>> +          sumOffsets(Offset, RResult.Val.getInt(), BinOpKind, RIsInt);
>>            E = BinOp->getLHS();
>>            goto tryAgain;
>>          }
>> @@ -6516,9 +6518,10 @@ checkFormatStringExpr(Sema &S, const Exp
>>      const UnaryOperator *UnaOp = cast<UnaryOperator>(E);
>>      auto ASE = dyn_cast<ArraySubscriptExpr>(UnaOp->getSubExpr());
>>      if (UnaOp->getOpcode() == UO_AddrOf && ASE) {
>> -      llvm::APSInt IndexResult;
>> +      Expr::EvalResult IndexResult;
>>        if (ASE->getRHS()->EvaluateAsInt(IndexResult, S.Context)) {
>> -        sumOffsets(Offset, IndexResult, BO_Add, /*RHS is int*/ true);
>> +        sumOffsets(Offset, IndexResult.Val.getInt(), BO_Add,
>> +                   /*RHS is int*/ true);
>>          E = ASE->getBase();
>>          goto tryAgain;
>>        }
>> @@ -10263,8 +10266,8 @@ static bool AnalyzeBitFieldAssignment(Se
>>    Expr *OriginalInit = Init->IgnoreParenImpCasts();
>>    unsigned FieldWidth = Bitfield->getBitWidthValue(S.Context);
>>
>> -  llvm::APSInt Value;
>> -  if (!OriginalInit->EvaluateAsInt(Value, S.Context,
>> +  Expr::EvalResult Result;
>> +  if (!OriginalInit->EvaluateAsInt(Result, S.Context,
>>                                     Expr::SE_AllowSideEffects)) {
>>      // The RHS is not constant.  If the RHS has an enum type, make sure
>> the
>>      // bitfield is wide enough to hold all the values of the enum without
>> @@ -10320,6 +10323,8 @@ static bool AnalyzeBitFieldAssignment(Se
>>      return false;
>>    }
>>
>> +  llvm::APSInt Value = Result.Val.getInt();
>> +
>>    unsigned OriginalWidth = Value.getBitWidth();
>>
>>    if (!Value.isSigned() || Value.isNegative())
>> @@ -10932,8 +10937,11 @@ CheckImplicitConversion(Sema &S, Expr *E
>>    if (SourceRange.Width > TargetRange.Width) {
>>      // If the source is a constant, use a default-on diagnostic.
>>      // TODO: this should happen for bitfield stores, too.
>> -    llvm::APSInt Value(32);
>> -    if (E->EvaluateAsInt(Value, S.Context, Expr::SE_AllowSideEffects)) {
>> +    Expr::EvalResult Result;
>> +    if (E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects)) {
>> +      llvm::APSInt Value(32);
>> +      Value = Result.Val.getInt();
>> +
>>        if (S.SourceMgr.isInSystemMacro(CC))
>>          return;
>>
>> @@ -10977,9 +10985,10 @@ CheckImplicitConversion(Sema &S, Expr *E
>>      // source value is exactly the width of the target type, which will
>>      // cause a negative value to be stored.
>>
>> -    llvm::APSInt Value;
>> -    if (E->EvaluateAsInt(Value, S.Context, Expr::SE_AllowSideEffects) &&
>> +    Expr::EvalResult Result;
>> +    if (E->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects) &&
>>          !S.SourceMgr.isInSystemMacro(CC)) {
>> +      llvm::APSInt Value = Result.Val.getInt();
>>        if (isSameWidthConstantConversion(S, E, T, CC)) {
>>          std::string PrettySourceValue = Value.toString(10);
>>          std::string PrettyTargetValue = PrettyPrintInRange(Value,
>> TargetRange);
>> @@ -12266,9 +12275,11 @@ void Sema::CheckArrayAccess(const Expr *
>>    if (!ArrayTy)
>>      return;
>>
>> -  llvm::APSInt index;
>> -  if (!IndexExpr->EvaluateAsInt(index, Context,
>> Expr::SE_AllowSideEffects))
>> +  Expr::EvalResult Result;
>> +  if (!IndexExpr->EvaluateAsInt(Result, Context,
>> Expr::SE_AllowSideEffects))
>>      return;
>> +
>> +  llvm::APSInt index = Result.Val.getInt();
>>    if (IndexNegated)
>>      index = -index;
>>
>>
>> Modified: cfe/trunk/lib/Sema/SemaDecl.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDecl.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaDecl.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaDecl.cpp Tue Nov 20 15:24:16 2018
>> @@ -5575,11 +5575,13 @@ static QualType TryToFixInvalidVariablyM
>>    if (VLATy->getElementType()->isVariablyModifiedType())
>>      return QualType();
>>
>> -  llvm::APSInt Res;
>> +  Expr::EvalResult Result;
>>    if (!VLATy->getSizeExpr() ||
>> -      !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
>> +      !VLATy->getSizeExpr()->EvaluateAsInt(Result, Context))
>>      return QualType();
>>
>> +  llvm::APSInt Res = Result.Val.getInt();
>> +
>>    // Check whether the array size is negative.
>>    if (Res.isSigned() && Res.isNegative()) {
>>      SizeIsNegative = true;
>>
>> Modified: cfe/trunk/lib/Sema/SemaDeclCXX.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclCXX.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaDeclCXX.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaDeclCXX.cpp Tue Nov 20 15:24:16 2018
>> @@ -13860,6 +13860,8 @@ Decl *Sema::BuildStaticAssertDeclaration
>>      ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
>>      if (Converted.isInvalid())
>>        Failed = true;
>> +    else
>> +      Converted = ConstantExpr::Create(Context, Converted.get());
>>
>>      llvm::APSInt Cond;
>>      if (!Failed && VerifyIntegerConstantExpression(Converted.get(),
>> &Cond,
>>
>> Modified: cfe/trunk/lib/Sema/SemaExpr.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaExpr.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaExpr.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaExpr.cpp Tue Nov 20 15:24:16 2018
>> @@ -4376,10 +4376,11 @@ ExprResult Sema::ActOnOMPArraySectionExp
>>      return ExprError();
>>
>>    if (LowerBound && !OriginalTy->isAnyPointerType()) {
>> -    llvm::APSInt LowerBoundValue;
>> -    if (LowerBound->EvaluateAsInt(LowerBoundValue, Context)) {
>> +    Expr::EvalResult Result;
>> +    if (LowerBound->EvaluateAsInt(Result, Context)) {
>>        // OpenMP 4.5, [2.4 Array Sections]
>>        // The array section must be a subset of the original array.
>> +      llvm::APSInt LowerBoundValue = Result.Val.getInt();
>>        if (LowerBoundValue.isNegative()) {
>>          Diag(LowerBound->getExprLoc(),
>> diag::err_omp_section_not_subset_of_array)
>>              << LowerBound->getSourceRange();
>> @@ -4389,10 +4390,11 @@ ExprResult Sema::ActOnOMPArraySectionExp
>>    }
>>
>>    if (Length) {
>> -    llvm::APSInt LengthValue;
>> -    if (Length->EvaluateAsInt(LengthValue, Context)) {
>> +    Expr::EvalResult Result;
>> +    if (Length->EvaluateAsInt(Result, Context)) {
>>        // OpenMP 4.5, [2.4 Array Sections]
>>        // The length must evaluate to non-negative integers.
>> +      llvm::APSInt LengthValue = Result.Val.getInt();
>>        if (LengthValue.isNegative()) {
>>          Diag(Length->getExprLoc(), diag::err_omp_section_length_negative)
>>              << LengthValue.toString(/*Radix=*/10, /*Signed=*/true)
>> @@ -5795,6 +5797,8 @@ Sema::BuildCompoundLiteralExpr(SourceLoc
>>            ? VK_RValue
>>            : VK_LValue;
>>
>> +  if (isFileScope)
>> +    LiteralExpr = ConstantExpr::Create(Context, LiteralExpr);
>>    Expr *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo,
>> literalType,
>>                                                VK, LiteralExpr,
>> isFileScope);
>>    if (isFileScope) {
>> @@ -5803,7 +5807,6 @@ Sema::BuildCompoundLiteralExpr(SourceLoc
>>          !literalType->isDependentType()) // C99 6.5.2.5p3
>>        if (CheckForConstantInitializer(LiteralExpr, literalType))
>>          return ExprError();
>> -    E = new (Context) ConstantExpr(E);
>>    } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
>>               literalType.getAddressSpace() != LangAS::Default) {
>>      // Embedded-C extensions to C99 6.5.2.5:
>> @@ -8399,8 +8402,8 @@ static bool canConvertIntToOtherIntTy(Se
>>    // Reject cases where the value of the Int is unknown as that would
>>    // possibly cause truncation, but accept cases where the scalar can be
>>    // demoted without loss of precision.
>> -  llvm::APSInt Result;
>> -  bool CstInt = Int->get()->EvaluateAsInt(Result, S.Context);
>> +  Expr::EvalResult EVResult;
>> +  bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.Context);
>>    int Order = S.Context.getIntegerTypeOrder(OtherIntTy, IntTy);
>>    bool IntSigned = IntTy->hasSignedIntegerRepresentation();
>>    bool OtherIntSigned = OtherIntTy->hasSignedIntegerRepresentation();
>> @@ -8408,6 +8411,7 @@ static bool canConvertIntToOtherIntTy(Se
>>    if (CstInt) {
>>      // If the scalar is constant and is of a higher order and has more
>> active
>>      // bits that the vector element type, reject it.
>> +    llvm::APSInt Result = EVResult.Val.getInt();
>>      unsigned NumBits = IntSigned
>>                             ? (Result.isNegative() ?
>> Result.getMinSignedBits()
>>                                                    :
>> Result.getActiveBits())
>> @@ -8435,8 +8439,9 @@ static bool canConvertIntTyToFloatTy(Sem
>>
>>    // Determine if the integer constant can be expressed as a floating
>> point
>>    // number of the appropriate type.
>> -  llvm::APSInt Result;
>> -  bool CstInt = Int->get()->EvaluateAsInt(Result, S.Context);
>> +  Expr::EvalResult EVResult;
>> +  bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.Context);
>> +
>>    uint64_t Bits = 0;
>>    if (CstInt) {
>>      // Reject constants that would be truncated if they were converted to
>> @@ -8444,6 +8449,7 @@ static bool canConvertIntTyToFloatTy(Sem
>>      // FIXME: Ideally the conversion to an APFloat and from an APFloat
>>      //        could be avoided if there was a convertFromAPInt method
>>      //        which could signal back if implicit truncation occurred.
>> +    llvm::APSInt Result = EVResult.Val.getInt();
>>      llvm::APFloat Float(S.Context.getFloatTypeSemantics(FloatTy));
>>      Float.convertFromAPInt(Result,
>> IntTy->hasSignedIntegerRepresentation(),
>>                             llvm::APFloat::rmTowardZero);
>> @@ -8783,9 +8789,10 @@ static void DiagnoseBadDivideOrRemainder
>>                                                 ExprResult &RHS,
>>                                                 SourceLocation Loc, bool
>> IsDiv) {
>>    // Check for division/remainder by zero.
>> -  llvm::APSInt RHSValue;
>> +  Expr::EvalResult RHSValue;
>>    if (!RHS.get()->isValueDependent() &&
>> -      RHS.get()->EvaluateAsInt(RHSValue, S.Context) && RHSValue == 0)
>> +      RHS.get()->EvaluateAsInt(RHSValue, S.Context) &&
>> +      RHSValue.Val.getInt() == 0)
>>      S.DiagRuntimeBehavior(Loc, RHS.get(),
>>                            S.PDiag(diag::warn_remainder_division_by_zero)
>>                              << IsDiv << RHS.get()->getSourceRange());
>> @@ -9027,8 +9034,9 @@ static void diagnoseStringPlusInt(Sema &
>>    if (!IsStringPlusInt || IndexExpr->isValueDependent())
>>      return;
>>
>> -  llvm::APSInt index;
>> -  if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) {
>> +  Expr::EvalResult Result;
>> +  if (IndexExpr->EvaluateAsInt(Result, Self.getASTContext())) {
>> +    llvm::APSInt index = Result.Val.getInt();
>>      unsigned StrLenWithNull = StrExpr->getLength() + 1;
>>      if (index.isNonNegative() &&
>>          index <= llvm::APSInt(llvm::APInt(index.getBitWidth(),
>> StrLenWithNull),
>> @@ -9172,10 +9180,11 @@ QualType Sema::CheckAdditionOperands(Exp
>>    if (PExp->IgnoreParenCasts()->isNullPointerConstant(
>>            Context, Expr::NPC_ValueDependentIsNotNull)) {
>>      // In C++ adding zero to a null pointer is defined.
>> -    llvm::APSInt KnownVal;
>> +    Expr::EvalResult KnownVal;
>>      if (!getLangOpts().CPlusPlus ||
>>          (!IExp->isValueDependent() &&
>> -         (!IExp->EvaluateAsInt(KnownVal, Context) || KnownVal != 0))) {
>> +         (!IExp->EvaluateAsInt(KnownVal, Context) ||
>> +          KnownVal.Val.getInt() != 0))) {
>>        // Check the conditions to see if this is the 'p = nullptr + n'
>> idiom.
>>        bool IsGNUIdiom = BinaryOperator::isNullPointerArithmeticExtension(
>>            Context, BO_Add, PExp, IExp);
>> @@ -9250,10 +9259,11 @@ QualType Sema::CheckSubtractionOperands(
>>        if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(Context,
>>
>> Expr::NPC_ValueDependentIsNotNull)) {
>>          // In C++ adding zero to a null pointer is defined.
>> -        llvm::APSInt KnownVal;
>> +        Expr::EvalResult KnownVal;
>>          if (!getLangOpts().CPlusPlus ||
>>              (!RHS.get()->isValueDependent() &&
>> -             (!RHS.get()->EvaluateAsInt(KnownVal, Context) || KnownVal
>> != 0))) {
>> +             (!RHS.get()->EvaluateAsInt(KnownVal, Context) ||
>> +              KnownVal.Val.getInt() != 0))) {
>>            diagnoseArithmeticOnNullPointer(*this, Loc, LHS.get(), false);
>>          }
>>        }
>> @@ -9329,11 +9339,12 @@ static void DiagnoseBadShiftValues(Sema&
>>    if (S.getLangOpts().OpenCL)
>>      return;
>>
>> -  llvm::APSInt Right;
>>    // Check right/shifter operand
>> +  Expr::EvalResult RHSResult;
>>    if (RHS.get()->isValueDependent() ||
>> -      !RHS.get()->EvaluateAsInt(Right, S.Context))
>> +      !RHS.get()->EvaluateAsInt(RHSResult, S.Context))
>>      return;
>> +  llvm::APSInt Right = RHSResult.Val.getInt();
>>
>>    if (Right.isNegative()) {
>>      S.DiagRuntimeBehavior(Loc, RHS.get(),
>> @@ -9356,11 +9367,12 @@ static void DiagnoseBadShiftValues(Sema&
>>    // according to C++ has undefined behavior ([expr.shift] 5.8/2).
>> Unsigned
>>    // integers have defined behavior modulo one more than the maximum
>> value
>>    // representable in the result type, so never warn for those.
>> -  llvm::APSInt Left;
>> +  Expr::EvalResult LHSResult;
>>    if (LHS.get()->isValueDependent() ||
>>        LHSType->hasUnsignedIntegerRepresentation() ||
>> -      !LHS.get()->EvaluateAsInt(Left, S.Context))
>> +      !LHS.get()->EvaluateAsInt(LHSResult, S.Context))
>>      return;
>> +  llvm::APSInt Left = LHSResult.Val.getInt();
>>
>>    // If LHS does not have a signed type and non-negative value
>>    // then, the behavior is undefined. Warn about it.
>> @@ -10730,8 +10742,9 @@ inline QualType Sema::CheckLogicalOperan
>>      // that isn't 0 or 1 (which indicate a potential logical operation
>> that
>>      // happened to fold to true/false) then warn.
>>      // Parens on the RHS are ignored.
>> -    llvm::APSInt Result;
>> -    if (RHS.get()->EvaluateAsInt(Result, Context))
>> +    Expr::EvalResult EVResult;
>> +    if (RHS.get()->EvaluateAsInt(EVResult, Context)) {
>> +      llvm::APSInt Result = EVResult.Val.getInt();
>>        if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType()
>> &&
>>             !RHS.get()->getExprLoc().isMacroID()) ||
>>            (Result != 0 && Result != 1)) {
>> @@ -10751,6 +10764,7 @@ inline QualType Sema::CheckLogicalOperan
>>
>> SourceRange(getLocForEndOfToken(LHS.get()->getEndLoc()),
>>                                   RHS.get()->getEndLoc()));
>>        }
>> +    }
>>    }
>>
>>    if (!Context.getLangOpts().CPlusPlus) {
>> @@ -14166,12 +14180,15 @@ Sema::VerifyIntegerConstantExpression(Ex
>>      return ExprError();
>>    }
>>
>> +  if (!isa<ConstantExpr>(E))
>> +    E = ConstantExpr::Create(Context, E);
>> +
>>    // Circumvent ICE checking in C++11 to avoid evaluating the expression
>> twice
>>    // in the non-ICE case.
>>    if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) {
>>      if (Result)
>>        *Result = E->EvaluateKnownConstIntCheckOverflow(Context);
>> -    return new (Context) ConstantExpr(E);
>> +    return E;
>>    }
>>
>>    Expr::EvalResult EvalResult;
>> @@ -14189,7 +14206,7 @@ Sema::VerifyIntegerConstantExpression(Ex
>>    if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
>>      if (Result)
>>        *Result = EvalResult.Val.getInt();
>> -    return new (Context) ConstantExpr(E);
>> +    return E;
>>    }
>>
>>    // If our only note is the usual "invalid subexpression" note, just
>> point
>> @@ -14217,7 +14234,7 @@ Sema::VerifyIntegerConstantExpression(Ex
>>
>>    if (Result)
>>      *Result = EvalResult.Val.getInt();
>> -  return new (Context) ConstantExpr(E);
>> +  return E;
>>  }
>>
>>  namespace {
>>
>> Modified: cfe/trunk/lib/Sema/SemaInit.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaInit.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaInit.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaInit.cpp Tue Nov 20 15:24:16 2018
>> @@ -8050,8 +8050,9 @@ ExprResult InitializationSequence::Perfo
>>            break;
>>          }
>>
>> -        llvm::APSInt Result;
>> -        Init->EvaluateAsInt(Result, S.Context);
>> +        Expr::EvalResult EVResult;
>> +        Init->EvaluateAsInt(EVResult, S.Context);
>> +        llvm::APSInt Result = EVResult.Val.getInt();
>>          const uint64_t SamplerValue = Result.getLimitedValue();
>>          // 32-bit value of sampler's initializer is interpreted as
>>          // bit-field with the following structure:
>>
>> Modified: cfe/trunk/lib/Sema/SemaOpenMP.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaOpenMP.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaOpenMP.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaOpenMP.cpp Tue Nov 20 15:24:16 2018
>> @@ -5020,15 +5020,16 @@ checkOpenMPLoop(OpenMPDirectiveKind DKin
>>    unsigned NestedLoopCount = 1;
>>    if (CollapseLoopCountExpr) {
>>      // Found 'collapse' clause - calculate collapse number.
>> -    llvm::APSInt Result;
>> +    Expr::EvalResult Result;
>>      if (CollapseLoopCountExpr->EvaluateAsInt(Result,
>> SemaRef.getASTContext()))
>> -      NestedLoopCount = Result.getLimitedValue();
>> +      NestedLoopCount = Result.Val.getInt().getLimitedValue();
>>    }
>>    unsigned OrderedLoopCount = 1;
>>    if (OrderedLoopCountExpr) {
>>      // Found 'ordered' clause - calculate collapse number.
>> -    llvm::APSInt Result;
>> -    if (OrderedLoopCountExpr->EvaluateAsInt(Result,
>> SemaRef.getASTContext())) {
>> +    Expr::EvalResult EVResult;
>> +    if (OrderedLoopCountExpr->EvaluateAsInt(EVResult,
>> SemaRef.getASTContext())) {
>> +      llvm::APSInt Result = EVResult.Val.getInt();
>>        if (Result.getLimitedValue() < NestedLoopCount) {
>>          SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(),
>>                       diag::err_omp_wrong_ordered_loop_count)
>> @@ -5624,7 +5625,6 @@ static bool checkSimdlenSafelenSpecified
>>    }
>>
>>    if (Simdlen && Safelen) {
>> -    llvm::APSInt SimdlenRes, SafelenRes;
>>      const Expr *SimdlenLength = Simdlen->getSimdlen();
>>      const Expr *SafelenLength = Safelen->getSafelen();
>>      if (SimdlenLength->isValueDependent() ||
>> SimdlenLength->isTypeDependent() ||
>> @@ -5635,8 +5635,11 @@ static bool checkSimdlenSafelenSpecified
>>          SafelenLength->isInstantiationDependent() ||
>>          SafelenLength->containsUnexpandedParameterPack())
>>        return false;
>> -    SimdlenLength->EvaluateAsInt(SimdlenRes, S.Context);
>> -    SafelenLength->EvaluateAsInt(SafelenRes, S.Context);
>> +    Expr::EvalResult SimdlenResult, SafelenResult;
>> +    SimdlenLength->EvaluateAsInt(SimdlenResult, S.Context);
>> +    SafelenLength->EvaluateAsInt(SafelenResult, S.Context);
>> +    llvm::APSInt SimdlenRes = SimdlenResult.Val.getInt();
>> +    llvm::APSInt SafelenRes = SafelenResult.Val.getInt();
>>      // OpenMP 4.5 [2.8.1, simd Construct, Restrictions]
>>      // If both simdlen and safelen clauses are specified, the value of
>> the
>>      // simdlen parameter must be less than or equal to the value of the
>> safelen
>> @@ -10641,10 +10644,11 @@ static bool checkOMPArraySectionConstant
>>      SingleElement = true;
>>      ArraySizes.push_back(llvm::APSInt::get(1));
>>    } else {
>> -    llvm::APSInt ConstantLengthValue;
>> -    if (!Length->EvaluateAsInt(ConstantLengthValue, Context))
>> +    Expr::EvalResult Result;
>> +    if (!Length->EvaluateAsInt(Result, Context))
>>        return false;
>>
>> +    llvm::APSInt ConstantLengthValue = Result.Val.getInt();
>>      SingleElement = (ConstantLengthValue.getSExtValue() == 1);
>>      ArraySizes.push_back(ConstantLengthValue);
>>    }
>> @@ -10665,9 +10669,12 @@ static bool checkOMPArraySectionConstant
>>        // This is an array subscript which has implicit length 1!
>>        ArraySizes.push_back(llvm::APSInt::get(1));
>>      } else {
>> -      llvm::APSInt ConstantLengthValue;
>> -      if (!Length->EvaluateAsInt(ConstantLengthValue, Context) ||
>> -          ConstantLengthValue.getSExtValue() != 1)
>> +      Expr::EvalResult Result;
>> +      if (!Length->EvaluateAsInt(Result, Context))
>> +        return false;
>> +
>> +      llvm::APSInt ConstantLengthValue = Result.Val.getInt();
>> +      if (ConstantLengthValue.getSExtValue() != 1)
>>          return false;
>>
>>        ArraySizes.push_back(ConstantLengthValue);
>> @@ -12190,9 +12197,11 @@ static bool checkArrayExpressionDoesNotR
>>    // If there is a lower bound that does not evaluates to zero, we are
>> not
>>    // covering the whole dimension.
>>    if (LowerBound) {
>> -    llvm::APSInt ConstLowerBound;
>> -    if (!LowerBound->EvaluateAsInt(ConstLowerBound,
>> SemaRef.getASTContext()))
>> +    Expr::EvalResult Result;
>> +    if (!LowerBound->EvaluateAsInt(Result, SemaRef.getASTContext()))
>>        return false; // Can't get the integer value as a constant.
>> +
>> +    llvm::APSInt ConstLowerBound = Result.Val.getInt();
>>      if (ConstLowerBound.getSExtValue())
>>        return true;
>>    }
>> @@ -12212,10 +12221,11 @@ static bool checkArrayExpressionDoesNotR
>>    if (!CATy)
>>      return false;
>>
>> -  llvm::APSInt ConstLength;
>> -  if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
>> +  Expr::EvalResult Result;
>> +  if (!Length->EvaluateAsInt(Result, SemaRef.getASTContext()))
>>      return false; // Can't get the integer value as a constant.
>>
>> +  llvm::APSInt ConstLength = Result.Val.getInt();
>>    return CATy->getSize().getSExtValue() != ConstLength.getSExtValue();
>>  }
>>
>> @@ -12246,10 +12256,11 @@ static bool checkArrayExpressionDoesNotR
>>    }
>>
>>    // Check if the length evaluates to 1.
>> -  llvm::APSInt ConstLength;
>> -  if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext()))
>> +  Expr::EvalResult Result;
>> +  if (!Length->EvaluateAsInt(Result, SemaRef.getASTContext()))
>>      return false; // Can't get the integer value as a constant.
>>
>> +  llvm::APSInt ConstLength = Result.Val.getInt();
>>    return ConstLength.getSExtValue() != 1;
>>  }
>>
>>
>> Modified: cfe/trunk/lib/Sema/SemaOverload.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaOverload.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaOverload.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaOverload.cpp Tue Nov 20 15:24:16 2018
>> @@ -5469,7 +5469,7 @@ static ExprResult CheckConvertedConstant
>>
>>      if (Notes.empty()) {
>>        // It's a constant expression.
>> -      return new (S.Context) ConstantExpr(Result.get());
>> +      return ConstantExpr::Create(S.Context, Result.get());
>>      }
>>    }
>>
>>
>> Modified: cfe/trunk/lib/Sema/SemaStmt.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaStmt.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaStmt.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaStmt.cpp Tue Nov 20 15:24:16 2018
>> @@ -945,8 +945,11 @@ Sema::ActOnFinishSwitchStmt(SourceLocati
>>      llvm::APSInt ConstantCondValue;
>>      bool HasConstantCond = false;
>>      if (!HasDependentValue && !TheDefaultStmt) {
>> -      HasConstantCond = CondExpr->EvaluateAsInt(ConstantCondValue,
>> Context,
>> +      Expr::EvalResult Result;
>> +      HasConstantCond = CondExpr->EvaluateAsInt(Result, Context,
>>
>>  Expr::SE_AllowSideEffects);
>> +      if (Result.Val.isInt())
>> +        ConstantCondValue = Result.Val.getInt();
>>        assert(!HasConstantCond ||
>>               (ConstantCondValue.getBitWidth() == CondWidth &&
>>                ConstantCondValue.isSigned() == CondIsSigned));
>>
>> Modified: cfe/trunk/lib/Sema/SemaStmtAsm.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaStmtAsm.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaStmtAsm.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaStmtAsm.cpp Tue Nov 20 15:24:16 2018
>> @@ -378,11 +378,12 @@ StmtResult Sema::ActOnGCCAsmStmt(SourceL
>>                           << InputExpr->getSourceRange());
>>      } else if (Info.requiresImmediateConstant() &&
>> !Info.allowsRegister()) {
>>        if (!InputExpr->isValueDependent()) {
>> -        llvm::APSInt Result;
>> -        if (!InputExpr->EvaluateAsInt(Result, Context))
>> +        Expr::EvalResult EVResult;
>> +        if (!InputExpr->EvaluateAsInt(EVResult, Context))
>>            return StmtError(
>>                Diag(InputExpr->getBeginLoc(),
>> diag::err_asm_immediate_expected)
>>                << Info.getConstraintStr() << InputExpr->getSourceRange());
>> +        llvm::APSInt Result = EVResult.Val.getInt();
>>           if (!Info.isValidAsmImmediate(Result))
>>             return StmtError(Diag(InputExpr->getBeginLoc(),
>>
>> diag::err_invalid_asm_value_for_constraint)
>>
>> Modified: cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp Tue Nov 20 15:24:16 2018
>> @@ -178,6 +178,8 @@ getDeducedParameterFromExpr(TemplateDedu
>>    while (true) {
>>      if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
>>        E = IC->getSubExpr();
>> +    else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E))
>> +      E = CE->getSubExpr();
>>      else if (SubstNonTypeTemplateParmExpr *Subst =
>>                 dyn_cast<SubstNonTypeTemplateParmExpr>(E))
>>        E = Subst->getReplacement();
>> @@ -5225,6 +5227,8 @@ MarkUsedTemplateParameters(ASTContext &C
>>    while (true) {
>>      if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
>>        E = ICE->getSubExpr();
>> +    else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(E))
>> +      E = CE->getSubExpr();
>>      else if (const SubstNonTypeTemplateParmExpr *Subst =
>>                 dyn_cast<SubstNonTypeTemplateParmExpr>(E))
>>        E = Subst->getReplacement();
>>
>> Modified: cfe/trunk/lib/Sema/SemaType.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaType.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/Sema/SemaType.cpp (original)
>> +++ cfe/trunk/lib/Sema/SemaType.cpp Tue Nov 20 15:24:16 2018
>> @@ -2233,10 +2233,6 @@ QualType Sema::BuildArrayType(QualType T
>>      T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
>>    }
>>
>> -  if (ArraySize && !CurContext->isFunctionOrMethod())
>> -    // A file-scoped array must have a constant array size.
>> -    ArraySize = new (Context) ConstantExpr(ArraySize);
>> -
>>    // OpenCL v1.2 s6.9.d: variable length arrays are not supported.
>>    if (getLangOpts().OpenCL && T->isVariableArrayType()) {
>>      Diag(Loc, diag::err_opencl_vla);
>>
>> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp
>> (original)
>> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/BuiltinFunctionChecker.cpp Tue
>> Nov 20 15:24:16 2018
>> @@ -101,9 +101,10 @@ bool BuiltinFunctionChecker::evalCall(co
>>      // This must be resolvable at compile time, so we defer to the
>> constant
>>      // evaluator for a value.
>>      SVal V = UnknownVal();
>> -    llvm::APSInt Result;
>> -    if (CE->EvaluateAsInt(Result, C.getASTContext(),
>> Expr::SE_NoSideEffects)) {
>> +    Expr::EvalResult EVResult;
>> +    if (CE->EvaluateAsInt(EVResult, C.getASTContext(),
>> Expr::SE_NoSideEffects)) {
>>        // Make sure the result has the correct type.
>> +      llvm::APSInt Result = EVResult.Val.getInt();
>>        SValBuilder &SVB = C.getSValBuilder();
>>        BasicValueFactory &BVF = SVB.getBasicValueFactory();
>>        BVF.getAPSIntType(CE->getType()).apply(Result);
>>
>> Modified:
>> cfe/trunk/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp
>> (original)
>> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp Tue
>> Nov 20 15:24:16 2018
>> @@ -597,9 +597,10 @@ void WalkAST::checkCall_mkstemp(const Ca
>>    unsigned suffix = 0;
>>    if (ArgSuffix.second >= 0) {
>>      const Expr *suffixEx = CE->getArg((unsigned)ArgSuffix.second);
>> -    llvm::APSInt Result;
>> -    if (!suffixEx->EvaluateAsInt(Result, BR.getContext()))
>> +    Expr::EvalResult EVResult;
>> +    if (!suffixEx->EvaluateAsInt(EVResult, BR.getContext()))
>>        return;
>> +    llvm::APSInt Result = EVResult.Val.getInt();
>>      // FIXME: Issue a warning.
>>      if (Result.isNegative())
>>        return;
>>
>> Modified:
>> cfe/trunk/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> ---
>> cfe/trunk/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
>> (original)
>> +++
>> cfe/trunk/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp Tue
>> Nov 20 15:24:16 2018
>> @@ -135,9 +135,9 @@ private:
>>      bool isIntZeroExpr(const Expr *E) const {
>>        if (!E->getType()->isIntegralOrEnumerationType())
>>          return false;
>> -      llvm::APSInt Result;
>> +      Expr::EvalResult Result;
>>        if (E->EvaluateAsInt(Result, Context))
>> -        return Result == 0;
>> +        return Result.Val.getInt() == 0;
>>        return false;
>>      }
>>
>> @@ -191,8 +191,11 @@ private:
>>        if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(rhse)) {
>>          if (BOp->getOpcode() == BO_Div) {
>>            const Expr *denom = BOp->getRHS()->IgnoreParenImpCasts();
>> -          if (denom->EvaluateAsInt(denomVal, Context))
>> +          Expr::EvalResult Result;
>> +          if (denom->EvaluateAsInt(Result, Context)) {
>> +            denomVal = Result.Val.getInt();
>>              denomKnown = true;
>> +          }
>>            const Expr *numerator = BOp->getLHS()->IgnoreParenImpCasts();
>>            if (numerator->isEvaluatable(Context))
>>              numeratorKnown = true;
>>
>> Modified:
>> cfe/trunk/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> ---
>> cfe/trunk/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp
>> (original)
>> +++
>> cfe/trunk/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp Tue
>> Nov 20 15:24:16 2018
>> @@ -87,9 +87,10 @@ void Callback::run(const MatchFinder::Ma
>>          MacroIndicatesWeShouldSkipTheCheck = true;
>>      }
>>      if (!MacroIndicatesWeShouldSkipTheCheck) {
>> -      llvm::APSInt Result;
>> +      Expr::EvalResult EVResult;
>>        if (CheckIfNull->IgnoreParenCasts()->EvaluateAsInt(
>> -              Result, ACtx, Expr::SE_AllowSideEffects)) {
>> +              EVResult, ACtx, Expr::SE_AllowSideEffects)) {
>> +        llvm::APSInt Result = EVResult.Val.getInt();
>>          if (Result == 0) {
>>            if (!C->Pedantic)
>>              return;
>>
>> Modified: cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp (original)
>> +++ cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp Tue Nov 20 15:24:16
>> 2018
>> @@ -1283,9 +1283,6 @@ void ExprEngine::Visit(const Stmt *S, Ex
>>        break;
>>
>>      case Expr::ConstantExprClass:
>> -      // Handled due to it being a wrapper class.
>> -      break;
>> -
>>      case Stmt::ExprWithCleanupsClass:
>>        // Handled due to fully linearised CFG.
>>        break;
>>
>> Modified: cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp (original)
>> +++ cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineC.cpp Tue Nov 20 15:24:16
>> 2018
>> @@ -810,8 +810,9 @@ void ExprEngine::
>>  VisitOffsetOfExpr(const OffsetOfExpr *OOE,
>>                    ExplodedNode *Pred, ExplodedNodeSet &Dst) {
>>    StmtNodeBuilder B(Pred, Dst, *currBldrCtx);
>> -  APSInt IV;
>> -  if (OOE->EvaluateAsInt(IV, getContext())) {
>> +  Expr::EvalResult Result;
>> +  if (OOE->EvaluateAsInt(Result, getContext())) {
>> +    APSInt IV = Result.Val.getInt();
>>      assert(IV.getBitWidth() == getContext().getTypeSize(OOE->getType()));
>>      assert(OOE->getType()->isBuiltinType());
>>      assert(OOE->getType()->getAs<BuiltinType>()->isInteger());
>>
>> Modified: cfe/trunk/lib/StaticAnalyzer/Core/SValBuilder.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/SValBuilder.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/lib/StaticAnalyzer/Core/SValBuilder.cpp (original)
>> +++ cfe/trunk/lib/StaticAnalyzer/Core/SValBuilder.cpp Tue Nov 20 15:24:16
>> 2018
>> @@ -362,9 +362,9 @@ Optional<SVal> SValBuilder::getConstantV
>>        return None;
>>
>>      ASTContext &Ctx = getContext();
>> -    llvm::APSInt Result;
>> +    Expr::EvalResult Result;
>>      if (E->EvaluateAsInt(Result, Ctx))
>> -      return makeIntVal(Result);
>> +      return makeIntVal(Result.Val.getInt());
>>
>>      if (Loc::isLocType(E->getType()))
>>        if (E->isNullPointerConstant(Ctx,
>> Expr::NPC_ValueDependentIsNotNull))
>>
>> Modified: cfe/trunk/test/Analysis/builtin-functions.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Analysis/builtin-functions.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/test/Analysis/builtin-functions.cpp (original)
>> +++ cfe/trunk/test/Analysis/builtin-functions.cpp Tue Nov 20 15:24:16 2018
>> @@ -70,14 +70,14 @@ void test_constant_p() {
>>    const int j = 2;
>>    constexpr int k = 3;
>>    clang_analyzer_eval(__builtin_constant_p(42) == 1); //
>> expected-warning {{TRUE}}
>> -  clang_analyzer_eval(__builtin_constant_p(i) == 0); // expected-warning
>> {{TRUE}}
>> +  clang_analyzer_eval(__builtin_constant_p(i) == 0); // expected-warning
>> {{UNKNOWN}}
>>    clang_analyzer_eval(__builtin_constant_p(j) == 1); // expected-warning
>> {{TRUE}}
>>    clang_analyzer_eval(__builtin_constant_p(k) == 1); // expected-warning
>> {{TRUE}}
>> -  clang_analyzer_eval(__builtin_constant_p(i + 42) == 0); //
>> expected-warning {{TRUE}}
>> +  clang_analyzer_eval(__builtin_constant_p(i + 42) == 0); //
>> expected-warning {{UNKNOWN}}
>>    clang_analyzer_eval(__builtin_constant_p(j + 42) == 1); //
>> expected-warning {{TRUE}}
>>    clang_analyzer_eval(__builtin_constant_p(k + 42) == 1); //
>> expected-warning {{TRUE}}
>>    clang_analyzer_eval(__builtin_constant_p(" ") == 1); //
>> expected-warning {{TRUE}}
>> -  clang_analyzer_eval(__builtin_constant_p(test_constant_p) == 0); //
>> expected-warning {{TRUE}}
>> +  clang_analyzer_eval(__builtin_constant_p(test_constant_p) == 0); //
>> expected-warning {{UNKNOWN}}
>>    clang_analyzer_eval(__builtin_constant_p(k - 3) == 0); //
>> expected-warning {{FALSE}}
>>    clang_analyzer_eval(__builtin_constant_p(k - 3) == 1); //
>> expected-warning {{TRUE}}
>>  }
>>
>> Modified: cfe/trunk/test/Sema/builtins.c
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Sema/builtins.c?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/test/Sema/builtins.c (original)
>> +++ cfe/trunk/test/Sema/builtins.c Tue Nov 20 15:24:16 2018
>> @@ -122,6 +122,14 @@ int test16() {
>>           __builtin_constant_p(1, 2); // expected-error {{too many
>> arguments}}
>>  }
>>
>> +// __builtin_constant_p cannot resolve non-constants as a file scoped
>> array.
>> +int expr;
>> +char y[__builtin_constant_p(expr) ? -1 : 1]; // no warning, the builtin
>> is false.
>> +
>> +// no warning, the builtin is false.
>> +struct foo { int a; };
>> +struct foo x = (struct foo) { __builtin_constant_p(42) ? 37 : 927 };
>> +
>>  const int test17_n = 0;
>>  const char test17_c[] = {1, 2, 3, 0};
>>  const char test17_d[] = {1, 2, 3, 4};
>> @@ -161,6 +169,7 @@ void test17() {
>>    F(&test17_d);
>>    F((struct Aggregate){0, 1});
>>    F((IntVector){0, 1, 2, 3});
>> +  F(test17);
>>
>>    // Ensure that a technique used in glibc is handled correctly.
>>  #define OPT(...) (__builtin_constant_p(__VA_ARGS__) &&
>> strlen(__VA_ARGS__) < 4)
>>
>> Modified: cfe/trunk/test/SemaCXX/compound-literal.cpp
>> URL:
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/compound-literal.cpp?rev=347364&r1=347363&r2=347364&view=diff
>>
>> ==============================================================================
>> --- cfe/trunk/test/SemaCXX/compound-literal.cpp (original)
>> +++ cfe/trunk/test/SemaCXX/compound-literal.cpp Tue Nov 20 15:24:16 2018
>> @@ -36,8 +36,8 @@ namespace brace_initializers {
>>
>>    POD p = (POD){1, 2};
>>    // CHECK-NOT: CXXBindTemporaryExpr {{.*}} 'brace_initializers::POD'
>> -  // CHECK: ConstantExpr {{.*}} 'brace_initializers::POD'
>> -  // CHECK-NEXT: CompoundLiteralExpr {{.*}} 'brace_initializers::POD'
>> +  // CHECK: CompoundLiteralExpr {{.*}} 'brace_initializers::POD'
>> +  // CHECK-NEXT: ConstantExpr {{.*}} 'brace_initializers::POD'
>>    // CHECK-NEXT: InitListExpr {{.*}} 'brace_initializers::POD'
>>    // CHECK-NEXT: IntegerLiteral {{.*}} 1{{$}}
>>    // CHECK-NEXT: IntegerLiteral {{.*}} 2{{$}}
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at lists.llvm.org
>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20181121/e1196544/attachment-0001.html>


More information about the cfe-commits mailing list