[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

161

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

llvm/lib/FileCheck/FileCheckImpl.h

122

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.

161

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

398

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

122

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.

161

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

396–397

Unused, oops

487–490

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

246

std::max?

252

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

263

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

252

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

252

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

llvm/lib/FileCheck/FileCheck.cpp

default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 }
 
 Expected<std::string>
 ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const {
   APInt IntValue = IntegerValue.getAPIntValue();
-  // Error out for values that cannot be represented by the appropriate 64-bit
-  // integer (e.g. int64_t for a signed format) to keep the getter of
-  // ExpressionValue as an APInt an NFC.
-  if (Value == Kind::Signed) {
-    if (!IntValue.isSignedIntN(64))
-      return make_error<OverflowError>();
-  } else {
-    if (!IntValue.isIntN(64))
-      return make_error<OverflowError>();
-  }
+  if (Value != Kind::Signed && IntValue.isNegative())
 
   unsigned Radix;
   bool UpperCase = false;
   SmallString<8> AbsoluteValueStr;
   StringRef SignPrefix = IntValue.isNegative() ? "-" : "";
   switch (Value) {
   case Kind::Unsigned:
   case Kind::Signed:
return (Twine(SignPrefix) + Twine(AlternateFormPrefix) +
             std::string(LeadingZeros, '0') + AbsoluteValueStr)
         .str();
   }
 
   return (Twine(SignPrefix) + Twine(AlternateFormPrefix) + AbsoluteValueStr)
       .str();
 }
 
+static unsigned nextAPIntBitWidth(unsigned BitWidth) {
+  return (BitWidth < APInt::APINT_BITS_PER_WORD) ? APInt::APINT_BITS_PER_WORD
+                                                 : BitWidth * 2;
+}
+
+static APInt toSigned(APInt AbsVal, bool Negative) {
+  if (AbsVal.isSignBitSet())
+    AbsVal = AbsVal.zext(nextAPIntBitWidth(AbsVal.getBitWidth()));
+  APInt Result = AbsVal;
+  if (Negative)
+    Result.negate();
+  return Result;
+}
+
 Expected<ExpressionValue>
 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);
-
-  return ExpressionValue(UnsignedValue);
+  APInt ResultValue;
+  bool ParseFailure = StrVal.getAsInteger(Hex ? 16 : 10, ResultValue);
+  if (ParseFailure)
+    return ErrorDiagnostic::get(SM, StrVal,
+                                "unable to represent numeric value");
+  return ExpressionValue(toSigned(ResultValue, Negative));
 }
 
-Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  bool Overflow;
+Expected<ExpressionValue> llvm::exprAdd(const ExpressionValue &LeftOperand,
+                                        const ExpressionValue &RightOperand,
+                                        bool &Overflow) {
   APInt Result = LeftOperand.getAPIntValue().sadd_ov(
       RightOperand.getAPIntValue(), Overflow);
-  if (Overflow ||
-      (Result.isNegative() && !Result.isSignedIntN(Result.getBitWidth() - 1)))
-    return make_error<OverflowError>();
-
-  if (Result.isNegative())
-    return ExpressionValue(Result.getSExtValue());
-  else
-    return ExpressionValue(Result.getZExtValue());
+  return ExpressionValue(Result);
 }
 
