[FileCheck, 3/4] Allow AP value for numeric expressions

[thopre]

Summary

Use APInt to represent numeric variables and expressions, therefore
removing overflow concerns. Only remains underflow when the format of an
expression is unsigned (incl. hex values) but the result is negative.
Note that this can only happen when substituting an expression, not when
capturing since the regex used to capture unsigned value will not include
minus sign, hence all the code removal for match propagation testing.
This is what this patch implement.

[thopre]

Ping?

[thopre]

In D150880#4383688, @thopre wrote:

Ping?

Ping?

[thopre]

Ping?

[arichardson]

Overall LGTM but as this is a rather large diff I may have missed something.

llvm/lib/FileCheck/FileCheck.cpp

153

[[maybe_unused]] for the variable instead of the void cast?

llvm/lib/FileCheck/FileCheckImpl.h

121

To reduce the size of the diff we could have this class wrap a single apint but since you've made the changes to remove it already I think we may as well remove it.

155

Hmm maybe we should add using ExpressionValue = APInt to avoid all these changes.

llvm/test/FileCheck/match-time-error-propagation/matched-excluded-pattern.txt

4

It seems like some of this test is still useful, we just have to create a different error?

llvm/unittests/FileCheck/FileCheckTest.cpp

384

The test previously used 64 bit values, do we need 128 bit here?

[jhenderson]

In D150880#4448145, @thopre wrote:

Ping?

Sorry @thopre, I have too many other reviews on my plate to ever realistically be able to get around to this.

[thopre]

In D150880#4448939, @arichardson wrote:

Overall LGTM but as this is a rather large diff I may have missed something.

I'll try your suggestion to see if we can have 2 smaller diffs instead. Do you have any opinion on the question in the second paragraph of the description?

llvm/lib/FileCheck/FileCheckImpl.h

121

That's a good idea, I'll explore this to see if I can create 2 patches instead of 1. I don't mind a bit more work if it makes for an easier review.

155

They have different interface but I could use APInt inside ExpressionValue instead of int64_t as suggested above.

[thopre]

• Split APInt change into separate patches and only keep changes to support arbitrary precision
• use [[maybe_unused]] instead of (void)

[thopre]

llvm/unittests/FileCheck/FileCheckTest.cpp

382–386

Unused, oops

474–478

Oops

[thopre]

llvm/test/FileCheck/match-time-error-propagation/matched-excluded-pattern.txt

4

This patch removes the one case where the error path tested by these tests can happen. After this patch the parsing of integer in valueFromStringRepr() would need to fail for the path to be triggered by the regex used to match numeric values ensures that integer are valid. See https://reviews.llvm.org/D154431 for more details.

[arichardson]

llvm/lib/FileCheck/FileCheck.cpp

223

std::max?

229

The API might be a bit nicer if evalbinop did the widening of apints?

240

This should be unnecessary.

llvm/test/FileCheck/match-time-error-propagation/matched-excluded-pattern.txt

4

Ah fair enough that makes sense. Is the error handling still tested after removing this test? If not, could keep coverage by changing the error to be a divide by zero?

[thopre]

Address review comments

[thopre]

llvm/lib/FileCheck/FileCheck.cpp

229

EvalBinop is a function pointer to one of the expr* functions above. That would mean adding that logic in all those functions. This code here is in a single place instead. I could split it out into a separate function if you prefer?

llvm/test/FileCheck/match-time-error-propagation/matched-excluded-pattern.txt

4

TL;DR: the code tested by this is dead code, it cannot be exercise.

Long answer:
Divide by zero can only happens when substituting a numeric expression which leads to a match failure. These tests were for errors after a successful match, which only happened when a value could not fit in a numeric variable due to overflow/underflow. As can be seen by the removal of the code in match() in D154431 there is no more any failure in match() after a successful match. The whole code that this test was testing is effectively dead and could be removed, but I'm wary of removing it in case some change in FileCheck makes it necessary again.

[thopre]

Ping?

[thopre]

In D150880#4538498, @thopre wrote:

Ping?

Ping?

[arichardson]

Looks good to me. Sorry for the delay.

llvm/lib/FileCheck/FileCheck.cpp

229

Ah yes of course. I don't really mind, so this should be fine.

llvm/lib/FileCheck/FileCheck.cpp

 //
 // This file implements most of the API that will be used by the FileCheck utility
 // as well as various unittests.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/FileCheck/FileCheck.h"
 #include "FileCheckImpl.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CheckedArithmetic.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <cstdint>
 #include <list>
 #include <set>
 #include <tuple>
case Kind::HexLower:
     return (Twine(AlternateFormPrefix) + Twine("[0-9a-f]+")).str();
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 }
 
 Expected<std::string>
-ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const {
-  uint64_t AbsoluteValue;
+ExpressionFormat::getMatchingString(APInt IntegerValue) const {
+  if (Value != Kind::Signed && IntegerValue.isNegative())
+    return make_error<UnderflowError>();
+
+  unsigned Radix;
+  bool UpperCase = false;
+  SmallString<8> AbsoluteValueStr;
   StringRef SignPrefix = IntegerValue.isNegative() ? "-" : "";
-
-  if (Value == Kind::Signed) {
-    Expected<int64_t> SignedValue = IntegerValue.getSignedValue();
-    if (!SignedValue)
-      return SignedValue.takeError();
-    if (*SignedValue < 0)
-      AbsoluteValue = cantFail(IntegerValue.getAbsolute().getUnsignedValue());
-    else
-      AbsoluteValue = *SignedValue;
-  } else {
-    Expected<uint64_t> UnsignedValue = IntegerValue.getUnsignedValue();
-    if (!UnsignedValue)
-      return UnsignedValue.takeError();
-    AbsoluteValue = *UnsignedValue;
-  }
-
-  std::string AbsoluteValueStr;
   switch (Value) {
   case Kind::Unsigned:
   case Kind::Signed:
-    AbsoluteValueStr = utostr(AbsoluteValue);
+    Radix = 10;
     break;
-  case Kind::HexUpper:
   case Kind::HexLower:
-    AbsoluteValueStr = utohexstr(AbsoluteValue, Value == Kind::HexLower);
+    Radix = 16;
+    UpperCase = false;
+    break;
+  case Kind::HexUpper:
+    Radix = 16;
+    UpperCase = true;
     break;
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
+  IntegerValue.abs().toString(AbsoluteValueStr, Radix, /*Signed=*/false,
+                              /*formatAsCLiteral=*/false,
+                              /*UpperCase=*/UpperCase);
 
   StringRef AlternateFormPrefix = AlternateForm ? StringRef("0x") : StringRef();
 
   if (Precision > AbsoluteValueStr.size()) {
     unsigned LeadingZeros = Precision - AbsoluteValueStr.size();
     return (Twine(SignPrefix) + Twine(AlternateFormPrefix) +
             std::string(LeadingZeros, '0') + AbsoluteValueStr)
         .str();
   }
 
   return (Twine(SignPrefix) + Twine(AlternateFormPrefix) + AbsoluteValueStr)
       .str();
 }
 
-Expected<ExpressionValue>
-ExpressionFormat::valueFromStringRepr(StringRef StrVal,
+unsigned nextAPIntBitWidth(unsigned BitWidth) {
+  return (BitWidth < APInt::APINT_BITS_PER_WORD) ? APInt::APINT_BITS_PER_WORD
+                                                 : BitWidth * 2;
+}
+
+APInt toSigned(APInt AbsVal, bool Negative) {
+  if (AbsVal.isSignBitSet())
+    AbsVal = AbsVal.zext(nextAPIntBitWidth(AbsVal.getBitWidth()));
+  APInt Result = AbsVal;
+  if (Negative)
+    Result.negate();
+  return Result;
+}
+
+APInt ExpressionFormat::valueFromStringRepr(StringRef StrVal,
                                             const SourceMgr &SM) const {
   bool ValueIsSigned = Value == Kind::Signed;
   // Both the FileCheck utility and library only call this method with a valid
   // value in StrVal. This is guaranteed by the regex returned by
   // getWildcardRegex() above. Only underflow and overflow errors can thus
   // occur. However new uses of this method could be added in the future so
   // the error message does not make assumptions about StrVal.
-  StringRef IntegerParseErrorStr = "unable to represent numeric value";
-  if (ValueIsSigned) {
-    int64_t SignedValue;
-
-    if (StrVal.getAsInteger(10, SignedValue))
-      return ErrorDiagnostic::get(SM, StrVal, IntegerParseErrorStr);
-
-    return ExpressionValue(SignedValue);
-  }
 
+  bool Negative = StrVal.consume_front("-");
   bool Hex = Value == Kind::HexUpper || Value == Kind::HexLower;
-  uint64_t UnsignedValue;
-  bool MissingFormPrefix = AlternateForm && !StrVal.consume_front("0x");
+  bool MissingFormPrefix =
+      !ValueIsSigned && AlternateForm && !StrVal.consume_front("0x");
   (void)MissingFormPrefix;
   assert(!MissingFormPrefix && "missing alternate form prefix");
-  if (StrVal.getAsInteger(Hex ? 16 : 10, UnsignedValue))
-    return ErrorDiagnostic::get(SM, StrVal, IntegerParseErrorStr);
+  APInt ResultValue;
+  bool ParseFailure = StrVal.getAsInteger(Hex ? 16 : 10, ResultValue);
+  (void)ParseFailure;
+  assert(!ParseFailure && "unable to represent numeric value");
 
-  return ExpressionValue(UnsignedValue);
+  return toSigned(ResultValue, Negative);
 }
 
-static int64_t getAsSigned(uint64_t UnsignedValue) {
-  // Use memcpy to reinterpret the bitpattern in Value since casting to
-  // signed is implementation-defined if the unsigned value is too big to be
-  // represented in the signed type and using an union violates type aliasing
-  // rules.
-  int64_t SignedValue;
-  memcpy(&SignedValue, &UnsignedValue, sizeof(SignedValue));
-  return SignedValue;
+Expected<APInt> llvm::exprAdd(const APInt &LeftOperand,
+                              const APInt &RightOperand, bool &Overflow) {
+  return LeftOperand.sadd_ov(RightOperand, Overflow);
 }
 
-Expected<int64_t> ExpressionValue::getSignedValue() const {
-  if (Negative)
-    return getAsSigned(Value);
-
-  if (Value > (uint64_t)std::numeric_limits<int64_t>::max())
-    return make_error<OverflowError>();
-
-  // Value is in the representable range of int64_t so we can use cast.
-  return static_cast<int64_t>(Value);
+Expected<APInt> llvm::exprSub(const APInt &LeftOperand,
+                              const APInt &RightOperand, bool &Overflow) {
+  return LeftOperand.ssub_ov(RightOperand, Overflow);
 }
 
-Expected<uint64_t> ExpressionValue::getUnsignedValue() const {
-  if (Negative)
-    return make_error<OverflowError>();
-
-  return Value;
+Expected<APInt> llvm::exprMul(const APInt &LeftOperand,
+                              const APInt &RightOperand, bool &Overflow) {
+  return LeftOperand.smul_ov(RightOperand, Overflow);
 }
 
-ExpressionValue ExpressionValue::getAbsolute() const {
-  if (!Negative)
-    return *this;
-
-  int64_t SignedValue = getAsSigned(Value);
-  int64_t MaxInt64 = std::numeric_limits<int64_t>::max();
-  // Absolute value can be represented as int64_t.
-  if (SignedValue >= -MaxInt64)
-    return ExpressionValue(-getAsSigned(Value));
-
-  // -X == -(max int64_t + Rem), negate each component independently.
-  SignedValue += MaxInt64;
-  uint64_t RemainingValueAbsolute = -SignedValue;
-  return ExpressionValue(MaxInt64 + RemainingValueAbsolute);
-}
-
-Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  if (LeftOperand.isNegative() && RightOperand.isNegative()) {
-    int64_t LeftValue = cantFail(LeftOperand.getSignedValue());
-    int64_t RightValue = cantFail(RightOperand.getSignedValue());
-    std::optional<int64_t> Result = checkedAdd<int64_t>(LeftValue, RightValue);
-    if (!Result)
-      return make_error<OverflowError>();
-
-    return ExpressionValue(*Result);
-  }
-
-  // (-A) + B == B - A.
-  if (LeftOperand.isNegative())
-    return RightOperand - LeftOperand.getAbsolute();
-
-  // A + (-B) == A - B.
-  if (RightOperand.isNegative())
-    return LeftOperand - RightOperand.getAbsolute();
-
-  // Both values are positive at this point.
-  uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
-  uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-  std::optional<uint64_t> Result =
-      checkedAddUnsigned<uint64_t>(LeftValue, RightValue);
-  if (!Result)
-    return make_error<OverflowError>();
-
-  return ExpressionValue(*Result);
-}
-
-Expected<ExpressionValue> llvm::operator-(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  // Result will be negative and thus might underflow.
-  if (LeftOperand.isNegative() && !RightOperand.isNegative()) {
-    int64_t LeftValue = cantFail(LeftOperand.getSignedValue());
-    uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-    // Result <= -1 - (max int64_t) which overflows on 1- and 2-complement.
-    if (RightValue > (uint64_t)std::numeric_limits<int64_t>::max())
-      return make_error<OverflowError>();
-    std::optional<int64_t> Result =
-        checkedSub(LeftValue, static_cast<int64_t>(RightValue));
-    if (!Result)
-      return make_error<OverflowError>();
-
-    return ExpressionValue(*Result);
-  }
-
-  // (-A) - (-B) == B - A.
-  if (LeftOperand.isNegative())
-    return RightOperand.getAbsolute() - LeftOperand.getAbsolute();
-
-  // A - (-B) == A + B.
-  if (RightOperand.isNegative())
-    return LeftOperand + RightOperand.getAbsolute();
-
-  // Both values are positive at this point.
-  uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
-  uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-  if (LeftValue >= RightValue)
-    return ExpressionValue(LeftValue - RightValue);
-  else {
-    uint64_t AbsoluteDifference = RightValue - LeftValue;
-    uint64_t MaxInt64 = std::numeric_limits<int64_t>::max();
-    // Value might underflow.
-    if (AbsoluteDifference > MaxInt64) {
-      AbsoluteDifference -= MaxInt64;
-      int64_t Result = -MaxInt64;
-      int64_t MinInt64 = std::numeric_limits<int64_t>::min();
-      // Underflow, tested by:
-      //   abs(Result + (max int64_t)) > abs((min int64_t) + (max int64_t))
-      if (AbsoluteDifference > static_cast<uint64_t>(-(MinInt64 - Result)))
-        return make_error<OverflowError>();
-      Result -= static_cast<int64_t>(AbsoluteDifference);
-      return ExpressionValue(Result);
-    }
-
-    return ExpressionValue(-static_cast<int64_t>(AbsoluteDifference));
-  }
+Expected<APInt> llvm::exprDiv(const APInt &LeftOperand,
+                              const APInt &RightOperand, bool &Overflow) {
+  if (RightOperand.isZero())
+    return make_error<DivByZeroError>();
+  return LeftOperand.sdiv_ov(RightOperand, Overflow);
 }
 
-Expected<ExpressionValue> llvm::operator*(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  // -A * -B == A * B
-  if (LeftOperand.isNegative() && RightOperand.isNegative())
-    return LeftOperand.getAbsolute() * RightOperand.getAbsolute();
-
-  // A * -B == -B * A
-  if (RightOperand.isNegative())
-    return RightOperand * LeftOperand;
-
-  assert(!RightOperand.isNegative() && "Unexpected negative operand!");
-
-  // Result will be negative and can underflow.
-  if (LeftOperand.isNegative()) {
-    auto Result = LeftOperand.getAbsolute() * RightOperand.getAbsolute();
-    if (!Result)
-      return Result;
-
-    return ExpressionValue(0) - *Result;
-  }
+Expected<APInt> llvm::exprMax(const APInt &LeftOperand,
+                              const APInt &RightOperand, bool &Overflow) {
+  Overflow = false;
+  return LeftOperand.slt(RightOperand) ? RightOperand : LeftOperand;
 
-  // Result will be positive and can overflow.
-  uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
-  uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-  std::optional<uint64_t> Result =
-      checkedMulUnsigned<uint64_t>(LeftValue, RightValue);
-  if (!Result)
-    return make_error<OverflowError>();
-
-  return ExpressionValue(*Result);
+Expected<APInt> llvm::exprMin(const APInt &LeftOperand,
+                              const APInt &RightOperand, bool &Overflow) {
+  Overflow = false;
+  return LeftOperand.slt(RightOperand) ? LeftOperand : RightOperand;
 }
 
-Expected<ExpressionValue> llvm::operator/(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  // -A / -B == A / B
-  if (LeftOperand.isNegative() && RightOperand.isNegative())
-    return LeftOperand.getAbsolute() / RightOperand.getAbsolute();
-
-  // Check for divide by zero.
-  if (RightOperand == ExpressionValue(0))
-    return make_error<OverflowError>();
-
-  // Result will be negative and can underflow.
-  if (LeftOperand.isNegative() || RightOperand.isNegative())
-    return ExpressionValue(0) -
-           cantFail(LeftOperand.getAbsolute() / RightOperand.getAbsolute());
-
-  uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
-  uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-  return ExpressionValue(LeftValue / RightValue);
-}
-
-Expected<ExpressionValue> llvm::max(const ExpressionValue &LeftOperand,
-                                    const ExpressionValue &RightOperand) {
-  if (LeftOperand.isNegative() && RightOperand.isNegative()) {
-    int64_t LeftValue = cantFail(LeftOperand.getSignedValue());
-    int64_t RightValue = cantFail(RightOperand.getSignedValue());
-    return ExpressionValue(std::max(LeftValue, RightValue));
-  }
-
-  if (!LeftOperand.isNegative() && !RightOperand.isNegative()) {
-    uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
-    uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-    return ExpressionValue(std::max(LeftValue, RightValue));
-  }
-
-  if (LeftOperand.isNegative())
-    return RightOperand;
-
-  return LeftOperand;
-}
-
-Expected<ExpressionValue> llvm::min(const ExpressionValue &LeftOperand,
-                                    const ExpressionValue &RightOperand) {
-  if (cantFail(max(LeftOperand, RightOperand)) == LeftOperand)
-    return RightOperand;
-
-  return LeftOperand;
-}
-
-Expected<ExpressionValue> NumericVariableUse::eval() const {
-  std::optional<ExpressionValue> Value = Variable->getValue();
+Expected<APInt> NumericVariableUse::eval() const {
+  std::optional<APInt> Value = Variable->getValue();
   if (Value)
     return *Value;
 
   return make_error<UndefVarError>(getExpressionStr());
 }
 
-Expected<ExpressionValue> BinaryOperation::eval() const {
-  Expected<ExpressionValue> LeftOp = LeftOperand->eval();
-  Expected<ExpressionValue> RightOp = RightOperand->eval();
+Expected<APInt> BinaryOperation::eval() const {
+  Expected<APInt> MaybeLeftOp = LeftOperand->eval();
+  Expected<APInt> MaybeRightOp = RightOperand->eval();
 
   // Bubble up any error (e.g. undefined variables) in the recursive
   // evaluation.
-  if (!LeftOp || !RightOp) {
+  if (!MaybeLeftOp || !MaybeRightOp) {
     Error Err = Error::success();
-    if (!LeftOp)
-      Err = joinErrors(std::move(Err), LeftOp.takeError());
-    if (!RightOp)
-      Err = joinErrors(std::move(Err), RightOp.takeError());
+    if (!MaybeLeftOp)
+      Err = joinErrors(std::move(Err), MaybeLeftOp.takeError());
+    if (!MaybeRightOp)
+      Err = joinErrors(std::move(Err), MaybeRightOp.takeError());
     return std::move(Err);
   }
 
-  return EvalBinop(*LeftOp, *RightOp);
+  APInt LeftOp = *MaybeLeftOp, RightOp = *MaybeRightOp;
+  bool Overflow;
+  APInt Result;
+  // Ensure both operands have the same bitwidth.
+  unsigned LeftBitWidth = LeftOp.getBitWidth();
+  unsigned RightBitWidth = RightOp.getBitWidth();
+  unsigned NewBitWidth =
+      LeftBitWidth > RightBitWidth ? LeftBitWidth : RightBitWidth;
+  LeftOp = LeftOp.sext(NewBitWidth);
+  RightOp = RightOp.sext(NewBitWidth);
+  do {
+    Expected<APInt> MaybeResult = EvalBinop(LeftOp, RightOp, Overflow);
+    if (!MaybeResult)
+      return MaybeResult.takeError();
+
+    if (!Overflow) {
+      Result = *MaybeResult;
+      break;
+    }
+
+    NewBitWidth = nextAPIntBitWidth(LeftOp.getBitWidth());
+    LeftOp = LeftOp.sext(NewBitWidth);
+    RightOp = RightOp.sext(NewBitWidth);
+  } while (Overflow);
+  return Result;
 }
 
 Expected<ExpressionFormat>
 BinaryOperation::getImplicitFormat(const SourceMgr &SM) const {
   Expected<ExpressionFormat> LeftFormat = LeftOperand->getImplicitFormat(SM);
   Expected<ExpressionFormat> RightFormat = RightOperand->getImplicitFormat(SM);
   if (!LeftFormat || !RightFormat) {
     Error Err = Error::success();
BinaryOperation::getImplicitFormat(const SourceMgr &SM) const {
 
   return *LeftFormat != ExpressionFormat::Kind::NoFormat ? *LeftFormat
                                                          : *RightFormat;
 }
 
 Expected<std::string> NumericSubstitution::getResult() const {
   assert(ExpressionPointer->getAST() != nullptr &&
          "Substituting empty expression");
-  Expected<ExpressionValue> EvaluatedValue =
-      ExpressionPointer->getAST()->eval();
+  Expected<APInt> EvaluatedValue = ExpressionPointer->getAST()->eval();
   if (!EvaluatedValue)
     return EvaluatedValue.takeError();
   ExpressionFormat Format = ExpressionPointer->getFormat();
   return Format.getMatchingString(*EvaluatedValue);
 }
 
 Expected<std::string> StringSubstitution::getResult() const {
   // Look up the value and escape it so that we can put it into the regex.

 
 // Parsing helper function that strips the first character in S and returns it.
 static char popFront(StringRef &S) {
   char C = S.front();
   S = S.drop_front();
   return C;
 }
 
-char OverflowError::ID = 0;
+char DivByZeroError::ID = 0;
+char UnderflowError::ID = 0;
 char UndefVarError::ID = 0;
 char ErrorDiagnostic::ID = 0;
 char NotFoundError::ID = 0;
 char ErrorReported::ID = 0;
 
 Expected<NumericVariable *> Pattern::parseNumericVariableDefinition(
     StringRef &Expr, FileCheckPatternContext *Context,
     std::optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
if (AO == AllowedOperand::LineVar || AO == AllowedOperand::Any) {
 
     if (AO == AllowedOperand::LineVar)
       return ParseVarResult.takeError();
     // Ignore the error and retry parsing as a literal.
     consumeError(ParseVarResult.takeError());
   }
 
   // Otherwise, parse it as a literal.
-  int64_t SignedLiteralValue;
-  uint64_t UnsignedLiteralValue;
+  APInt LiteralValue;
   StringRef SaveExpr = Expr;
-  // Accept both signed and unsigned literal, default to signed literal.
+  bool Negative = Expr.consume_front("-");
   if (!Expr.consumeInteger((AO == AllowedOperand::LegacyLiteral) ? 10 : 0,
-                           UnsignedLiteralValue))
+                           LiteralValue)) {
+    LiteralValue = toSigned(LiteralValue, Negative);
     return std::make_unique<ExpressionLiteral>(SaveExpr.drop_back(Expr.size()),
-                                               UnsignedLiteralValue);
-  Expr = SaveExpr;
-  if (AO == AllowedOperand::Any && !Expr.consumeInteger(0, SignedLiteralValue))
-    return std::make_unique<ExpressionLiteral>(SaveExpr.drop_back(Expr.size()),
-                                               SignedLiteralValue);
+                                               LiteralValue);
+  }
 
   return ErrorDiagnostic::get(
-      SM, Expr,
+      SM, SaveExpr,
       Twine("invalid ") +
           (MaybeInvalidConstraint ? "matching constraint or " : "") +
           "operand format");
 }
 
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseParenExpr(StringRef &Expr, std::optional<size_t> LineNumber,
                         FileCheckPatternContext *Context, const SourceMgr &SM) {
Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
 
   // Check if this is a supported operation and select a function to perform
   // it.
   SMLoc OpLoc = SMLoc::getFromPointer(RemainingExpr.data());
   char Operator = popFront(RemainingExpr);
   binop_eval_t EvalBinop;
   switch (Operator) {
   case '+':
-    EvalBinop = operator+;
+    EvalBinop = exprAdd;
     break;
   case '-':
-    EvalBinop = operator-;
+    EvalBinop = exprSub;
     break;
   default:
     return ErrorDiagnostic::get(
         SM, OpLoc, Twine("unsupported operation '") + Twine(Operator) + "'");
   }
 
   // Parse right operand.
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);

 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName,
                        std::optional<size_t> LineNumber,
                        FileCheckPatternContext *Context, const SourceMgr &SM) {
   Expr = Expr.ltrim(SpaceChars);
   assert(Expr.startswith("("));
 
   auto OptFunc = StringSwitch<binop_eval_t>(FuncName)
-                     .Case("add", operator+)
-                     .Case("div", operator/)
-                     .Case("max", max)
-                     .Case("min", min)
-                     .Case("mul", operator*)
-                     .Case("sub", operator-)
+                     .Case("add", exprAdd)
+                     .Case("div", exprDiv)
+                     .Case("max", exprMax)
+                     .Case("min", exprMin)
+                     .Case("mul", exprMul)
+                     .Case("sub", exprSub)
                      .Default(nullptr);
 
   if (!OptFunc)
     return ErrorDiagnostic::get(
         SM, FuncName, Twine("call to undefined function '") + FuncName + "'");
 
   Expr.consume_front("(");
   Expr = Expr.ltrim(SpaceChars);
Pattern::MatchResult Pattern::match(StringRef Buffer,
 
   // If there are substitutions, we need to create a temporary string with the
   // actual value.
   StringRef RegExToMatch = RegExStr;
   std::string TmpStr;
   if (!Substitutions.empty()) {
     TmpStr = RegExStr;
     if (LineNumber)
-      Context->LineVariable->setValue(ExpressionValue(*LineNumber));
+      Context->LineVariable->setValue(
+          APInt(sizeof(*LineNumber) * 8, *LineNumber));
 
     size_t InsertOffset = 0;
     // Substitute all string variables and expressions whose values are only
     // now known. Use of string variables defined on the same line are handled
     // by back-references.
     Error Errs = Error::success();
     for (const auto &Substitution : Substitutions) {
       // Substitute and check for failure (e.g. use of undefined variable).
       Expected<std::string> Value = Substitution->getResult();
       if (!Value) {
         // Convert to an ErrorDiagnostic to get location information. This is
         // done here rather than printMatch/printNoMatch since now we know which
         // substitution block caused the overflow.
         Errs = joinErrors(std::move(Errs),
                           handleErrors(
                               Value.takeError(),
-                              [&](const OverflowError &E) {
+                              [&SM, &Substitution](const UnderflowError &E) {
+                                return ErrorDiagnostic::get(
+                                    SM, Substitution->getFromString(),
+                                    "unable to substitute variable or "
+                                    "numeric expression: underflow error");
+                              },
+                              [&SM, &Substitution](const DivByZeroError &E) {
                                 return ErrorDiagnostic::get(
                                     SM, Substitution->getFromString(),
                                     "unable to substitute variable or "
-                                    "numeric expression: overflow error");
+                                    "numeric expression: division by error");
                               },
                               [&SM](const UndefVarError &E) {
                                 return ErrorDiagnostic::get(SM, E.getVarName(),
                                                             E.message());
                               }));
         continue;
       }
 
const NumericVariableMatch &NumericVariableMatch =
         NumericVariableDef.getValue();
     unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;
     assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");
     NumericVariable *DefinedNumericVariable =
         NumericVariableMatch.DefinedNumericVariable;
 
     StringRef MatchedValue = MatchInfo[CaptureParenGroup];
     ExpressionFormat Format = DefinedNumericVariable->getImplicitFormat();
-    Expected<ExpressionValue> Value =
-        Format.valueFromStringRepr(MatchedValue, SM);
-    if (!Value)
-      return MatchResult(TheMatch, Value.takeError());
-    DefinedNumericVariable->setValue(*Value, MatchedValue);
+    APInt Value = Format.valueFromStringRepr(MatchedValue, SM);
+    DefinedNumericVariable->setValue(Value, MatchedValue);
   }
 
   return MatchResult(TheMatch, Error::success());
 }
 
 unsigned Pattern::computeMatchDistance(StringRef Buffer) const {
   // Just compute the number of matching characters. For regular expressions, we
   // just compare against the regex itself and hope for the best.
if (CmdlineDef[0] == '#') {
         Errs = joinErrors(std::move(Errs), ExpressionResult.takeError());
         continue;
       }
       std::unique_ptr<Expression> Expression = std::move(*ExpressionResult);
       // Now evaluate the expression whose value this variable should be set
       // to, since the expression of a command-line variable definition should
       // only use variables defined earlier on the command-line. If not, this
       // is an error and we report it.
-      Expected<ExpressionValue> Value = Expression->getAST()->eval();
+      Expected<APInt> Value = Expression->getAST()->eval();
       if (!Value) {
         Errs = joinErrors(std::move(Errs), Value.takeError());
         continue;
       }
 
       assert(DefinedNumericVariable && "No variable defined");
       (*DefinedNumericVariable)->setValue(*Value);
 

llvm/lib/FileCheck/FileCheckImpl.h

 // allow unit testing of FileCheck and to separate the interface from the
 // implementation. It is only meant to be used by FileCheck.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_FILECHECK_FILECHECKIMPL_H
 #define LLVM_LIB_FILECHECK_FILECHECKIMPL_H
 
+#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/FileCheck/FileCheck.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/SourceMgr.h"
 #include <map>
 #include <optional>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // Numeric substitution handling code.
 //===----------------------------------------------------------------------===//
 
-class ExpressionValue;
-
 /// Type representing the format an expression value should be textualized into
 /// for matching. Used to represent both explicit format specifiers as well as
 /// implicit format from using numeric variables.
 struct ExpressionFormat {
   enum class Kind {
     /// Denote absence of format. Used for implicit format of literals and
     /// empty expressions.
     NoFormat,
public:
   /// \returns a wildcard regular expression string that matches any value in
   /// the format represented by this instance and no other value, or an error
   /// if the format is NoFormat.
   Expected<std::string> getWildcardRegex() const;
 
   /// \returns the string representation of \p Value in the format represented
   /// by this instance, or an error if conversion to this format failed or the
   /// format is NoFormat.
-  Expected<std::string> getMatchingString(ExpressionValue Value) const;
+  Expected<std::string> getMatchingString(APInt Value) const;
 
   /// \returns the value corresponding to string representation \p StrVal
-  /// according to the matching format represented by this instance or an error
-  /// with diagnostic against \p SM if \p StrVal does not correspond to a valid
-  /// and representable value.
-  Expected<ExpressionValue> valueFromStringRepr(StringRef StrVal,
-                                                const SourceMgr &SM) const;
+  /// according to the matching format represented by this instance.
+  APInt valueFromStringRepr(StringRef StrVal, const SourceMgr &SM) const;
 };
 
 /// Class to represent an overflow error that might result when manipulating a
 /// value.
-class OverflowError : public ErrorInfo<OverflowError> {
+class UnderflowError : public ErrorInfo<UnderflowError> {
 public:
   static char ID;
 
   std::error_code convertToErrorCode() const override {
-    return std::make_error_code(std::errc::value_too_large);
+    return std::make_error_code(std::errc::invalid_argument);
   }
 
-  void log(raw_ostream &OS) const override { OS << "overflow error"; }
+  void log(raw_ostream &OS) const override { OS << "underflow error"; }
 };
 
-/// Class representing a numeric value.
-class ExpressionValue {
-private:
-  uint64_t Value;
-  bool Negative;
-
+/// Class to represent a division by zero error.
+class DivByZeroError : public ErrorInfo<DivByZeroError> {
 public:
-  template <class T>
-  explicit ExpressionValue(T Val) : Value(Val), Negative(Val < 0) {}
+  static char ID;
 
-  bool operator==(const ExpressionValue &Other) const {
-    return Value == Other.Value && isNegative() == Other.isNegative();
+  std::error_code convertToErrorCode() const override {
+    return std::make_error_code(std::errc::invalid_argument);
   }
 
-  bool operator!=(const ExpressionValue &Other) const {
-    return !(*this == Other);
-  }
+  void log(raw_ostream &OS) const override { OS << "division by zero error"; }
+};
 
-  /// Returns true if value is signed and negative, false otherwise.
-  bool isNegative() const {
-    assert((Value != 0 || !Negative) && "Unexpected negative zero!");
-    return Negative;
-  }
-
-  /// \returns the value as a signed integer or an error if the value is out of
-  /// range.
-  Expected<int64_t> getSignedValue() const;
-
-  /// \returns the value as an unsigned integer or an error if the value is out
-  /// of range.
-  Expected<uint64_t> getUnsignedValue() const;
-
-  /// \returns an unsigned ExpressionValue instance whose value is the absolute
-  /// value to this object's value.
-  ExpressionValue getAbsolute() const;
-};
-
-/// Performs operation and \returns its result or an error in case of failure,
-/// such as if an overflow occurs.
-Expected<ExpressionValue> operator+(const ExpressionValue &Lhs,
-                                    const ExpressionValue &Rhs);
-Expected<ExpressionValue> operator-(const ExpressionValue &Lhs,
-                                    const ExpressionValue &Rhs);
-Expected<ExpressionValue> operator*(const ExpressionValue &Lhs,
-                                    const ExpressionValue &Rhs);
-Expected<ExpressionValue> operator/(const ExpressionValue &Lhs,
-                                    const ExpressionValue &Rhs);
-Expected<ExpressionValue> max(const ExpressionValue &Lhs,
-                              const ExpressionValue &Rhs);
-Expected<ExpressionValue> min(const ExpressionValue &Lhs,
-                              const ExpressionValue &Rhs);
+Expected<APInt> exprAdd(const APInt &LeftOperand, const APInt &RightOperand,
+                        bool &Overflow);
+Expected<APInt> exprSub(const APInt &LeftOperand, const APInt &RightOperand,
+                        bool &Overflow);
+Expected<APInt> exprMul(const APInt &LeftOperand, const APInt &RightOperand,
+                        bool &Overflow);
+Expected<APInt> exprDiv(const APInt &LeftOperand, const APInt &RightOperand,
+                        bool &Overflow);
+Expected<APInt> exprMin(const APInt &LeftOperand, const APInt &RightOperand,
+                        bool &Overflow);
+Expected<APInt> exprMax(const APInt &LeftOperand, const APInt &RightOperand,
+                        bool &Overflow);
 
 /// Base class representing the AST of a given expression.
 class ExpressionAST {
 private:
   StringRef ExpressionStr;
 
 public:
   ExpressionAST(StringRef ExpressionStr) : ExpressionStr(ExpressionStr) {}
 
   virtual ~ExpressionAST() = default;
 
   StringRef getExpressionStr() const { return ExpressionStr; }
 
   /// Evaluates and \returns the value of the expression represented by this
   /// AST or an error if evaluation fails.
-  virtual Expected<ExpressionValue> eval() const = 0;
+  virtual Expected<APInt> eval() const = 0;
 
   /// \returns either the implicit format of this AST, a diagnostic against
   /// \p SM if implicit formats of the AST's components conflict, or NoFormat
   /// if the AST has no implicit format (e.g. AST is made up of a single
   /// literal).
   virtual Expected<ExpressionFormat>
   getImplicitFormat(const SourceMgr &SM) const {
     return ExpressionFormat();
   }
 };
 
 /// Class representing an unsigned literal in the AST of an expression.
 class ExpressionLiteral : public ExpressionAST {
 private:
   /// Actual value of the literal.
-  ExpressionValue Value;
+  APInt Value;
 
 public:
-  template <class T>
-  explicit ExpressionLiteral(StringRef ExpressionStr, T Val)
+  explicit ExpressionLiteral(StringRef ExpressionStr, APInt Val)
       : ExpressionAST(ExpressionStr), Value(Val) {}
 
   /// \returns the literal's value.
-  Expected<ExpressionValue> eval() const override { return Value; }
+  Expected<APInt> eval() const override { return Value; }
 };
 
 /// Class to represent an undefined variable error, which quotes that
 /// variable's name when printed.
 class UndefVarError : public ErrorInfo<UndefVarError> {
 private:
   StringRef VarName;
 
private:
   /// Name of the numeric variable.
   StringRef Name;
 
   /// Format to use for expressions using this variable without an explicit
   /// format.
   ExpressionFormat ImplicitFormat;
 
   /// Value of numeric variable, if defined, or std::nullopt otherwise.
-  std::optional<ExpressionValue> Value;
+  std::optional<APInt> Value;
 
   /// The input buffer's string from which Value was parsed, or std::nullopt.
   /// See comments on getStringValue for a discussion of the std::nullopt case.
   std::optional<StringRef> StrValue;
 
   /// Line number where this variable is defined, or std::nullopt if defined
   /// before input is parsed. Used to determine whether a variable is defined on
   /// the same line as a given use.
public:
 
   /// \returns name of this numeric variable.
   StringRef getName() const { return Name; }
 
   /// \returns implicit format of this numeric variable.
   ExpressionFormat getImplicitFormat() const { return ImplicitFormat; }
 
   /// \returns this variable's value.
-  std::optional<ExpressionValue> getValue() const { return Value; }
+  std::optional<APInt> getValue() const { return Value; }
 
   /// \returns the input buffer's string from which this variable's value was
   /// parsed, or std::nullopt if the value is not yet defined or was not parsed
   /// from the input buffer.  For example, the value of @LINE is not parsed from
   /// the input buffer, and some numeric variables are parsed from the command
   /// line instead.
   std::optional<StringRef> getStringValue() const { return StrValue; }
 
   /// Sets value of this numeric variable to \p NewValue, and sets the input
   /// buffer string from which it was parsed to \p NewStrValue.  See comments on
   /// getStringValue for a discussion of when the latter can be std::nullopt.
-  void setValue(ExpressionValue NewValue,
+  void setValue(APInt NewValue,
                 std::optional<StringRef> NewStrValue = std::nullopt) {
     Value = NewValue;
     StrValue = NewStrValue;
   }
 
   /// Clears value of this numeric variable, regardless of whether it is
   /// currently defined or not.
   void clearValue() {

 private:
   /// Pointer to the class instance for the variable this use is about.
   NumericVariable *Variable;
 
 public:
   NumericVariableUse(StringRef Name, NumericVariable *Variable)
       : ExpressionAST(Name), Variable(Variable) {}
   /// \returns the value of the variable referenced by this instance.
-  Expected<ExpressionValue> eval() const override;
+  Expected<APInt> eval() const override;
 
   /// \returns implicit format of this numeric variable.
   Expected<ExpressionFormat>
   getImplicitFormat(const SourceMgr &SM) const override {
     return Variable->getImplicitFormat();
   }
 };
 
 /// Type of functions evaluating a given binary operation.
-using binop_eval_t = Expected<ExpressionValue> (*)(const ExpressionValue &,
-                                                   const ExpressionValue &);
+using binop_eval_t = Expected<APInt> (*)(const APInt &LHS, const APInt &RHS,
+                                         bool &Overflow);
 
 /// Class representing a single binary operation in the AST of an expression.
 class BinaryOperation : public ExpressionAST {
 private:
   /// Left operand.
   std::unique_ptr<ExpressionAST> LeftOperand;
 
   /// Right operand.
BinaryOperation(StringRef ExpressionStr, binop_eval_t EvalBinop,
     LeftOperand = std::move(LeftOp);
     RightOperand = std::move(RightOp);
   }
 
   /// Evaluates the value of the binary operation represented by this AST,
   /// using EvalBinop on the result of recursively evaluating the operands.
   /// \returns the expression value or an error if an undefined numeric
   /// variable is used in one of the operands.
-  Expected<ExpressionValue> eval() const override;
+  Expected<APInt> eval() const override;
 
   /// \returns the implicit format of this AST, if any, a diagnostic against
   /// \p SM if the implicit formats of the AST's components conflict, or no
   /// format if the AST has no implicit format (e.g. AST is made of a single
   /// literal).
   Expected<ExpressionFormat>
   getImplicitFormat(const SourceMgr &SM) const override;
 };

llvm/test/FileCheck/match-time-error-propagation/invalid-excluded-pattern.txt

-; Check handling of match-time diagnostics for invalid patterns (e.g.,
-; substitution overflow) in the case of excluded patterns (e.g., CHECK-NOT).
-;
-; At one time, FileCheck's exit status was zero for this case.  Moreover, it
-; printed the error diagnostic only if -vv was specified and input dumps were
-; disabled.  Test every combination as the logic is hard to get right.
-
-RUN: echo > %t.chk \
-RUN:      'CHECK-NOT: [[#0x8000000000000000+0x8000000000000000]] [[UNDEFVAR]]'
-RUN: echo > %t.in '10000000000000000'
-
-     ERR-NOT:{{.}}
-      ERR-VV:{{.*}}: remark: implicit EOF: expected string found in input
- ERR-VV-NEXT:CHECK-NOT: {{.*}}
- ERR-VV-NEXT:{{ *}}^
- ERR-VV-NEXT:{{.*}}: note: found here
-ERR-VV-EMPTY:
- ERR-VV-NEXT:^
-     ERR-NOT:{{.}}
-         ERR:{{.*}}: error: unable to substitute variable or numeric expression: overflow error
-    ERR-NEXT:CHECK-NOT: {{.*}}
-    ERR-NEXT:{{ *}}^
-    ERR-NEXT:{{.*}}: error: undefined variable: UNDEFVAR
-    ERR-NEXT:{{CHECK-NOT: \[\[#0x8000000000000000\+0x8000000000000000\]\] \[\[UNDEFVAR\]\]}}
-    ERR-NEXT:^
-     ERR-NOT:{{error|note|remark}}:
-
-        DUMP:<<<<<<
-   DUMP-NEXT:         1: 10000000000000000 
-   DUMP-NEXT:not:1'0     X~~~~~~~~~~~~~~~~~ error: match failed for invalid pattern
-   DUMP-NEXT:not:1'1                        unable to substitute variable or numeric expression: overflow error
-   DUMP-NEXT:not:1'2                        undefined variable: UNDEFVAR
-DUMP-VV-NEXT:         2: 
-DUMP-VV-NEXT:eof:1       ^
-   DUMP-NEXT:>>>>>>
-
-;--------------------------------------------------
-; Check -dump-input=never cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,ERR-VV
-
-;--------------------------------------------------
-; Check -dump-input=fail cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP,DUMP-VV

llvm/test/FileCheck/match-time-error-propagation/invalid-expected-pattern.txt

-; Check handling of match-time diagnostics for invalid patterns (e.g.,
-; substitution overflow) in the case of expected patterns (e.g., CHECK).
-
-RUN: echo > %t.chk \
-RUN:      'CHECK: [[#0x8000000000000000+0x8000000000000000]] [[UNDEFVAR]]'
-RUN: echo > %t.in '10000000000000000'
-
-  ERR-NOT:{{.}}
-      ERR:{{.*}}: error: unable to substitute variable or numeric expression: overflow error
- ERR-NEXT:CHECK: {{.*}}
- ERR-NEXT:{{ *}}^
- ERR-NEXT:{{.*}}: error: undefined variable: UNDEFVAR
- ERR-NEXT:{{CHECK: \[\[#0x8000000000000000\+0x8000000000000000\]\] \[\[UNDEFVAR\]\]}}
- ERR-NEXT:^
-  ERR-NOT:{{error|note|remark}}:
-
-     DUMP:<<<<<<
-DUMP-NEXT:           1: 10000000000000000 
-DUMP-NEXT:check:1'0     X~~~~~~~~~~~~~~~~~ error: match failed for invalid pattern
-DUMP-NEXT:check:1'1                        unable to substitute variable or numeric expression: overflow error
-DUMP-NEXT:check:1'2                        undefined variable: UNDEFVAR
-DUMP-NEXT:>>>>>>
-
-;--------------------------------------------------
-; Check -dump-input=never cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-;--------------------------------------------------
-; Check -dump-input=fail cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP

llvm/test/FileCheck/match-time-error-propagation/matched-excluded-pattern.txt

-; Check handling of diagnostics for problematic matches (e.g., variable capture
-; overflow) in the case of excluded patterns (e.g., CHECK-NOT).
-;
-; At one time, FileCheck's exit status for the following example was zero even
-; though the excluded pattern does match (it's just capturing that fails).
-; Moreover, it printed the error diagnostic only if -vv was specified and input
-; dumps were disabled.  Test every combination as the logic is hard to get
-; right. 
-;
-; TODO: Capturing from an excluded pattern probably shouldn't be permitted
-; because it seems useless: it's captured only if the pattern matches, but then
-; FileCheck fails.  The helpfulness of reporting overflow from that capture is
-; perhaps questionable then, but it doesn't seem harmful either.  Anyway, the
-; goal of this test is simply to exercise the error propagation mechanism for a
-; matched excluded pattern.  In the future, if we have a more interesting error
-; to exercise in that case, we should instead use it in this test, and then we
-; might want to think more about where that error should be presented in the
-; list of diagnostics.
-
-RUN: echo > %t.chk 'CHECK-NOT: [[#122+1]] [[STR:abc]] [[#NUM:]]'
-RUN: echo > %t.in '123 abc 1000000000000000000000000000000000000000000000000000'
-
-     ERR-NOT:{{.}}
-      ERR-VV:{{.*}}: remark: implicit EOF: expected string found in input
- ERR-VV-NEXT:CHECK-NOT: {{.*}}
- ERR-VV-NEXT:{{ *}}^
- ERR-VV-NEXT:{{.*}}: note: found here
-ERR-VV-EMPTY:
- ERR-VV-NEXT:^
-     ERR-NOT:{{.}}
-         ERR:{{.*}}: error: CHECK-NOT: excluded string found in input
-    ERR-NEXT:CHECK-NOT: {{.*}}
-    ERR-NEXT:{{ *}}^
-    ERR-NEXT:<stdin>:1:1: note: found here
-    ERR-NEXT:123 abc 10{{0*}}
-    ERR-NEXT:^~~~~~~~~{{~*}}
-    ERR-NEXT:<stdin>:1:1: note: with "122+1" equal to "123"
-    ERR-NEXT:123 abc 10{{0*}}
-    ERR-NEXT:^
-    ERR-NEXT:<stdin>:1:5: note: captured var "STR"
-    ERR-NEXT:123 abc 10{{0*}}
-    ERR-NEXT:    ^~~
-    ERR-NEXT:<stdin>:1:9: error: unable to represent numeric value
-    ERR-NEXT:123 abc 10{{0*}}
-    ERR-NEXT:        ^
-     ERR-NOT:{{error|note|remark}}:
-
-        DUMP:<<<<<<
-   DUMP-NEXT:         1: 123 abc 10{{0*}} 
-   DUMP-NEXT:not:1'0     !~~~~~~~~~{{~*}}  error: no match expected
-   DUMP-NEXT:not:1'1                       with "122+1" equal to "123"
-   DUMP-NEXT:not:1'2         !~~           captured var "STR"
-   DUMP-NEXT:not:1'3             !~{{~*}}  error: unable to represent numeric value
-DUMP-VV-NEXT:         2: 
-DUMP-VV-NEXT:eof:1       ^
-   DUMP-NEXT:>>>>>>
-
-;--------------------------------------------------
-; Check -dump-input=never cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,ERR-VV
-
-;--------------------------------------------------
-; Check -dump-input=fail cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP,DUMP-VV

llvm/test/FileCheck/match-time-error-propagation/matched-expected-pattern.txt

-; Check handling of diagnostics for problematic matches (e.g., variable capture
-; overflow) in the case of expected patterns (e.g., CHECK).
-
-RUN: echo > %t.chk 'CHECK: [[#122+1]] [[STR:abc]] [[#NUM:]]'
-RUN: echo > %t.in '123 abc 1000000000000000000000000000000000000000000000000000'
-
-  ERR-NOT:{{.}}
-      ERR:{{.*}}: remark: CHECK: expected string found in input
- ERR-NEXT:CHECK: {{.*}}
- ERR-NEXT:{{ *}}^
- ERR-NEXT:<stdin>:1:1: note: found here
- ERR-NEXT:123 abc 10{{0*}}
- ERR-NEXT:^~~~~~~~~{{~*}}
- ERR-NEXT:<stdin>:1:1: note: with "122+1" equal to "123"
- ERR-NEXT:123 abc 10{{0*}}
- ERR-NEXT:^
- ERR-NEXT:<stdin>:1:5: note: captured var "STR"
- ERR-NEXT:123 abc 10{{0*}}
- ERR-NEXT:    ^~~
- ERR-NEXT:<stdin>:1:9: error: unable to represent numeric value
- ERR-NEXT:123 abc 10{{0*}}
- ERR-NEXT:        ^
-  ERR-NOT:{{error|note|remark}}:
-
-     DUMP:<<<<<<
-DUMP-NEXT:           1: 123 abc 10{{0*}} 
-DUMP-NEXT:check:1'0     ^~~~~~~~~~{{~*}}
-DUMP-NEXT:check:1'1                       with "122+1" equal to "123"
-DUMP-NEXT:check:1'2         ^~~           captured var "STR"
-DUMP-NEXT:check:1'3             !~{{~*}}  error: unable to represent numeric value
-DUMP-NEXT:>>>>>>
-
-;--------------------------------------------------
-; Check -dump-input=never cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=never -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR
-
-;--------------------------------------------------
-; Check -dump-input=fail cases.
-;--------------------------------------------------
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -v %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP
-
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -dump-input=fail -vv %t.chk < %t.in 2>&1 \
-RUN: | FileCheck %s -match-full-lines -check-prefixes=ERR,DUMP

llvm/test/FileCheck/numeric-expression.txt

 CLI-STR-CONFLICT-NEXT: {{^}}                  ^{{$}}
 INPUT-NUM-CONFLICT: numeric-expression.txt:[[#@LINE-7]]:22: error: string variable with name 'STRVAR' already exists
  INPUT-NUM-CONFLICT-NEXT: CONFLICT4: redef2 {{\[\[#STRVAR:\]\]}}
 INPUT-NUM-CONFLICT-NEXT: {{^}}                     ^{{$}}
 CLI-NUM-CONFLICT: Global defines:2:45: error: string variable with name 'STRVAR' already exists
  CLI-NUM-CONFLICT-NEXT: Global define #2: #STRVAR=42 (parsed as: {{\[\[#STRVAR:42\]\]}})
 CLI-NUM-CONFLICT-NEXT: {{^}}                                            ^{{$}}
 
-; Numeric variable definition with too big value.
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck --check-prefix BIGVAL --input-file %s %s 2>&1 \
-RUN:   | FileCheck --strict-whitespace --check-prefix BIGVAL-MSG %s
-
-BIG VALUE
-NUMVAR: 10000000000000000000000
-BIGVAL-LABEL: BIG VALUE
-BIGVAL-NEXT: NUMVAR: [[#NUMVAR:]]
-BIGVAL-MSG: numeric-expression.txt:[[#@LINE-3]]:9: error: unable to represent numeric value
- BIGVAL-MSG-NEXT: {{N}}UMVAR: 10000000000000000000000
-BIGVAL-MSG-NEXT: {{^}}        ^{{$}}
-
 ; Verify that when a variable is set to an expression the expression is still
 ; checked.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix DEF-EXPR-FAIL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix DEF-EXPR-FAIL-MSG %s
 
 DEF EXPR WRONG MATCH
 20

 DC
 REDEF-NEW-FMT-LABEL: VAR REDEF FMT CHANGE
 REDEF-NEW-FMT-NEXT: [[#UNSI:]]
 REDEF-NEW-FMT-NEXT: [[#%X,UNSI:]]
 REDEF-NEW-FMT-MSG: numeric-expression.txt:[[#@LINE-1]]:31: error: format different from previous variable definition
 REDEF-NEW-FMT-MSG-NEXT: {{R}}EDEF-NEW-FMT-NEXT: {{\[\[#%X,UNSI:\]\]}}
 REDEF-NEW-FMT-MSG-NEXT:    {{^}}                              ^{{$}}
 
-; Numeric expression with overflow.
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck --check-prefix OVERFLOW --input-file %s %s 2>&1 \
-RUN:   | FileCheck --check-prefix OVERFLOW-MSG --strict-whitespace %s
-
-OVERFLOW
-BIGVAR=10000000000000000
-OVERFLOW-LABEL: OVERFLOW
-OVERFLOW-NEXT: BIGVAR: [[#BIGVAR:0x8000000000000000+0x8000000000000000]]
-OVERFLOW-MSG: numeric-expression.txt:[[#@LINE-1]]:27: error: unable to substitute variable or numeric expression
-OVERFLOW-MSG-NEXT: {{O}}VERFLOW-NEXT: BIGVAR: {{\[\[#BIGVAR:0x8000000000000000\+0x8000000000000000\]\]}}
-OVERFLOW-MSG-NEXT:    {{^}}                          ^{{$}}
-
-; Numeric expression with underflow.
-RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck --check-prefix UNDERFLOW --input-file %s %s 2>&1 \
-RUN:   | FileCheck --check-prefix UNDERFLOW-MSG --strict-whitespace %s
-
-UNDERFLOW
-TINYVAR=-10000000000000000
-UNDERFLOW-LABEL: UNDERFLOW
-UNDERFLOW-NEXT: TINYVAR: [[#%d,TINYVAR:-0x8000000000000000-0x8000000000000000]]
-UNDERFLOW-MSG: numeric-expression.txt:[[#@LINE-1]]:29: error: unable to substitute variable or numeric expression
-UNDERFLOW-MSG-NEXT: {{U}}NDERFLOW-NEXT: TINYVAR: {{\[\[#%d,TINYVAR:-0x8000000000000000-0x8000000000000000\]\]}}
-UNDERFLOW-MSG-NEXT:    {{^}}                            ^{{$}}
-
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#NUMVAR=10 --check-prefix CALL-MISSING-CLOSING-BRACKET --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix CALL-MISSING-CLOSING-BRACKET-MSG %s
 
 CALL MISSING CLOSING BRACKET
 30
 CALL-MISSING-CLOSING-BRACKET-LABEL: CALL MISSING CLOSING BRACKET
 CALL-MISSING-CLOSING-BRACKET-NEXT: [[#add(NUMVAR,3]]

llvm/unittests/FileCheck/FileCheckTest.cpp

if (Negative) {
       NumStr = NumStr.drop_front();
     }
     PaddedStr.append(Precision - NumStr.size(), '0');
     PaddedStr.append(NumStr.str());
     return PaddedStr;
   }
 
   template <class T> void checkMatchingString(T Val, StringRef ExpectedStr) {
-    Expected<std::string> MatchingString =
-        Format.getMatchingString(ExpressionValue(Val));
+    APInt Value(128, Val, std::is_signed_v<T>);
+    Expected<std::string> MatchingString = Format.getMatchingString(Value);
     ASSERT_THAT_EXPECTED(MatchingString, Succeeded())
-        << "No matching string for " << Val;
+        << "No matching string for "
+        << (std::is_signed_v<T> ? Value.getSExtValue() : Value.getZExtValue());
     EXPECT_EQ(*MatchingString, ExpectedStr);
   }
 
   template <class T> void checkMatchingStringFailure(T Val) {
-    Expected<std::string> MatchingString =
-        Format.getMatchingString(ExpressionValue(Val));
+    APInt Value(64, Val, std::is_signed_v<T>);
+    Expected<std::string> MatchingString = Format.getMatchingString(Value);
     // Error message tested in ExpressionValue unit tests.
     EXPECT_THAT_EXPECTED(MatchingString, Failed());
   }
 
-  Expected<ExpressionValue> getValueFromStringReprFailure(StringRef Str) {
+  Expected<APInt> getValueFromStringReprFailure(StringRef Str) {
     StringRef BufferizedStr = bufferize(SM, Str);
     return Format.valueFromStringRepr(BufferizedStr, SM);
   }
 
   template <class T>
   void checkValueFromStringRepr(StringRef Str, T ExpectedVal) {
-    Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
+    Expected<APInt> ResultValue = getValueFromStringReprFailure(Str);
     ASSERT_THAT_EXPECTED(ResultValue, Succeeded())
         << "Failed to get value from " << Str;
     ASSERT_EQ(ResultValue->isNegative(), ExpectedVal < 0)
         << "Value for " << Str << " is not " << ExpectedVal;
-    if (ResultValue->isNegative())
-      EXPECT_EQ(cantFail(ResultValue->getSignedValue()),
-                static_cast<int64_t>(ExpectedVal));
+    if (std::is_signed_v<T>)
+      EXPECT_EQ(ResultValue->getSExtValue(), static_cast<int64_t>(ExpectedVal));
     else
-      EXPECT_EQ(cantFail(ResultValue->getUnsignedValue()),
+      EXPECT_EQ(ResultValue->getZExtValue(),
                 static_cast<uint64_t>(ExpectedVal));
   }
-
-  void checkValueFromStringReprFailure(
-      StringRef Str, StringRef ErrorStr = "unable to represent numeric value") {
-    Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
-    expectDiagnosticError(ErrorStr, ResultValue.takeError());
-  }
 };
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) {
   // Wildcard regex is valid.
   Expected<std::string> WildcardPattern = Format.getWildcardRegex();
   ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded());
   WildcardRegex = Regex((Twine("^") + *WildcardPattern + "$").str());
   ASSERT_TRUE(WildcardRegex.isValid());

 }
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatGetMatchingString) {
   checkMatchingString(0, addBasePrefix(padWithLeadingZeros("0")));
   checkMatchingString(9, addBasePrefix(padWithLeadingZeros("9")));
 
   if (Signed) {
     checkMatchingString(-5, padWithLeadingZeros("-5"));
-    checkMatchingStringFailure(MaxUint64);
+    checkMatchingString(MaxUint64, padWithLeadingZeros(MaxUint64Str));
     checkMatchingString(MaxInt64, padWithLeadingZeros(MaxInt64Str));
     checkMatchingString(MinInt64, padWithLeadingZeros(MinInt64Str));
   } else {
     checkMatchingStringFailure(-5);
     checkMatchingString(MaxUint64,
                         addBasePrefix(padWithLeadingZeros(MaxUint64Str)));
     checkMatchingString(MaxInt64,
                         addBasePrefix(padWithLeadingZeros(MaxInt64Str)));
     checkMatchingStringFailure(MinInt64);
   }
 
   checkMatchingString(10, addBasePrefix(padWithLeadingZeros(TenStr)));
   checkMatchingString(15, addBasePrefix(padWithLeadingZeros(FifteenStr)));
 }
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatValueFromStringRepr) {
   checkValueFromStringRepr(addBasePrefix("0"), 0);
   checkValueFromStringRepr(addBasePrefix("9"), 9);
 
   if (Signed) {
     checkValueFromStringRepr("-5", -5);
-    checkValueFromStringReprFailure(MaxUint64Str);
   } else {
     checkValueFromStringRepr(addBasePrefix(MaxUint64Str), MaxUint64);
   }
 
   checkValueFromStringRepr(addBasePrefix(TenStr), 10);
   checkValueFromStringRepr(addBasePrefix(FifteenStr), 15);
-
-  // Wrong casing is not tested because valueFromStringRepr() relies on
-  // StringRef's getAsInteger() which does not allow to restrict casing.
-  checkValueFromStringReprFailure(addBasePrefix("G"));
 }
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatBoolOperator) {
   EXPECT_TRUE(bool(Format));
 }
 
 INSTANTIATE_TEST_SUITE_P(
     AllowedExplicitExpressionFormat, ExpressionFormatParameterisedFixture,
::testing::Values(
         std::make_tuple(ExpressionFormat::Kind::Signed, 20, false)));
 
 TEST_F(FileCheckTest, NoFormatProperties) {
   ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
   expectError<StringError>("trying to match value with invalid format",
                            NoFormat.getWildcardRegex().takeError());
   expectError<StringError>(
       "trying to match value with invalid format",
-      NoFormat.getMatchingString(ExpressionValue(18u)).takeError());
+      NoFormat.getMatchingString(APInt(64, 18u)).takeError());
   EXPECT_FALSE(bool(NoFormat));
 }
 
 TEST_F(FileCheckTest, FormatEqualityOperators) {
   ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned);
   ExpressionFormat UnsignedFormat2(ExpressionFormat::Kind::Unsigned);
   EXPECT_TRUE(UnsignedFormat == UnsignedFormat2);
   EXPECT_FALSE(UnsignedFormat != UnsignedFormat2);
TEST_F(FileCheckTest, FormatKindEqualityOperators) {
   EXPECT_FALSE(UnsignedFormat != ExpressionFormat::Kind::Unsigned);
   EXPECT_FALSE(UnsignedFormat == ExpressionFormat::Kind::HexLower);
   EXPECT_TRUE(UnsignedFormat != ExpressionFormat::Kind::HexLower);
   ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
   EXPECT_TRUE(NoFormat == ExpressionFormat::Kind::NoFormat);
   EXPECT_FALSE(NoFormat != ExpressionFormat::Kind::NoFormat);
 }
 
-template <class T1, class T2>
-static Expected<ExpressionValue> doValueOperation(binop_eval_t Operation,
-                                                  T1 LeftValue, T2 RightValue) {
-  ExpressionValue LeftOperand(LeftValue);
-  ExpressionValue RightOperand(RightValue);
-  return Operation(LeftOperand, RightOperand);
+template <class T> static APInt toAPInt(T Value) {
+  if (std::is_unsigned_v<T>)
+    return APInt(128, Value);
+  return APInt(128, Value, /*IsSigned=*/true);
 }
 
-template <class T>
-static void expectValueEqual(ExpressionValue ActualValue, T ExpectedValue) {
-  EXPECT_EQ(ExpectedValue < 0, ActualValue.isNegative());
-  if (ExpectedValue < 0) {
-    Expected<int64_t> SignedActualValue = ActualValue.getSignedValue();
-    ASSERT_THAT_EXPECTED(SignedActualValue, Succeeded());
-    EXPECT_EQ(*SignedActualValue, static_cast<int64_t>(ExpectedValue));
-  } else {
-    Expected<uint64_t> UnsignedActualValue = ActualValue.getUnsignedValue();
-    ASSERT_THAT_EXPECTED(UnsignedActualValue, Succeeded());
-    EXPECT_EQ(*UnsignedActualValue, static_cast<uint64_t>(ExpectedValue));
-  }
+static void expectOperationValueResult(binop_eval_t Operation, APInt LeftValue,
+                                       APInt RightValue, APInt ResultValue) {
+  bool Overflow;
+  Expected<APInt> OperationResult = Operation(LeftValue, RightValue, Overflow);
+  ASSERT_THAT_EXPECTED(OperationResult, Succeeded());
+  EXPECT_EQ(*OperationResult, ResultValue);
 }
 
-template <class T1, class T2, class TR>
-static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
-                                       T2 RightValue, TR ResultValue) {
-  Expected<ExpressionValue> OperationResult =
-      doValueOperation(Operation, LeftValue, RightValue);
-  ASSERT_THAT_EXPECTED(OperationResult, Succeeded());
-  expectValueEqual(*OperationResult, ResultValue);
+template <class T1, class T2, class T3>
+static void expectOperationValueResult(binop_eval_t Operation, T1 LeftVal,
+                                       T2 RightVal, T3 ResultVal) {
+  APInt LeftValue(128, LeftVal, std::is_signed_v<T1>);
+  APInt RightValue(128, RightVal, std::is_signed_v<T2>);
+  APInt ResultValue = std::is_integral_v<T3>
+                          ? APInt(128, ResultVal, std::is_signed_v<T3>)
+                          : APInt(128, ResultVal, /*Radix=*/10);
+  expectOperationValueResult(Operation, LeftValue, RightValue, ResultValue);
 }
 
 template <class T1, class T2>
-static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
-                                       T2 RightValue) {
-  expectError<OverflowError>(
-      "overflow error",
-      doValueOperation(Operation, LeftValue, RightValue).takeError());
-}
-
-TEST_F(FileCheckTest, ExpressionValueGetUnsigned) {
-  // Test positive value.
-  Expected<uint64_t> UnsignedValue = ExpressionValue(10).getUnsignedValue();
-  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
-  EXPECT_EQ(*UnsignedValue, 10U);
-
-  // Test 0.
-  UnsignedValue = ExpressionValue(0).getUnsignedValue();
-  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
-  EXPECT_EQ(*UnsignedValue, 0U);
-
-  // Test max positive value.
-  UnsignedValue = ExpressionValue(MaxUint64).getUnsignedValue();
-  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
-  EXPECT_EQ(*UnsignedValue, MaxUint64);
-
-  // Test failure with negative value.
-  expectError<OverflowError>(
-      "overflow error", ExpressionValue(-1).getUnsignedValue().takeError());
-
-  // Test failure with min negative value.
-  expectError<OverflowError>(
-      "overflow error",
-      ExpressionValue(MinInt64).getUnsignedValue().takeError());
-}
-
-TEST_F(FileCheckTest, ExpressionValueGetSigned) {
-  // Test positive value.
-  Expected<int64_t> SignedValue = ExpressionValue(10).getSignedValue();
-  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
-  EXPECT_EQ(*SignedValue, 10);
-
-  // Test 0.
-  SignedValue = ExpressionValue(0).getSignedValue();
-  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
-  EXPECT_EQ(*SignedValue, 0);
-
-  // Test max int64_t.
-  SignedValue = ExpressionValue(MaxInt64).getSignedValue();
-  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
-  EXPECT_EQ(*SignedValue, MaxInt64);
-
-  // Test failure with too big positive value.
-  expectError<OverflowError>(
-      "overflow error", ExpressionValue(static_cast<uint64_t>(MaxInt64) + 1)
-                            .getSignedValue()
-                            .takeError());
-
-  // Test failure with max uint64_t.
-  expectError<OverflowError>(
-      "overflow error",
-      ExpressionValue(MaxUint64).getSignedValue().takeError());
-
-  // Test negative value.
-  SignedValue = ExpressionValue(-10).getSignedValue();
-  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
-  EXPECT_EQ(*SignedValue, -10);
-
-  // Test min int64_t.
-  SignedValue = ExpressionValue(MinInt64).getSignedValue();
-  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
-  EXPECT_EQ(*SignedValue, MinInt64);
-}
-
-TEST_F(FileCheckTest, ExpressionValueAbsolute) {
-  // Test positive value.
-  expectValueEqual(ExpressionValue(10).getAbsolute(), 10);
-
-  // Test 0.
-  expectValueEqual(ExpressionValue(0).getAbsolute(), 0);
-
-  // Test max uint64_t.
-  expectValueEqual(ExpressionValue(MaxUint64).getAbsolute(), MaxUint64);
-
-  // Test negative value.
-  expectValueEqual(ExpressionValue(-10).getAbsolute(), 10);
-
-  // Test absence of overflow on min int64_t.
-  expectValueEqual(ExpressionValue(MinInt64).getAbsolute(),
-                   static_cast<uint64_t>(-(MinInt64 + 10)) + 10);
+static void expectOperationValueResult(binop_eval_t Operation, T1 LeftVal,
+                                       T2 RightVal) {
+  bool Overflow;
+  APInt LeftValue(128, LeftVal, std::is_signed_v<T1>);
+  APInt RightValue(128, RightVal, std::is_signed_v<T2>);
+  expectError<DivByZeroError>(
+      "division by zero error",
+      Operation(LeftValue, RightValue, Overflow).takeError());
 }
 
-TEST_F(FileCheckTest, ExpressionValueAddition) {
+TEST_F(FileCheckTest, ExpressionAddition) {
   // Test both negative values.
-  expectOperationValueResult(operator+, -10, -10, -20);
+  expectOperationValueResult(exprAdd, -10, -10, -20);
 
-  // Test both negative values with underflow.
-  expectOperationValueResult(operator+, MinInt64, -1);
-  expectOperationValueResult(operator+, MinInt64, MinInt64);
+  // Test both negative values with result not representable in int64_t.
+  expectOperationValueResult(exprAdd, MinInt64, -1, "-9223372036854775809");
+  expectOperationValueResult(exprAdd, MinInt64, MinInt64,
+                             "-18446744073709551616");
 
   // Test negative and positive value.
-  expectOperationValueResult(operator+, -10, 10, 0);
-  expectOperationValueResult(operator+, -10, 11, 1);
-  expectOperationValueResult(operator+, -11, 10, -1);
+  expectOperationValueResult(exprAdd, -10, 10, 0);
+  expectOperationValueResult(exprAdd, -10, 11, 1);
+  expectOperationValueResult(exprAdd, -11, 10, -1);
 
   // Test positive and negative value.
-  expectOperationValueResult(operator+, 10, -10, 0);
-  expectOperationValueResult(operator+, 10, -11, -1);
-  expectOperationValueResult(operator+, 11, -10, 1);
+  expectOperationValueResult(exprAdd, 10, -10, 0);
+  expectOperationValueResult(exprAdd, 10, -11, -1);
+  expectOperationValueResult(exprAdd, 11, -10, 1);
 
   // Test both positive values.
-  expectOperationValueResult(operator+, 10, 10, 20);
+  expectOperationValueResult(exprAdd, 10, 10, 20);
 
-  // Test both positive values with overflow.
-  expectOperationValueResult(operator+, MaxUint64, 1);
-  expectOperationValueResult(operator+, MaxUint64, MaxUint64);
+  // Test both positive values with result not representable in uint64_t.
+  expectOperationValueResult(exprAdd, MaxUint64, 1, "18446744073709551616");
+  expectOperationValueResult(exprAdd, MaxUint64, MaxUint64,
+                             "36893488147419103230");
 }
 
-TEST_F(FileCheckTest, ExpressionValueSubtraction) {
+TEST_F(FileCheckTest, ExpressionSubtraction) {
   // Test negative value and value bigger than int64_t max.
-  expectOperationValueResult(operator-, -10, MaxUint64);
+  expectOperationValueResult(exprSub, -10, MaxUint64, "-18446744073709551625");
 
-  // Test negative and positive value with underflow.
-  expectOperationValueResult(operator-, MinInt64, 1);
+  // Test negative and positive value with result not representable in int64_t.
+  expectOperationValueResult(exprSub, MinInt64, 1, "-9223372036854775809");
 
   // Test negative and positive value.
-  expectOperationValueResult(operator-, -10, 10, -20);
+  expectOperationValueResult(exprSub, -10, 10, -20);
 
   // Test both negative values.
-  expectOperationValueResult(operator-, -10, -10, 0);
-  expectOperationValueResult(operator-, -11, -10, -1);
-  expectOperationValueResult(operator-, -10, -11, 1);
+  expectOperationValueResult(exprSub, -10, -10, 0);
+  expectOperationValueResult(exprSub, -11, -10, -1);
+  expectOperationValueResult(exprSub, -10, -11, 1);
 
   // Test positive and negative values.
-  expectOperationValueResult(operator-, 10, -10, 20);
+  expectOperationValueResult(exprSub, 10, -10, 20);
 
   // Test both positive values with result positive.
-  expectOperationValueResult(operator-, 10, 5, 5);
+  expectOperationValueResult(exprSub, 10, 5, 5);
 
-  // Test both positive values with underflow.
-  expectOperationValueResult(operator-, 0, MaxUint64);
-  expectOperationValueResult(operator-, 0,
-                             static_cast<uint64_t>(-(MinInt64 + 10)) + 11);
+  // Test both positive values with result not representable on int64_t.
+  expectOperationValueResult(exprSub, 0, MaxUint64, "-18446744073709551615");
+  expectOperationValueResult(exprSub, 0,
+                             static_cast<uint64_t>(-(MinInt64 + 10)) + 11,
+                             "-9223372036854775809");
 
   // Test both positive values with result < -(max int64_t)
-  expectOperationValueResult(operator-, 10,
+#if 0
+  expectOperationValueResult(exprSub, 10,
                              static_cast<uint64_t>(MaxInt64) + 11,
                              -MaxInt64 - 1);
+#endif
 
   // Test both positive values with 0 > result > -(max int64_t)
-  expectOperationValueResult(operator-, 10, 11, -1);
+  expectOperationValueResult(exprSub, 10, 11, -1);
 }
 
 TEST_F(FileCheckTest, ExpressionValueMultiplication) {
   // Test mixed signed values.
-  expectOperationValueResult(operator*, -3, 10, -30);
-  expectOperationValueResult(operator*, 2, -17, -34);
-  expectOperationValueResult(operator*, 0, MinInt64, 0);
-  expectOperationValueResult(operator*, MinInt64, 1, MinInt64);
-  expectOperationValueResult(operator*, 1, MinInt64, MinInt64);
-  expectOperationValueResult(operator*, MaxInt64, -1, -MaxInt64);
-  expectOperationValueResult(operator*, -1, MaxInt64, -MaxInt64);
+  expectOperationValueResult(exprMul, -3, 10, -30);
+  expectOperationValueResult(exprMul, 2, -17, -34);
+  expectOperationValueResult(exprMul, 0, MinInt64, 0);
+  expectOperationValueResult(exprMul, MinInt64, 1, MinInt64);
+  expectOperationValueResult(exprMul, 1, MinInt64, MinInt64);
+  expectOperationValueResult(exprMul, MaxInt64, -1, -MaxInt64);
+  expectOperationValueResult(exprMul, -1, MaxInt64, -MaxInt64);
 
   // Test both negative values.
-  expectOperationValueResult(operator*, -3, -10, 30);
-  expectOperationValueResult(operator*, -2, -17, 34);
-  expectOperationValueResult(operator*, MinInt64, -1, AbsoluteMinInt64);
+  expectOperationValueResult(exprMul, -3, -10, 30);
+  expectOperationValueResult(exprMul, -2, -17, 34);
+  expectOperationValueResult(exprMul, MinInt64, -1, AbsoluteMinInt64);
 
   // Test both positive values.
-  expectOperationValueResult(operator*, 3, 10, 30);
-  expectOperationValueResult(operator*, 2, 17, 34);
-  expectOperationValueResult(operator*, 0, MaxUint64, 0);
-
-  // Test negative results that underflow.
-  expectOperationValueResult(operator*, -10, MaxInt64);
-  expectOperationValueResult(operator*, MaxInt64, -10);
-  expectOperationValueResult(operator*, 10, MinInt64);
-  expectOperationValueResult(operator*, MinInt64, 10);
-  expectOperationValueResult(operator*, -1, MaxUint64);
-  expectOperationValueResult(operator*, MaxUint64, -1);
-  expectOperationValueResult(operator*, -1, AbsoluteMaxInt64 + 2);
-  expectOperationValueResult(operator*, AbsoluteMaxInt64 + 2, -1);
-
-  // Test positive results that overflow.
-  expectOperationValueResult(operator*, 10, MaxUint64);
-  expectOperationValueResult(operator*, MaxUint64, 10);
-  expectOperationValueResult(operator*, MinInt64, -10);
-  expectOperationValueResult(operator*, -10, MinInt64);
+  expectOperationValueResult(exprMul, 3, 10, 30);
+  expectOperationValueResult(exprMul, 2, 17, 34);
+  expectOperationValueResult(exprMul, 0, MaxUint64, 0);
+
+  // Test negative results not representable in int64_t.
+  expectOperationValueResult(exprMul, -10, MaxInt64, "-92233720368547758070");
+  expectOperationValueResult(exprMul, MaxInt64, -10, "-92233720368547758070");
+  expectOperationValueResult(exprMul, 10, MinInt64, "-92233720368547758080");
+  expectOperationValueResult(exprMul, MinInt64, 10, "-92233720368547758080");
+  expectOperationValueResult(exprMul, -1, MaxUint64, "-18446744073709551615");
+  expectOperationValueResult(exprMul, MaxUint64, -1, "-18446744073709551615");
+  expectOperationValueResult(exprMul, -1, AbsoluteMaxInt64 + 2,
+                             "-9223372036854775809");
+  expectOperationValueResult(exprMul, AbsoluteMaxInt64 + 2, -1,
+                             "-9223372036854775809");
+
+  // Test positive results not representable in uint64_t.
+  expectOperationValueResult(exprMul, 10, MaxUint64, "184467440737095516150");
+  expectOperationValueResult(exprMul, MaxUint64, 10, "184467440737095516150");
+  expectOperationValueResult(exprMul, MinInt64, -10, "92233720368547758080");
+  expectOperationValueResult(exprMul, -10, MinInt64, "92233720368547758080");
 }
 
 TEST_F(FileCheckTest, ExpressionValueDivision) {
   // Test mixed signed values.
-  expectOperationValueResult(operator/, -30, 10, -3);
-  expectOperationValueResult(operator/, 34, -17, -2);
-  expectOperationValueResult(operator/, 0, -10, 0);
-  expectOperationValueResult(operator/, MinInt64, 1, MinInt64);
-  expectOperationValueResult(operator/, MaxInt64, -1, -MaxInt64);
-  expectOperationValueResult(operator/, -MaxInt64, 1, -MaxInt64);
+  expectOperationValueResult(exprDiv, -30, 10, -3);
+  expectOperationValueResult(exprDiv, 34, -17, -2);
+  expectOperationValueResult(exprDiv, 0, -10, 0);
+  expectOperationValueResult(exprDiv, MinInt64, 1, MinInt64);
+  expectOperationValueResult(exprDiv, MaxInt64, -1, -MaxInt64);
+  expectOperationValueResult(exprDiv, -MaxInt64, 1, -MaxInt64);
 
   // Test both negative values.
-  expectOperationValueResult(operator/, -30, -10, 3);
-  expectOperationValueResult(operator/, -34, -17, 2);
+  expectOperationValueResult(exprDiv, -30, -10, 3);
+  expectOperationValueResult(exprDiv, -34, -17, 2);
 
   // Test both positive values.
-  expectOperationValueResult(operator/, 30, 10, 3);
-  expectOperationValueResult(operator/, 34, 17, 2);
-  expectOperationValueResult(operator/, 0, 10, 0);
+  expectOperationValueResult(exprDiv, 30, 10, 3);
+  expectOperationValueResult(exprDiv, 34, 17, 2);
+  expectOperationValueResult(exprDiv, 0, 10, 0);
 
   // Test divide by zero.
-  expectOperationValueResult(operator/, -10, 0);
-  expectOperationValueResult(operator/, 10, 0);
-  expectOperationValueResult(operator/, 0, 0);
-
-  // Test negative result that underflows.
-  expectOperationValueResult(operator/, MaxUint64, -1);
-  expectOperationValueResult(operator/, AbsoluteMaxInt64 + 2, -1);
-}
-
-TEST_F(FileCheckTest, ExpressionValueEquality) {
-  // Test negative and positive value.
-  EXPECT_FALSE(ExpressionValue(5) == ExpressionValue(-3));
-  EXPECT_TRUE(ExpressionValue(5) != ExpressionValue(-3));
-  EXPECT_FALSE(ExpressionValue(-2) == ExpressionValue(6));
-  EXPECT_TRUE(ExpressionValue(-2) != ExpressionValue(6));
-  EXPECT_FALSE(ExpressionValue(-7) == ExpressionValue(7));
-  EXPECT_TRUE(ExpressionValue(-7) != ExpressionValue(7));
-  EXPECT_FALSE(ExpressionValue(4) == ExpressionValue(-4));
-  EXPECT_TRUE(ExpressionValue(4) != ExpressionValue(-4));
-  EXPECT_FALSE(ExpressionValue(MaxUint64) == ExpressionValue(-1));
-  EXPECT_TRUE(ExpressionValue(MaxUint64) != ExpressionValue(-1));
-
-  // Test both negative values.
-  EXPECT_FALSE(ExpressionValue(-2) == ExpressionValue(-7));
-  EXPECT_TRUE(ExpressionValue(-2) != ExpressionValue(-7));
-  EXPECT_TRUE(ExpressionValue(-3) == ExpressionValue(-3));
-  EXPECT_FALSE(ExpressionValue(-3) != ExpressionValue(-3));
-  EXPECT_FALSE(ExpressionValue(MinInt64) == ExpressionValue(-1));
-  EXPECT_TRUE(ExpressionValue(MinInt64) != ExpressionValue(-1));
-  EXPECT_FALSE(ExpressionValue(MinInt64) == ExpressionValue(-0));
-  EXPECT_TRUE(ExpressionValue(MinInt64) != ExpressionValue(-0));
-
-  // Test both positive values.
-  EXPECT_FALSE(ExpressionValue(8) == ExpressionValue(9));
-  EXPECT_TRUE(ExpressionValue(8) != ExpressionValue(9));
-  EXPECT_TRUE(ExpressionValue(1) == ExpressionValue(1));
-  EXPECT_FALSE(ExpressionValue(1) != ExpressionValue(1));
-
-  // Check the signedness of zero doesn't affect equality.
-  EXPECT_TRUE(ExpressionValue(0) == ExpressionValue(0));
-  EXPECT_FALSE(ExpressionValue(0) != ExpressionValue(0));
-  EXPECT_TRUE(ExpressionValue(0) == ExpressionValue(-0));
-  EXPECT_FALSE(ExpressionValue(0) != ExpressionValue(-0));
-  EXPECT_TRUE(ExpressionValue(-0) == ExpressionValue(0));
-  EXPECT_FALSE(ExpressionValue(-0) != ExpressionValue(0));
-  EXPECT_TRUE(ExpressionValue(-0) == ExpressionValue(-0));
-  EXPECT_FALSE(ExpressionValue(-0) != ExpressionValue(-0));
+  expectOperationValueResult(exprDiv, -10, 0);
+  expectOperationValueResult(exprDiv, 10, 0);
+  expectOperationValueResult(exprDiv, 0, 0);
+
+  // Test negative result not representable in int64_t.
+  expectOperationValueResult(exprDiv, MaxUint64, -1, "-18446744073709551615");
+  expectOperationValueResult(exprDiv, AbsoluteMaxInt64 + 2, -1,
+                             "-9223372036854775809");
 }
 
 TEST_F(FileCheckTest, Literal) {
   SourceMgr SM;
 
   // Eval returns the literal's value.
-  ExpressionLiteral Ten(bufferize(SM, "10"), 10u);
-  Expected<ExpressionValue> Value = Ten.eval();
+  ExpressionLiteral Ten(bufferize(SM, "10"), APInt(64, 10u));
+  Expected<APInt> Value = Ten.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
-  EXPECT_EQ(10, cantFail(Value->getSignedValue()));
+  EXPECT_EQ(10, Value->getSExtValue());
   Expected<ExpressionFormat> ImplicitFormat = Ten.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::NoFormat);
 
   // Min value can be correctly represented.
-  ExpressionLiteral Min(bufferize(SM, std::to_string(MinInt64)), MinInt64);
+  ExpressionLiteral Min(bufferize(SM, std::to_string(MinInt64)),
+                        APInt(64, MinInt64, /*IsSigned=*/true));
   Value = Min.eval();
   ASSERT_TRUE(bool(Value));
-  EXPECT_EQ(MinInt64, cantFail(Value->getSignedValue()));
+  EXPECT_EQ(MinInt64, Value->getSExtValue());
 
   // Max value can be correctly represented.
-  ExpressionLiteral Max(bufferize(SM, std::to_string(MaxUint64)), MaxUint64);
+  ExpressionLiteral Max(bufferize(SM, std::to_string(MaxUint64)),
+                        APInt(64, MaxUint64));
   Value = Max.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
-  EXPECT_EQ(MaxUint64, cantFail(Value->getUnsignedValue()));
+  EXPECT_EQ(MaxUint64, Value->getZExtValue());
 }
 
 TEST_F(FileCheckTest, Expression) {
   SourceMgr SM;
 
   std::unique_ptr<ExpressionLiteral> Ten =
-      std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), 10u);
+      std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), APInt(64, 10u));
   ExpressionLiteral *TenPtr = Ten.get();
   Expression Expr(std::move(Ten),
                   ExpressionFormat(ExpressionFormat::Kind::HexLower));
   EXPECT_EQ(Expr.getAST(), TenPtr);
   EXPECT_EQ(Expr.getFormat(), ExpressionFormat::Kind::HexLower);
 }
 
 static void
NumericVariable FooVar("FOO",
                          ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
   EXPECT_EQ("FOO", FooVar.getName());
   EXPECT_EQ(FooVar.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
   NumericVariableUse FooVarUse("FOO", &FooVar);
   Expected<ExpressionFormat> ImplicitFormat = FooVarUse.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
   EXPECT_FALSE(FooVar.getValue());
-  Expected<ExpressionValue> EvalResult = FooVarUse.eval();
+  Expected<APInt> EvalResult = FooVarUse.eval();
   expectUndefErrors({"FOO"}, EvalResult.takeError());
 
   // Defined variable without string: only getValue and eval return value set.
-  FooVar.setValue(ExpressionValue(42u));
-  std::optional<ExpressionValue> Value = FooVar.getValue();
+  FooVar.setValue(APInt(64, 42u));
+  std::optional<APInt> Value = FooVar.getValue();
   ASSERT_TRUE(Value);
-  EXPECT_EQ(42, cantFail(Value->getSignedValue()));
+  EXPECT_EQ(42u, Value->getZExtValue());
   EXPECT_FALSE(FooVar.getStringValue());
   EvalResult = FooVarUse.eval();
   ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
-  EXPECT_EQ(42, cantFail(EvalResult->getSignedValue()));
+  EXPECT_EQ(42u, EvalResult->getZExtValue());
 
   // Defined variable with string: getValue, eval, and getStringValue return
   // value set.
   StringRef StringValue = "925";
-  FooVar.setValue(ExpressionValue(925u), StringValue);
+  FooVar.setValue(APInt(64, 925u), StringValue);
   Value = FooVar.getValue();
   ASSERT_TRUE(Value);
-  EXPECT_EQ(925, cantFail(Value->getSignedValue()));
+  EXPECT_EQ(925u, Value->getZExtValue());
   // getStringValue should return the same memory not just the same characters.
   EXPECT_EQ(StringValue.begin(), FooVar.getStringValue()->begin());
   EXPECT_EQ(StringValue.end(), FooVar.getStringValue()->end());
   EvalResult = FooVarUse.eval();
   ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
-  EXPECT_EQ(925, cantFail(EvalResult->getSignedValue()));
-  EXPECT_EQ(925, cantFail(EvalResult->getSignedValue()));
+  EXPECT_EQ(925u, EvalResult->getZExtValue());
+  EXPECT_EQ(925u, EvalResult->getZExtValue());
 
   // Clearing variable: getValue and eval fail. Error returned by eval holds
   // the name of the cleared variable.
   FooVar.clearValue();
   EXPECT_FALSE(FooVar.getValue());
   EXPECT_FALSE(FooVar.getStringValue());
   EvalResult = FooVarUse.eval();
   expectUndefErrors({"FOO"}, EvalResult.takeError());
 }
 
 TEST_F(FileCheckTest, Binop) {
   SourceMgr SM;
 
   StringRef ExprStr = bufferize(SM, "FOO+BAR");
   StringRef FooStr = ExprStr.take_front(3);
   NumericVariable FooVar(FooStr,
                          ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
-  FooVar.setValue(ExpressionValue(42u));
+  FooVar.setValue(APInt(64, 42u));
   std::unique_ptr<NumericVariableUse> FooVarUse =
       std::make_unique<NumericVariableUse>(FooStr, &FooVar);
   StringRef BarStr = ExprStr.take_back(3);
   NumericVariable BarVar(BarStr,
                          ExpressionFormat(ExpressionFormat::Kind::Unsigned), 2);
-  BarVar.setValue(ExpressionValue(18u));
+  BarVar.setValue(APInt(64, 18u));
   std::unique_ptr<NumericVariableUse> BarVarUse =
       std::make_unique<NumericVariableUse>(BarStr, &BarVar);
-  binop_eval_t doAdd = operator+;
+  binop_eval_t doAdd = exprAdd;
   BinaryOperation Binop(ExprStr, doAdd, std::move(FooVarUse),
                         std::move(BarVarUse));
 
-  // Defined variables: eval returns right value; implicit format is as
-  // expected.
-  Expected<ExpressionValue> Value = Binop.eval();
+  // Defined variables with same bitwidth and no overflow: eval returns right
+  // value; implicit format is as expected.
+  Expected<APInt> Value = Binop.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
-  EXPECT_EQ(60, cantFail(Value->getSignedValue()));
+  EXPECT_EQ(60u, Value->getZExtValue());
   Expected<ExpressionFormat> ImplicitFormat = Binop.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
 
+  // Defined variables with different bitwidth and no overflow: eval succeeds
+  // and return the right value.
+  BarVar.setValue(APInt(32, 18u));
+  Value = Binop.eval();
+  ASSERT_THAT_EXPECTED(Value, Succeeded());
+  EXPECT_EQ(60u, Value->getZExtValue());
+
+  // Defined variables with same bitwidth and wider result (i.e. overflow):
+  // eval succeeds and return the right value in a wider APInt.
+  BarVar.setValue(APInt(64, AbsoluteMaxInt64));
+  Value = Binop.eval();
+  ASSERT_THAT_EXPECTED(Value, Succeeded());
+  EXPECT_EQ(128u, Value->getBitWidth());
+  EXPECT_EQ(APInt(128, AbsoluteMaxInt64 + FooVar.getValue()->getZExtValue()),
+            *Value);
+
   // 1 undefined variable: eval fails, error contains name of undefined
   // variable.
   FooVar.clearValue();
   Value = Binop.eval();
   expectUndefErrors({"FOO"}, Value.takeError());
 
   // 2 undefined variables: eval fails, error contains names of all undefined
   // variables.
   BarVar.clearValue();
   Value = Binop.eval();
   expectUndefErrors({"FOO", "BAR"}, Value.takeError());
 
   // Literal + Variable has format of variable.
   ExprStr = bufferize(SM, "FOO+18");
   FooStr = ExprStr.take_front(3);
   StringRef EighteenStr = ExprStr.take_back(2);
   FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
   std::unique_ptr<ExpressionLiteral> Eighteen =
-      std::make_unique<ExpressionLiteral>(EighteenStr, 18u);
+      std::make_unique<ExpressionLiteral>(EighteenStr, APInt(64, 18u));
   Binop = BinaryOperation(ExprStr, doAdd, std::move(FooVarUse),
                           std::move(Eighteen));
   ImplicitFormat = Binop.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
   ExprStr = bufferize(SM, "18+FOO");
   FooStr = ExprStr.take_back(3);
   EighteenStr = ExprStr.take_front(2);
   FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
-  Eighteen = std::make_unique<ExpressionLiteral>(EighteenStr, 18u);
+  Eighteen = std::make_unique<ExpressionLiteral>(EighteenStr, APInt(64, 18u));
   Binop = BinaryOperation(ExprStr, doAdd, std::move(Eighteen),
                           std::move(FooVarUse));
   ImplicitFormat = Binop.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
 
   // Variables with different implicit format conflict.
   ExprStr = bufferize(SM, "FOO+BAZ");

 }
 
 TEST_F(FileCheckTest, Match) {
   PatternTester Tester;
 
   // Check a substitution error is diagnosed.
   ASSERT_FALSE(Tester.parsePattern("[[#%u, -1]]"));
   expectDiagnosticError(
-      "unable to substitute variable or numeric expression: overflow error",
+      "unable to substitute variable or numeric expression: underflow error",
       Tester.match("").takeError());
 
   // Check matching an empty expression only matches a number.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("[[#]]"));
   expectNotFoundError(Tester.match("FAIL").takeError());
   EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
 
TEST_F(FileCheckTest, Substitution) {
   StringSubstitution StringSubstitution(&Context, "VAR404", 42);
   Expected<std::string> SubstValue = StringSubstitution.getResult();
   expectUndefErrors({"VAR404"}, SubstValue.takeError());
 
   // Numeric substitution blocks constituted of defined numeric variables are
   // substituted for the variable's value.
   NumericVariable NVar("N", ExpressionFormat(ExpressionFormat::Kind::Unsigned),
                        1);
-  NVar.setValue(ExpressionValue(10u));
+  NVar.setValue(APInt(64, 10u));
   auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar);
   auto ExpressionN = std::make_unique<Expression>(
       std::move(NVarUse), ExpressionFormat(ExpressionFormat::Kind::HexUpper));
   NumericSubstitution SubstitutionN(&Context, "N", std::move(ExpressionN),
                                     /*InsertIdx=*/30);
   SubstValue = SubstitutionN.getResult();
   ASSERT_THAT_EXPECTED(SubstValue, Succeeded());
   EXPECT_EQ("A", *SubstValue);
Expected<std::unique_ptr<Expression>> ExpressionPointer =
       P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable,
                                       /*IsLegacyLineExpr=*/false, LineNumber,
                                       &Cxt, SM);
   ASSERT_THAT_EXPECTED(LocalVar, Succeeded());
   EXPECT_EQ(*LocalVar, "FOO");
   Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
-  Expected<ExpressionValue> ExpressionVal =
-      (*ExpressionPointer)->getAST()->eval();
+  Expected<APInt> ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
-  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 18);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 18);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar2Ref, DefinedNumericVariable,
       /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
   ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
-  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 20);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 20);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar3Ref, DefinedNumericVariable,
       /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
   ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
-  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 12);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 12);
   ASSERT_THAT_EXPECTED(EmptyVar, Succeeded());
   EXPECT_EQ(*EmptyVar, "");
   expectUndefErrors({std::string(UnknownVarStr)}, UnknownVar.takeError());
 
   // Clear local variables and check they become absent.
   Cxt.clearLocalVars();
   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   expectUndefErrors({std::string(LocalVarStr)}, LocalVar.takeError());
#endif
   EXPECT_EQ(*GlobalVar, "BAR");
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
   ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
-  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 36);
 
   // Clear local variables and check global variables remain defined.
   Cxt.clearLocalVars();
   EXPECT_THAT_EXPECTED(Cxt.getPatternVarValue(GlobalVarStr), Succeeded());
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
   ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
-  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 36);
 }
 
 TEST_F(FileCheckTest, CapturedVarDiags) {
   PatternTester Tester;
   ASSERT_FALSE(Tester.parsePattern("[[STRVAR:[a-z]+]] [[#NUMVAR:@LINE]]"));
   EXPECT_THAT_EXPECTED(Tester.match("foobar 2"), Succeeded());
   std::vector<FileCheckDiag> Diags;
   Tester.printVariableDefs(FileCheckDiag::MatchFoundAndExpected, Diags);