-Expected<ExpressionValue> llvm::operator-(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  bool Overflow;
+Expected<ExpressionValue> llvm::exprSub(const ExpressionValue &LeftOperand,
+                                        const ExpressionValue &RightOperand,
+                                        bool &Overflow) {
   APInt Result = LeftOperand.getAPIntValue().ssub_ov(
       RightOperand.getAPIntValue(), Overflow);
-  if (Overflow ||
-      (Result.isNegative() && !Result.isSignedIntN(Result.getBitWidth() - 1)))
-    return make_error<OverflowError>();
-
-  if (Result.isNegative())
-    return ExpressionValue(Result.getSExtValue());
-  else
-    return ExpressionValue(Result.getZExtValue());
+  return ExpressionValue(Result);
 }
 
-Expected<ExpressionValue> llvm::operator*(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
-  bool Overflow;
+Expected<ExpressionValue> llvm::exprMul(const ExpressionValue &LeftOperand,
+                                        const ExpressionValue &RightOperand,
+                                        bool &Overflow) {
   APInt Result = LeftOperand.getAPIntValue().smul_ov(
       RightOperand.getAPIntValue(), Overflow);
-  if (Overflow ||
-      (Result.isNegative() && !Result.isSignedIntN(Result.getBitWidth() - 1)))
-    return make_error<OverflowError>();
-
-  if (Result.isNegative())
-    return ExpressionValue(Result.getSExtValue());
-  else
-    return ExpressionValue(Result.getZExtValue());
+  return ExpressionValue(Result);
 }
 
-Expected<ExpressionValue> llvm::operator/(const ExpressionValue &LeftOperand,
-                                          const ExpressionValue &RightOperand) {
+Expected<ExpressionValue> llvm::exprDiv(const ExpressionValue &LeftOperand,
+                                        const ExpressionValue &RightOperand,
+                                        bool &Overflow) {
   // Check for division by zero.
   if (RightOperand.getAPIntValue().isZero())
     return make_error<OverflowError>();
 
-  bool Overflow;
   APInt Result = LeftOperand.getAPIntValue().sdiv_ov(
       RightOperand.getAPIntValue(), Overflow);
-  if (Overflow ||
-      (Result.isNegative() && !Result.isSignedIntN(Result.getBitWidth() - 1)))
-    return make_error<OverflowError>();
-
-  if (Result.isNegative())
-    return ExpressionValue(Result.getSExtValue());
-  else
-    return ExpressionValue(Result.getZExtValue());
+  return ExpressionValue(Result);
 }
 
-Expected<ExpressionValue> llvm::max(const ExpressionValue &LeftOperand,
-                                    const ExpressionValue &RightOperand) {
+Expected<ExpressionValue> llvm::exprMax(const ExpressionValue &LeftOperand,
+                                        const ExpressionValue &RightOperand,
+                                        bool &Overflow) {
+  Overflow = false;
   return LeftOperand.getAPIntValue().slt(RightOperand.getAPIntValue())
              ? RightOperand
              : LeftOperand;
 }
 
-Expected<ExpressionValue> llvm::min(const ExpressionValue &LeftOperand,
-                                    const ExpressionValue &RightOperand) {
-  if (cantFail(max(LeftOperand, RightOperand)).getAPIntValue() ==
+Expected<ExpressionValue> llvm::exprMin(const ExpressionValue &LeftOperand,
+                                        const ExpressionValue &RightOperand,
+                                        bool &Overflow) {
+  Overflow = false;
+  if (cantFail(exprMax(LeftOperand, RightOperand, Overflow)).getAPIntValue() ==
       LeftOperand.getAPIntValue())
     return RightOperand;
 
   return LeftOperand;
 }
 
 Expected<ExpressionValue> NumericVariableUse::eval() const {
   std::optional<ExpressionValue> 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<ExpressionValue> MaybeLeftOp = LeftOperand->eval();
+  Expected<ExpressionValue> 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->getAPIntValue();
+  APInt RightOp = MaybeRightOp->getAPIntValue();
+  bool Overflow;
+  // Ensure both operands have the same bitwidth.
+  unsigned LeftBitWidth = LeftOp.getBitWidth();
+  unsigned RightBitWidth = RightOp.getBitWidth();
+  unsigned NewBitWidth = std::max(LeftBitWidth, RightBitWidth);
+  LeftOp = LeftOp.sext(NewBitWidth);
+  RightOp = RightOp.sext(NewBitWidth);
+  do {
+    Expected<ExpressionValue> MaybeResult =
+        EvalBinop(ExpressionValue(LeftOp), ExpressionValue(RightOp), Overflow);
+    if (!MaybeResult)
+      return MaybeResult.takeError();
+
+    if (!Overflow)
+      return MaybeResult;
+
+    NewBitWidth = nextAPIntBitWidth(NewBitWidth);
+    LeftOp = LeftOp.sext(NewBitWidth);
+    RightOp = RightOp.sext(NewBitWidth);
+  } while (true);
 }
 
 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();
     if (!LeftFormat)
       Err = joinErrors(std::move(Err), LeftFormat.takeError());
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(
+          ExpressionValue(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).

llvm/lib/FileCheck/FileCheckImpl.h

public:
   std::error_code convertToErrorCode() const override {
     return std::make_error_code(std::errc::value_too_large);
   }
 
   void log(raw_ostream &OS) const override { OS << "overflow error"; }
 };
 
 /// Class representing a numeric value.
 class ExpressionValue {
 private:
   APInt Value;
 
 public:
-  // Store signed and unsigned 64-bit integers in a signed 65-bit APInt.
-  template <class T>
-  explicit ExpressionValue(T Val) : Value(65, Val, /*isSigned=*/Val < 0) {}
+  ExpressionValue(APInt Val) : Value(Val) {}
 
   APInt getAPIntValue() const { return Value; }
 };
 
 /// 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<ExpressionValue> exprAdd(const ExpressionValue &Lhs,
+                                  const ExpressionValue &Rhs, bool &Overflow);
+Expected<ExpressionValue> exprSub(const ExpressionValue &Lhs,
+                                  const ExpressionValue &Rhs, bool &Overflow);
+Expected<ExpressionValue> exprMul(const ExpressionValue &Lhs,
+                                  const ExpressionValue &Rhs, bool &Overflow);
+Expected<ExpressionValue> exprDiv(const ExpressionValue &Lhs,
+                                  const ExpressionValue &Rhs, bool &Overflow);
+Expected<ExpressionValue> exprMax(const ExpressionValue &Lhs,
+                                  const ExpressionValue &Rhs, bool &Overflow);
+Expected<ExpressionValue> exprMin(const ExpressionValue &Lhs,
+                                  const ExpressionValue &Rhs, 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;
 
   /// \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;
 
 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; }
 };
 
 /// Class to represent an undefined variable error, which quotes that
 /// variable's name when printed.
public:
   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 &);
+                                                   const ExpressionValue &,
+                                                   bool &);
 
 /// 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.

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
+; Numeric variable definition with big value.
+RUN: FileCheck --check-prefix BIGVAL --input-file %s %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

 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
+; Numeric expression with big resulting value.
+RUN: FileCheck --check-prefix OVERFLOW --input-file %s %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:    {{^}}                            ^{{$}}
+OVERFLOW EXPRESSION
+BIGVAL: 10000000000000000
+OVERFLOW-LABEL: OVERFLOW EXPRESSION
+OVERFLOW-NEXT: BIGVAL: [[#%X,0x8000000000000000+0x8000000000000000]]
+
+; Numeric expression with big negative resulting value.
+RUN: FileCheck --check-prefix UNDERFLOW --input-file %s %s
+
+UNDERFLOW EXPRESSION
+TINYVAR: -18446744073709551616 # -0x10000000000000000
+UNDERFLOW-LABEL: UNDERFLOW EXPRESSION
+UNDERFLOW-NEXT: TINYVAR: [[#%d,-0x8000000000000000-0x8000000000000000]]
 
 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

llvm/unittests/FileCheck/FileCheckTest.cpp

 }
 
 constexpr uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max();
 constexpr int64_t MaxInt64 = std::numeric_limits<int64_t>::max();
 constexpr int64_t MinInt64 = std::numeric_limits<int64_t>::min();
 constexpr uint64_t AbsoluteMinInt64 =
     static_cast<uint64_t>(-(MinInt64 + 1)) + 1;
 constexpr uint64_t AbsoluteMaxInt64 = static_cast<uint64_t>(MaxInt64);
+// Use 128 bitwidth for literals to keep one bit for sign for uint64_t
+// literals.
+constexpr unsigned LiteralsBitWidth = 128;
 
 struct ExpressionFormatParameterisedFixture
     : public ::testing::TestWithParam<
           std::tuple<ExpressionFormat::Kind, unsigned, bool>> {
   bool AlternateForm;
   unsigned Precision;
   bool Signed;
   bool AllowHex;
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) {
+    APInt Value(LiteralsBitWidth, Val, std::is_signed_v<T>);
     Expected<std::string> MatchingString =
-        Format.getMatchingString(ExpressionValue(Val));
+        Format.getMatchingString(ExpressionValue(Value));
     ASSERT_THAT_EXPECTED(MatchingString, Succeeded())
         << "No matching string for " << Val;
     EXPECT_EQ(*MatchingString, ExpectedStr);
   }
 
   template <class T> void checkMatchingStringFailure(T Val) {
+    APInt Value(LiteralsBitWidth, Val, std::is_signed_v<T>);
     Expected<std::string> MatchingString =
-        Format.getMatchingString(ExpressionValue(Val));
+        Format.getMatchingString(ExpressionValue(Value));
     // Error message tested in ExpressionValue unit tests.
     EXPECT_THAT_EXPECTED(MatchingString, Failed());
   }
 
   Expected<ExpressionValue> getValueFromStringReprFailure(StringRef Str) {
     StringRef BufferizedStr = bufferize(SM, Str);
     return Format.valueFromStringRepr(BufferizedStr, SM);
   }

 }
 
 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);
+    checkValueFromStringRepr(MaxUint64Str, MaxUint64);
   } else {
     checkValueFromStringRepr(addBasePrefix(MaxUint64Str), MaxUint64);
   }
 
   checkValueFromStringRepr(addBasePrefix(TenStr), 10);
   checkValueFromStringRepr(addBasePrefix(FifteenStr), 15);
 
   // Wrong casing is not tested because valueFromStringRepr() relies on
::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(ExpressionValue(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_TRUE(UnsignedFormat == ExpressionFormat::Kind::Unsigned);
   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 void expectValueEqual(ExpressionValue ActualValue, T ExpectedValue) {
-  APInt Value = ActualValue.getAPIntValue();
-  EXPECT_EQ(ExpectedValue < 0, Value.isNegative());
-  if (ExpectedValue < 0)
-    EXPECT_EQ(Value.getSExtValue(), static_cast<int64_t>(ExpectedValue));
-  else
-    EXPECT_EQ(Value.getZExtValue(), static_cast<uint64_t>(ExpectedValue));
+static void expectOperationValueResult(binop_eval_t Operation, APInt LeftValue,
+                                       APInt RightValue, APInt ExpectedValue) {
+  bool Overflow;
+  ExpressionValue LeftVal(LeftValue);
+  ExpressionValue RightVal(RightValue);
+  Expected<ExpressionValue> OperationResult =
+      Operation(LeftVal, RightVal, Overflow);
+  ASSERT_THAT_EXPECTED(OperationResult, Succeeded());
+  EXPECT_EQ(OperationResult->getAPIntValue(), ExpectedValue);
 }
 
 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);
+  APInt LeftVal(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>);
+  APInt RightVal(LiteralsBitWidth, RightValue, std::is_signed_v<T2>);
+  APInt ResultVal =
+      std::is_integral_v<TR>
+          ? APInt(LiteralsBitWidth, ResultValue, std::is_signed_v<TR>)
+          : APInt(LiteralsBitWidth, ResultValue, /*Radix=*/10);
+  expectOperationValueResult(Operation, LeftVal, RightVal, ResultVal);
 }
 
 template <class T1, class T2>
 static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
                                        T2 RightValue) {
+  bool Overflow;
+  ExpressionValue LeftVal(
+      APInt(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>));
+  ExpressionValue RightVal(
+      APInt(LiteralsBitWidth, RightValue, std::is_signed_v<T2>));
   expectError<OverflowError>(
-      "overflow error",
-      doValueOperation(Operation, LeftValue, RightValue).takeError());
+      "overflow error", Operation(LeftVal, RightVal, Overflow).takeError());
 }
 
 TEST_F(FileCheckTest, ExpressionValueAddition) {
   // 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);
+  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 as uint64_t.
+  expectOperationValueResult(exprAdd, MaxUint64, 1, "18446744073709551616");
+  expectOperationValueResult(exprAdd, MaxUint64, MaxUint64,
+                             "36893488147419103230");
 }
 
 TEST_F(FileCheckTest, ExpressionValueSubtraction) {
   // 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 as 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 as 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,
-                             static_cast<uint64_t>(MaxInt64) + 11,
+  expectOperationValueResult(exprSub, 10, static_cast<uint64_t>(MaxInt64) + 11,
                              -MaxInt64 - 1);
 
   // 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 as 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 as 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);
+  expectOperationValueResult(exprDiv, -10, 0);
+  expectOperationValueResult(exprDiv, 10, 0);
+  expectOperationValueResult(exprDiv, 0, 0);
+
+  // Test negative result not representable as 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);
+  ExpressionLiteral Ten(bufferize(SM, "10"), APInt(64, 10u));
   Expected<ExpressionValue> Value = Ten.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
   EXPECT_EQ(10, Value->getAPIntValue().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, Value->getAPIntValue().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, Value->getAPIntValue().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
TEST_F(FileCheckTest, NumericVariable) {
   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();
   expectUndefErrors({"FOO"}, EvalResult.takeError());
 
   // Defined variable without string: only getValue and eval return value set.
-  FooVar.setValue(ExpressionValue(42u));
+  FooVar.setValue(ExpressionValue(APInt(64, 42u)));
   std::optional<ExpressionValue> Value = FooVar.getValue();
   ASSERT_TRUE(Value);
   EXPECT_EQ(42, Value->getAPIntValue().getSExtValue());
   EXPECT_FALSE(FooVar.getStringValue());
   EvalResult = FooVarUse.eval();
   ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
   EXPECT_EQ(42, EvalResult->getAPIntValue().getSExtValue());
 
   // Defined variable with string: getValue, eval, and getStringValue return
   // value set.
   StringRef StringValue = "925";
-  FooVar.setValue(ExpressionValue(925u), StringValue);
+  FooVar.setValue(ExpressionValue(APInt(64, 925u)), StringValue);
   Value = FooVar.getValue();
   ASSERT_TRUE(Value);
   EXPECT_EQ(925, Value->getAPIntValue().getSExtValue());
   // 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());

 
 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(ExpressionValue(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(ExpressionValue(APInt(64, 18u)));
   std::unique_ptr<NumericVariableUse> BarVarUse =
       std::make_unique<NumericVariableUse>(BarStr, &BarVar);
-  binop_eval_t doAdd = operator+;
-  BinaryOperation Binop(ExprStr, doAdd, std::move(FooVarUse),
+  BinaryOperation Binop(ExprStr, exprAdd, std::move(FooVarUse),
                         std::move(BarVarUse));
 
-  // Defined variables: eval returns right value; implicit format is as
-  // expected.
+  // Defined variables with same bitwidth and no overflow: eval returns right
+  // value; implicit formas is as expected.
   Expected<ExpressionValue> Value = Binop.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
   EXPECT_EQ(60, Value->getAPIntValue().getSExtValue());
   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(ExpressionValue(APInt(32, 18u)));
+  Value = Binop.eval();
+  ASSERT_THAT_EXPECTED(Value, Succeeded());
+  EXPECT_EQ(60, Value->getAPIntValue().getSExtValue());
+
+  // Defined variables with same bitwidth and wider result (i.e. overflow):
+  // eval succeeds and return the right value in a wider APInt.
+  BarVar.setValue(ExpressionValue(APInt(64, AbsoluteMaxInt64)));
+  Value = Binop.eval();
+  ASSERT_THAT_EXPECTED(Value, Succeeded());
+  EXPECT_EQ(128u, Value->getAPIntValue().getBitWidth());
+  EXPECT_EQ(APInt(128, AbsoluteMaxInt64 +
+                           FooVar.getValue()->getAPIntValue().getZExtValue()),
+            Value->getAPIntValue());
+
   // 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);
-  Binop = BinaryOperation(ExprStr, doAdd, std::move(FooVarUse),
+      std::make_unique<ExpressionLiteral>(EighteenStr, APInt(64, 18u));
+  Binop = BinaryOperation(ExprStr, exprAdd, 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);
-  Binop = BinaryOperation(ExprStr, doAdd, std::move(Eighteen),
+  Eighteen = std::make_unique<ExpressionLiteral>(EighteenStr, APInt(64, 18u));
+  Binop = BinaryOperation(ExprStr, exprAdd, 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");
   FooStr = ExprStr.take_front(3);
   StringRef BazStr = ExprStr.take_back(3);
   NumericVariable BazVar(BazStr,
                          ExpressionFormat(ExpressionFormat::Kind::HexLower), 3);
   FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
   std::unique_ptr<NumericVariableUse> BazVarUse =
       std::make_unique<NumericVariableUse>(BazStr, &BazVar);
-  Binop = BinaryOperation(ExprStr, doAdd, std::move(FooVarUse),
+  Binop = BinaryOperation(ExprStr, exprAdd, std::move(FooVarUse),
                           std::move(BazVarUse));
   ImplicitFormat = Binop.getImplicitFormat(SM);
   expectDiagnosticError(
       "implicit format conflict between 'FOO' (%u) and 'BAZ' (%x), "
       "need an explicit format specifier",
       ImplicitFormat.takeError());
 
   // All variable conflicts are reported.
   ExprStr = bufferize(SM, "(FOO+BAZ)+(FOO+QUUX)");
   StringRef Paren1ExprStr = ExprStr.substr(1, 7);
   FooStr = Paren1ExprStr.take_front(3);
   BazStr = Paren1ExprStr.take_back(3);
   StringRef Paren2ExprStr = ExprStr.substr(ExprStr.rfind('(') + 1, 8);
   StringRef FooStr2 = Paren2ExprStr.take_front(3);
   StringRef QuuxStr = Paren2ExprStr.take_back(4);
   FooVarUse = std::make_unique<NumericVariableUse>(FooStr, &FooVar);
   BazVarUse = std::make_unique<NumericVariableUse>(BazStr, &BazVar);
   std::unique_ptr<NumericVariableUse> FooVarUse2 =
       std::make_unique<NumericVariableUse>(FooStr2, &FooVar);
   NumericVariable QuuxVar(
       QuuxStr, ExpressionFormat(ExpressionFormat::Kind::HexLower), 4);
   std::unique_ptr<NumericVariableUse> QuuxVarUse =
       std::make_unique<NumericVariableUse>(QuuxStr, &QuuxVar);
   std::unique_ptr<BinaryOperation> Binop1 = std::make_unique<BinaryOperation>(
-      ExprStr.take_front(9), doAdd, std::move(FooVarUse), std::move(BazVarUse));
+      ExprStr.take_front(9), exprAdd, std::move(FooVarUse),
+      std::move(BazVarUse));
   std::unique_ptr<BinaryOperation> Binop2 = std::make_unique<BinaryOperation>(
-      ExprStr.take_back(10), doAdd, std::move(FooVarUse2),
+      ExprStr.take_back(10), exprAdd, std::move(FooVarUse2),
       std::move(QuuxVarUse));
   std::unique_ptr<BinaryOperation> OuterBinop =
-      std::make_unique<BinaryOperation>(ExprStr, doAdd, std::move(Binop1),
+      std::make_unique<BinaryOperation>(ExprStr, exprAdd, std::move(Binop1),
                                         std::move(Binop2));
   ImplicitFormat = OuterBinop->getImplicitFormat(SM);
   expectSameErrors<ErrorDiagnostic>(
       {("implicit format conflict between 'FOO' (%u) and 'BAZ' (%x), need an "
        "explicit format specifier"),
        ("implicit format conflict between 'FOO' (%u) and 'QUUX' (%x), need an "
        "explicit format specifier")},
       ImplicitFormat.takeError());
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(ExpressionValue(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);