FileCheck [10/12]: Add support for signed numeric values

[thopre]

Summary

This patch is part of a patch series to add support for FileCheck
numeric expressions. This specific patch adds support signed numeric
values, thus allowing negative numeric values.

As such, the patch adds a new class to represent a signed or unsigned
value and add the logic for type promotion and type conversion in
numeric expression mixing signed and unsigned values. It also adds
the %d format specifier to represent signed value.

Finally, it also adds underflow and overflow detection when performing a
binary operation.

Copyright:

• Linaro (changes up to diff 183612 of revision D55940)
• GraphCore (changes in later versions of revision D55940 and in new revision created off D55940)

[thopre]

Rebase on top of latest changes in the series

[thopre]

Rebase on top of latest changes in the patch series

[thopre]

• Fix a case of numeric expression -> expression
• Fix code style

[thopre]

Rebase on latest changes in patch series

[arichardson]

llvm/lib/Support/FileCheck.cpp

40

llvm/include/llvm/Support/CheckedArithmetic.h contains llvm::checkedAdd, llvm::checkedSub, llvm::checkedAddUnsigned and llvm::checkedSubUnsigned, which should make this code much simpler.

[thopre]

Address comment and rebase

[thopre]

Uploading the current status of this patch. I know there are still issues (in particular add more unittests), and I'll address them.

[thopre]

Rebase

[thopre]

Rebase

[thopre]

Rebase

[thopre]

Need to add unit tests

[arichardson]

Looks good to me once the tests have been added and other reviewers are also happy.

llvm/lib/Support/FileCheck.cpp

203

This is fine for the initial version of the patch, but I think in the future it will be useful to permit adding an unsigned variable to a signed one, etc. as long as the result is still within the representable range.

248

I'm not sure if this is necessary but I feel like it may be useful to permit adding a signed (negative value) to an unsigned value as long as the result is >= 0. Maybe these checks should move into operator+/-?

llvm/test/FileCheck/numeric-expression.txt

68–69

Since there are quite a lot of CHECK lines now, it might be helpful to add a comment after every line that checks a new variable. For example:

11 // VAR1
12
10
-30 // VAR2
-29
-31
c // VAR3 (hex)
...

[jhenderson]

Sorry for the delay in looking at this. Comments inline.

llvm/lib/Support/FileCheck.cpp

63

I'd not abbreviate this name. It's not clear to me that "Conv" == "Conversion"

Also, it's more idiomatic to declare the Error within the if, to reduce its scope.

120

other -> Other

121

I think you need a check that Signed == other.Signed, as otherwise there will be some cases where the two values match but aren't of the same signed-ness (e.g. -1 and uint64_t max). Unless that's intentional of course.

127

I'd make the names of this and convertUnsigned a bit more explicit, by adding "to", e.g. "toSigned" or "convertToSigned"

1031

As far as I can see, this block is just skipping the error? Why the switch/case?

llvm/lib/Support/FileCheckImpl.h

130

Perhaps a not_supported or invalid_argument would make more sense here.

155–159

This pair of constructors feels like a recipe for confusion or compilation problems due to ambiguous resolution. I think it might be better to make Signed an additional parameter.

163–164

other -> Other

179–183

As with above, this could lead to ambiguous compiler resolution, if Val is neither a uint64_t or int64_t. Perhaps not an issue in internal code, but it feels like there might be a better solution to me, perhaps using templates and std::is_signed in this case?

245

You've lost the reference to when this can be None. When can it be?

llvm/test/FileCheck/numeric-expression.txt

69

Maybe there should be som testing for signed positive values here?

[thopre]

Address review comments

[thopre]

llvm/lib/Support/FileCheck.cpp

1031

There's now only an OverflowError without type but FYI the goal was to catch the case of a new type of ValueError in the future that shouldn't be ignored here.

llvm/lib/Support/FileCheckImpl.h

130

From llvm/include/llvm/Support/Error.h:

/// The value returned by this function can be returned from convertToErrorCode
/// for Error values where no sensible translation to std::error_code exists.
/// It should only be used in this situation, and should never be used where a
/// sensible conversion to std::error_code is available, as attempts to convert
/// to/from this error will result in a fatal error. (i.e. it is a programmatic
///error to try to convert such a value).
std::error_code inconvertibleErrorCode();

That seems to be the right function to use when that function does not make sense for a given error?

[thopre]

Rebase

[thopre]

Last build failure were due to the pre commit check script trying to apply one of the earlier patch of this patch series as a needed dependency even though that diff is marked as closed.

[jhenderson]

llvm/docs/CommandGuide/FileCheck.rst

697

promotion rules

llvm/lib/Support/FileCheck.cpp

110

I'm a little confused as to what is going on here, as I'm not up-to-speed on APInt. Could you give a brief explanation, please?

133

Doesn't this assume 2s complement, which isn't standard-guaranteed as far as I'm aware? I'm okay with that, if there is precendent for it in LLVM already, since it seems like C++ is moving in that direction (see http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0907r1.html), but I'd be nervous otherwise.

156–162

It might be worth a comment saying why signed plus unsigned results in an unsigned (of course, that assumes I'm following the logic correctly).

936

Why do we handle OverflowError here, but not other error kinds (e.g. undefined variables)?

938

Unable -> unable

(diagnostic messages should not be capitalized)

llvm/lib/Support/FileCheckImpl.h

87–89

Delete the "if" at the end of this line (it's not needed).

119

std::errc::value_too_large is for overflows, so maybe that can be used here?

122

This comment doesn't seem right?

123

Probably should be lower-case "overflow"

156

I'm slightly nervous "error in case of overflow" might go stale, in the event we introduce other failure modes. Perhaps "an error in case of a problem, such as an overflow."

llvm/test/FileCheck/numeric-expression.txt

41–43

Any particular reason you've changed this case?

68–90

Nit: here and below, add space after comment markers, i.e. // VAR1

Also, has this been addressed:

Maybe there should be som testing for signed positive values here?

153

Here and elsewhere there seem to be some extra cases added that aren't to do with signed decimal values. Do they belong in this change?

191–192

It seems like we need testing showing the behaviour of signed decimals converting to hex.

429–430

Here and elsewhere, minor nit: be consistent with single or double-dashes.

llvm/unittests/Support/FileCheckTest.cpp

108

MinusFortyTwo

385

What about 10u + -11 or -11 + 10u?

405

What about MinusTen - MinusTen?

459

10ull would be more typical, I'd think, here and elsewhere. Any particular reason you've chosen the cast?

[arichardson]

llvm/lib/Support/FileCheck.cpp

110

Using APInt here seems unnecessary. How about return (int64_t)Value;?

Or if you would like to avoid the casts you could use a union.

133

Since we know the value is signed after if (!Signed), can't we change these three lines to
return ExpressionValue(std::abs((int64_t)Value), /*Signed=*/false)?

llvm/lib/Support/FileCheckImpl.h

140

Signed && (int64_t)Value < 0?

[arichardson]

llvm/unittests/Support/FileCheckTest.cpp

459

ull is not guaranteed to be the same as a uint64_t constant since some platforms use unsigned long instead of unsigned long long. stdint.h provides UINT64_C(10) if you want to avoid the cast.

[thopre]

llvm/lib/Support/FileCheck.cpp

110

Value is uint64_t and C++14 says:

If the destination type is signed, the value is unchanged if it can be represented in the destination type;otherwise, the value is implementation-defined

So if Value corresponds to a negative signed integer the conversion is implementation-defined. I don't know how APInt deal with this but I hope it does something C++14 compliant.

133

As per above, the conversion to (int64_t) is implementation-defined in case where Value has its msb set (ie. corresponds to a negative signed value).

[thopre]

Address all comments

[thopre]

Fix casing

[MaskRay]

llvm/lib/Support/FileCheckImpl.h

46

a signed integer

[jhenderson]

llvm/test/FileCheck/numeric-expression.txt

89–90

I'm not following the purpose of the blank line here?

llvm/unittests/Support/FileCheckTest.cpp

385

Where has this been addressed?

405

Where has this been addressed?

[thopre]

llvm/lib/Support/FileCheckImpl.h

140

Casting to int64_t is implementation-defined if Value is > std::numeric_limits<int64_t>::max(). That said current code assumes 2-complement so I've changed for memcpy. Hopefully the compiler can elide that call.

llvm/test/FileCheck/numeric-expression.txt

68–90

Yes, that's the VAR2+72 case.

153

Ah yes indeed, I noticed some bug in the testcase. I forgot to split the fix out in its own patch. Now done in https://reviews.llvm.org/D79820

llvm/unittests/Support/FileCheckTest.cpp

385

Those are ExpressionValue since this test is testing ExpressionValue operator+. I've renamed all such variable to add the suffix "Value"

405

Ditto.

[thopre]

llvm/test/FileCheck/numeric-expression.txt

89–90

The CHECK-NEXT: #VAR2a is trying to match c which is also found in "// VAR1c". The CHECK-NEXT thus fails because it found c after the previous match on the same line.

llvm/unittests/Support/FileCheckTest.cpp

385

I forgot to send the comments I had written. I hope that answers why I didn't do it.

[arichardson]

llvm/lib/Support/FileCheckImpl.h

140

Yes it definitely can (even at -O1): https://godbolt.org/z/5jcz9L
I'm still not sure that it's possible that casting gives a different value from memcpy on any architecture that LLVM builds on, but I'm also fine with the memcpy.

[thopre]

Fix typo

[thopre]

The current promotion rules prevent to compute VAR-10 when VAR is an unsigned variable whose value is 5 because the result would be negative but the expression should be unsigned. I'll address that by accepting all values as long as they fit in an int64_t or uint64_t and only throw an overflow error when trying to match the value if it doesn't fit with the expression format. I should have done that in the first place.

[thopre]

llvm/lib/Support/FileCheckImpl.h

140

architecture -> system, surely the compiler can mess things up as well? It's such a shame that there isn't a better way to achieve this while being perfectly well defined.

[jhenderson]

llvm/test/FileCheck/numeric-expression.txt

89–90

I see. I'm beginning to think the names of the variables need improving. Rather than have VAR1, VAR2, VAR1a etc, how about "SIGN", "UNSI" "UHEX", "LHEX", etc, possibly with additional context for their actual values. The CHECKs might also want an additional {{^}} to avoid matching things spuriously.

llvm/unittests/Support/FileCheckTest.cpp

385

I'm not sure it does, if I'm honest. An unsigned 10 plus a signed -11 should trigger the clause at line 174 in FileCheck.cpp, whilst the other way around triggers the clause at 170. They are distinctly interesting from the other cases that trigger those clauses because they should trigger overflows, if I've understood things right, rather than resulting in max uint64_t, but I don't think that's tested directly. The fact that this happens to call into other functions seems somewhat irrelevant from testing a distinct unit perspective - if you refactored the code to no longer use the same code path as something else that might be tested independently, you still want the test coverage.

405

It seems to me like operator- is a distinct unit, and its interface should be fully tested independently (see also my comments above). I believe this ends path ends up calling into checkedSub for which I can see no direct testing (does it handle double-negatives correctly, for example?)

[thopre]

Address review comments

llvm/unittests/Support/FileCheckTest.cpp

385

I've reworked the ExpressionValue storage which should simplify the codepath somewhat and added one testcase to cover for an overflow case that was not tested (I was relying on testing of checkedSub but as you pointed out testing code would risk to bitrot in case the operator code is changed).

Please let me know if that doesn't address all your concerns.

405

How about now? Whether the value is signed or not doesn't matter anymore, only whether it's negative which should allow to reduce the amount of overflow codepaths.

[jhenderson]

llvm/docs/CommandGuide/FileCheck.rst

697–699

Is this still true?

llvm/lib/Support/FileCheck.cpp

246

I think there's an overflow issue here, right? If RightValue is bigger than max int64_t, it's possible for the expression to end up outside a representable int64_t, which seems like it should be an error?

llvm/lib/Support/FileCheckImpl.h

127–131

I'm looking at this and thinking can't this and the above constructor not just be changed to:

template <class T>
explicit ExpressionValue(T Val)
  : Value(Val), Negative(Val < 0) {}

133

true is -> true if

llvm/unittests/Support/FileCheckTest.cpp

385

I'm starting to get a bit of review fatigue, so I'm starting to miss things, but if I've followed things right, my suggested simplification to the constructors should enable us to get rid of the distinction between SignedTen and UnsignedTen, which in turn should allow the tests to be much simpler. At that point, I'd expect the test cases to be:

1. Negative + Positive
2. Positive + Negative
3. Negative + Negative (no overflow)
4. Positive + Positive (no overflow)

5-6) Overflowing variations of 3) and 4)

with an equivalent set for operator-

[thopre]

Address review comments and fix a few more bugs

llvm/lib/Support/FileCheck.cpp

153–185

Undefined on 2-complement system when Value == min int64_t.

224

This can fail since RightOperand, being positive, is represented by a uint64_t.

246

Indeed, and it made me realize that getAbsolute doesn't work for min int64_t either.

llvm/unittests/Support/FileCheckTest.cpp

385

My apologies for causing this fatigue. I've added comments for each individual checks for each of the function/operator tested. Hope this helps. I've also caught a bug in the -A -B case where B would not fit in an int64_t. There's now an extra underflow here with an extra test.

[thopre]

Fix format issue

[jhenderson]

I've been thinking more about test cases, and suggested a number more. If you can reduce the boiler plate for each individual test case, that would be great too. Perhaps even consider a TEST_P solution to specify input and expected output, whilst sharing the same code body.

llvm/unittests/Support/FileCheckTest.cpp

315

I'd test the range edge of -1 instead of -10.

It may be worth showing it fails for int64_t min too.

Also, a 0 check would be good to ensure no off-by-1 errors/incorrect use of < versus <= etc.

327–328

Perhaps worth adding a int64_t max + 1 case.

333

Maybe also int64_t min and max cases?

342

Maybe worth considering test cases for 0, and uint64_t max too?

371

Perhaps use -1 instead of -10.

Perhaps also MinInt64 - MinInt64.

376–380

These checks all have a lot of repeated code. It's probably time to factor out much of this into a function. It might also be a good idea to factor them into separate TESTs to allow the rest of the test to run in the event of a failure with an ASSERT etc, and to provide finer-grained test failures.

388

I'd prefer these slightly to not just always give a result of 0. I think it is more interesting to show that 10 + -11 can produce a negative number, for example, whilst 11 + -10 produces a positive one. Same goes for the case above.

399

Perhaps 1 instead of 10 here.

Perhaps also MaxUint64Value + MaxUint64Value would be a useful case, to maximise surface area.

404

What is meant by "too big" here? Be more precise in this comment.

409

- 1 rather than - 10 would probably be best here.

422

Similar to the + case, it might be nice for this to result in a non-zero value.

437

"or nul"?

438

I'm not sure Value is a useful suffix to all these names. It wasn't confusing to me before either.

447

Maybe Zero instead of Ten here would be good, for maximum possible underflow.
Maybe consider 0 - (std::abs(MinInt64) + 1) for minimum possible underflow.

458

Why not test the exact value?

461

Seems to me like there are two interesting cases here: "result is positive" and "result is negative".

[thopre]

Address unittest review comments

[thopre]

Fix format by using source tree clang-format-diff.py instead of system clang-format-diff

llvm/unittests/Support/FileCheckTest.cpp

376–380

Is that fine grain enough or do you want me to split further?

447

I can't use std::abs(MinInt64) since it's undefined in 2-complement (std::abs returns an int64_t for some reason).

461

Result is positive is already handled above. I meant to handle the negative case where result < -(max int64_t). Fixed now.

[jhenderson]

The latest changes are a big improvement on readability, thanks. Did you consider using TEST_P to factor things out further? That way you'd only need to specify the input and expected output values for each test case, with only a single TEST itself.

llvm/unittests/Support/FileCheckTest.cpp

300

Don't know how plausible it is, but did you consider passing in a function_ref to the operator+/operator- functions instead of the boolean? That might be useful in the future if support is extended to e.g. multiplication.

367

I think these sorts of comments indicate a need to split the test up. The suggestion I have is one method == one (or more) TESTs.

Thus there'd be tests for getAbsolute, getSignedValue etc etc and I'd call them ExpressionValueGetAbsolute, ExpressionValueGetSignedValue etc.

413

Typo

447

(Just to be clear, I only used std::abs as an intended example, rather than literally what should have been written).

[thopre]

Address inline review comments

[thopre]

In D60390#2048630, @jhenderson wrote:

The latest changes are a big improvement on readability, thanks. Did you consider using TEST_P to factor things out further? That way you'd only need to specify the input and expected output values for each test case, with only a single TEST itself.

To make the result more concise that would require sharing fixture and instantiation among TEST_P but I'm not sure how to do it since the values generated in the instantiation are passed to all TEST_P but even operator+ and operator- have different values. If I need separate instantiation per TEST_P then I need separate fixture as well and that becomes more faff that what we have now I feel.

If there's some clever trick please give me some pointers on how to do it as I cannot see it right now.

[jhenderson]

LGTM, with nit.

Re. TEST_P, the best suggestion I've got is look at the examples in DWARFDebugLineTest.cpp, where I've used a few different tricks to achieve the goal of code re-use. In particular, AdjustAddressFixtureBase related test cases might be interesting to you. In your case, I'd probably have a set of parameters each for failing and passing combinations, and for addition and subtraction, for a total of 4 combinations, if I'm not mistaken. You'd have thin fixtures for each, but they could probably share some code via a base class.

That all being said, only make those changes if you think they are worthwhile. I'm happy enough with this as-is.

llvm/unittests/Support/FileCheckTest.cpp

424

Here and in various other places, not sure you want the space between - and 10 (same for - 20 and various cases below).

[thopre]

llvm/unittests/Support/FileCheckTest.cpp

424

I don't like it either but this comes from clang-format-diff.py. Should I go against it?

[thopre]

In D60390#2056652, @jhenderson wrote:

LGTM, with nit.

Re. TEST_P, the best suggestion I've got is look at the examples in DWARFDebugLineTest.cpp, where I've used a few different tricks to achieve the goal of code re-use. In particular, AdjustAddressFixtureBase related test cases might be interesting to you. In your case, I'd probably have a set of parameters each for failing and passing combinations, and for addition and subtraction, for a total of 4 combinations, if I'm not mistaken. You'd have thin fixtures for each, but they could probably share some code via a base class.

That all being said, only make those changes if you think they are worthwhile. I'm happy enough with this as-is.

So far, I'm getting:

llvm/unittests/Support/FileCheckTest.cpp | 413 +++++++++++++++++++++++++++++++++-------------------
1 file changed, 263 insertions(+), 150 deletions(-)

It's also quite a lot of code change, so even if that is acceptable because the code is deemed more readable, it's better to look at it as a separate patch and land the current code (with the suggested spacing fix)

[thopre]

Rebase and fix spacing issue for negative literals

[thopre]

Argh sorry, forgot to remove the unnecessary phabricator marks when landing.

[jhenderson]

In D60390#2059448, @thopre wrote:

In D60390#2056652, @jhenderson wrote:

LGTM, with nit.

Re. TEST_P, the best suggestion I've got is look at the examples in DWARFDebugLineTest.cpp, where I've used a few different tricks to achieve the goal of code re-use. In particular, AdjustAddressFixtureBase related test cases might be interesting to you. In your case, I'd probably have a set of parameters each for failing and passing combinations, and for addition and subtraction, for a total of 4 combinations, if I'm not mistaken. You'd have thin fixtures for each, but they could probably share some code via a base class.

That all being said, only make those changes if you think they are worthwhile. I'm happy enough with this as-is.

So far, I'm getting:

llvm/unittests/Support/FileCheckTest.cpp | 413 +++++++++++++++++++++++++++++++++-------------------
1 file changed, 263 insertions(+), 150 deletions(-)

It's also quite a lot of code change, so even if that is acceptable because the code is deemed more readable, it's better to look at it as a separate patch and land the current code (with the suggested spacing fix)

I'll leave it up to you as to whether you want to. This is probably sufficient as is.

llvm/unittests/Support/FileCheckTest.cpp

424

If clang-format-diff.py was trying to format it that way, I'd consider that a bug in clang-format, so should be reported as such. The - there is a unary operator, and should be formatted as such (without a space).

llvm/docs/CommandGuide/FileCheck.rst

 numeric expression constraint based on those variables via a numeric
 substitution. This allows ``CHECK:`` directives to verify a numeric relation
 between two numbers, such as the need for consecutive registers to be used.
 
 The syntax to define a numeric variable is ``[[#%<fmtspec>,<NUMVAR>:]]`` where:
 
 * ``%<fmtspec>`` is an optional scanf-style matching format specifier to
   indicate what number format to match (e.g. hex number).  Currently accepted
-  format specifiers are ``%u``, ``%x`` and ``%X``.  If absent, the format
-  specifier defaults to ``%u``.
+  format specifiers are ``%u``, ``%d``, ``%x`` and ``%X``.  If absent, the
+  format specifier defaults to ``%u``.
 
 * ``<NUMVAR>`` is the name of the numeric variable to define to the matching
   value.
 
 For example:
 
 .. code-block:: llvm
 

 
 * ``<expr>`` is an expression. An expression is in turn recursively defined
   as:
 
   * a numeric operand, or
   * an expression followed by an operator and a numeric operand.
 
   A numeric operand is a previously defined numeric variable, or an integer
-  literal. The supported operators are ``+`` and ``-``. Spaces are accepted
-  before, after and between any of these elements.
+  literal and have a 64-bit precision. The supported operators are ``+`` and
+  ``-``. Spaces are accepted before, after and between any of these elements.
+  Evaluation of an expression follows the C language integer promotion rules,
+  i.e. a signed 64-bit operand is promoted to an unsigned 64-bit operand if the
+  other operand is unsigned.
 
 For example:
 
 .. code-block:: llvm
 
     ; CHECK: load r[[#REG:]], [r0]
     ; CHECK: load r[[#REG+1]], [r1]
     ; CHECK: Loading from 0x[[#%x,ADDR:]]

llvm/lib/Support/FileCheck.cpp

 // This file implements most of the API that will be used by the FileCheck utility
 // as well as various unittests.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/FileCheck.h"
 #include "FileCheckImpl.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 <tuple>
 #include <utility>
 
 using namespace llvm;
 
 StringRef ExpressionFormat::toString() const {
   switch (Value) {
   case Kind::NoFormat:
     return StringRef("<none>");
   case Kind::Unsigned:
     return StringRef("%u");
+  case Kind::Signed:
+    return StringRef("%d");
   case Kind::HexUpper:
     return StringRef("%X");
   case Kind::HexLower:
     return StringRef("%x");
   }
   llvm_unreachable("unknown expression format");
 }
 
 Expected<StringRef> ExpressionFormat::getWildcardRegex() const {
   switch (Value) {
   case Kind::Unsigned:
     return StringRef("[0-9]+");
+  case Kind::Signed:
+    return StringRef("-?[0-9]+");
   case Kind::HexUpper:
     return StringRef("[0-9A-F]+");
   case Kind::HexLower:
     return StringRef("[0-9a-f]+");
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 }
 
 Expected<std::string>
-ExpressionFormat::getMatchingString(uint64_t IntegerValue) const {
+ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const {
+  if (Value == Kind::Signed) {
+    Expected<int64_t> SignedValue = IntegerValue.getSignedValue();
+    if (!SignedValue)
+      return SignedValue.takeError();
+    return itostr(*SignedValue);
+  }
+
+  Expected<uint64_t> UnsignedValue = IntegerValue.getUnsignedValue();
+  if (!UnsignedValue)
+    return UnsignedValue.takeError();
   switch (Value) {
   case Kind::Unsigned:
-    return utostr(IntegerValue);
+    return utostr(*UnsignedValue);
   case Kind::HexUpper:
-    return utohexstr(IntegerValue, /*LowerCase=*/false);
+    return utohexstr(*UnsignedValue, /*LowerCase=*/false);
   case Kind::HexLower:
-    return utohexstr(IntegerValue, /*LowerCase=*/true);
+    return utohexstr(*UnsignedValue, /*LowerCase=*/true);
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 }
 
-Expected<uint64_t>
+Expected<ExpressionValue>
 ExpressionFormat::valueFromStringRepr(StringRef StrVal,
                                       const SourceMgr &SM) const {
+  bool ValueIsSigned = Value == Kind::Signed;
+  StringRef OverflowErrorStr = "unable to represent numeric value";
+  if (ValueIsSigned) {
+    int64_t SignedValue;
+
+    if (StrVal.getAsInteger(10, SignedValue))
+      return ErrorDiagnostic::get(SM, StrVal, OverflowErrorStr);
+
+    return ExpressionValue(SignedValue, ValueIsSigned);
+  }
+
   bool Hex = Value == Kind::HexUpper || Value == Kind::HexLower;
-  uint64_t IntegerValue;
-  if (StrVal.getAsInteger(Hex ? 16 : 10, IntegerValue))
-    return ErrorDiagnostic::get(SM, StrVal,
-                                "unable to represent numeric value");
+  uint64_t UnsignedValue;
+  if (StrVal.getAsInteger(Hex ? 16 : 10, UnsignedValue))
+    return ErrorDiagnostic::get(SM, StrVal, OverflowErrorStr);
+
+  return ExpressionValue(UnsignedValue, ValueIsSigned);
+}
+
+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;
+}
+
+bool ExpressionValue::isNegative() const {
+  if (!Signed)
+    return false;
+
+  return getAsSigned(Value) < 0;
+}
+
+Expected<int64_t> ExpressionValue::getSignedValue() const {
+  if (Signed)
+    return getAsSigned(Value);
+
+  if (Value > 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<uint64_t> ExpressionValue::getUnsignedValue() const {
+  if (isNegative())
+    return make_error<OverflowError>();
+
+  return Value;
+}
+
+ExpressionValue ExpressionValue::getAbsolute() const {
+  if (!Signed)
+    return *this;
+
+  if (!isNegative())
+    return ExpressionValue(Value, /*Signed=*/false);
+
+  return ExpressionValue(-getAsSigned(Value), /*Signed=*/false);
+}
+
+Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand,
+                                          const ExpressionValue &RightOperand) {
+  bool ResultIsSigned = LeftOperand.isSigned() && RightOperand.isSigned();
+
+  if (ResultIsSigned) {
+    int64_t LeftValue = cantFail(LeftOperand.getSignedValue());
+    int64_t RightValue = cantFail(RightOperand.getSignedValue());
+    Optional<int64_t> Result = checkedAdd<int64_t>(LeftValue, RightValue);
+    if (!Result)
+      return make_error<OverflowError>();
 
-  return IntegerValue;
+    return ExpressionValue(*Result, ResultIsSigned);
   }
 
-Expected<uint64_t> NumericVariableUse::eval() const {
-  Optional<uint64_t> Value = Variable->getValue();
+  // Result is unsigned from now on due to operand promotion.
+
+  // (-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());
+  Optional<uint64_t> Result =
+      checkedAddUnsigned<uint64_t>(LeftValue, RightValue);
+  if (!Result)
+    return make_error<OverflowError>();
+
+  return ExpressionValue(*Result, ResultIsSigned);
+}
+
+Expected<ExpressionValue> llvm::operator-(const ExpressionValue &LeftOperand,
+                                          const ExpressionValue &RightOperand) {
+  bool ResultIsSigned = LeftOperand.isSigned() && RightOperand.isSigned();
+
+  if (ResultIsSigned) {
+    int64_t LeftValue = cantFail(LeftOperand.getSignedValue());
+    int64_t RightValue = cantFail(RightOperand.getSignedValue());
+    Optional<int64_t> Result = checkedSub(LeftValue, RightValue);
+    if (!Result)
+      return make_error<OverflowError>();
+
+    return ExpressionValue(*Result, ResultIsSigned);
+  }
+
+  // Result is unsigned from now on due to operand promotion.
+
+  // Result will be negative.
+  if (LeftOperand.isNegative())
+    return make_error<OverflowError>();
+
+  // 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());
+  Optional<uint64_t> Result =
+      checkedOp(LeftValue, RightValue, &llvm::APInt::usub_ov);
+  if (!Result)
+    return make_error<OverflowError>();
+  return ExpressionValue(*Result, ResultIsSigned);
+}
+
+Expected<ExpressionValue> NumericVariableUse::eval() const {
+  Optional<ExpressionValue> Value = Variable->getValue();
   if (Value)
     return *Value;
 
   return make_error<UndefVarError>(getExpressionStr());
 }
 
-Expected<uint64_t> BinaryOperation::eval() const {
-  Expected<uint64_t> LeftOp = LeftOperand->eval();
-  Expected<uint64_t> RightOp = RightOperand->eval();
+Expected<ExpressionValue> BinaryOperation::eval() const {
+  Expected<ExpressionValue> LeftOp = LeftOperand->eval();
+  Expected<ExpressionValue> RightOp = RightOperand->eval();
 
   // Bubble up any error (e.g. undefined variables) in the recursive
   // evaluation.
   if (!LeftOp || !RightOp) {
     Error Err = Error::success();
     if (!LeftOp)
       Err = joinErrors(std::move(Err), LeftOp.takeError());
     if (!RightOp)
       Err = joinErrors(std::move(Err), RightOp.takeError());
     return std::move(Err);
   }
 
   return EvalBinop(*LeftOp, *RightOp);
 }
 
 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 (!RightFormat)
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<uint64_t> EvaluatedValue = ExpressionPointer->getAST()->eval();
+  Expected<ExpressionValue> 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 UndefVarError::ID = 0;
 char ErrorDiagnostic::ID = 0;
 char NotFoundError::ID = 0;
 
 Expected<NumericVariable *> Pattern::parseNumericVariableDefinition(
     StringRef &Expr, FileCheckPatternContext *Context,
     Optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
     const SourceMgr &SM) {
if (ParseVarResult)
                                      Context, SM);
     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.
-  uint64_t LiteralValue;
-  StringRef OperandExpr = Expr;
+  int64_t SignedLiteralValue;
+  uint64_t UnsignedLiteralValue;
+  StringRef SaveExpr = Expr;
+  // Accept both signed and unsigned literal, default to signed literal.
+  if (AO == AllowedOperand::Any && !Expr.consumeInteger(0, SignedLiteralValue))
+    return std::make_unique<ExpressionLiteral>(SaveExpr.drop_back(Expr.size()),
+                                               SignedLiteralValue);
+  Expr = SaveExpr;
   if (!Expr.consumeInteger((AO == AllowedOperand::LegacyLiteral) ? 10 : 0,
-                           LiteralValue)) {
-    return std::make_unique<ExpressionLiteral>(
-        OperandExpr.drop_back(Expr.size()), LiteralValue);
-  }
+                           UnsignedLiteralValue))
+    return std::make_unique<ExpressionLiteral>(SaveExpr.drop_back(Expr.size()),
+                                               UnsignedLiteralValue);
 
   return ErrorDiagnostic::get(SM, Expr,
                               "invalid operand format '" + Expr + "'");
 }
 
-static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {
-  return LeftOp + RightOp;
-}
-
-static uint64_t sub(uint64_t LeftOp, uint64_t RightOp) {
-  return LeftOp - RightOp;
-}
-
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
                     std::unique_ptr<ExpressionAST> LeftOp,
                     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
                     FileCheckPatternContext *Context, const SourceMgr &SM) {
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.empty())
     return std::move(LeftOp);
 
   // 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 = add;
+    EvalBinop = operator+;
     break;
   case '-':
-    EvalBinop = sub;
+    EvalBinop = operator-;
     break;
   default:
     return ErrorDiagnostic::get(
         SM, OpLoc, Twine("unsupported operation '") + Twine(Operator) + "'");
   }
 
   // Parse right operand.
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
if (FormatSpecEnd != StringRef::npos) {
 
     // Check for unknown matching format specifier and set matching format in
     // class instance representing this expression.
     SMLoc fmtloc = SMLoc::getFromPointer(Expr.data());
     switch (popFront(Expr)) {
     case 'u':
       ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::Unsigned);
       break;
+    case 'd':
+      ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::Signed);
+      break;
     case 'x':
       ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::HexLower);
       break;
     case 'X':
       ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::HexUpper);
       break;
     default:
       return ErrorDiagnostic::get(SM, fmtloc,
Expected<size_t> Pattern::match(StringRef Buffer, size_t &MatchLen,
 
   // 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(*LineNumber);
+      Context->LineVariable->setValue(
+          ExpressionValue(*LineNumber, /*Signed=*/false));
 
     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.
     for (const auto &Substitution : Substitutions) {
       // Substitute and check for failure (e.g. use of undefined variable).
       Expected<std::string> Value = Substitution->getResult();
-      if (!Value)
-        return Value.takeError();
+      if (!Value) {
+        // Convert to an ErrorDiagnostic to get location information. This is
+        // done here rather than PrintNoMatch since now we know which
+        // substitution block caused the overflow.
+        Error Err =
+            handleErrors(Value.takeError(), [&](const OverflowError &E) {
+              return ErrorDiagnostic::get(SM, Substitution->getFromString(),
+                                          "unable to substitute variable or "
+                                          "numeric expression: overflow error");
+            });
+        return std::move(Err);
+      }
 
       // Plop it into the regex at the adjusted offset.
       TmpStr.insert(TmpStr.begin() + Substitution->getIndex() + InsertOffset,
                     Value->begin(), Value->end());
       InsertOffset += Value->size();
     }
 
     // Match the newly constructed regex.
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<uint64_t> Value = Format.valueFromStringRepr(MatchedValue, SM);
+    Expected<ExpressionValue> Value =
+        Format.valueFromStringRepr(MatchedValue, SM);
     if (!Value)
       return Value.takeError();
     DefinedNumericVariable->setValue(*Value);
   }
 
   // Like CHECK-NEXT, CHECK-EMPTY's match range is considered to start after
   // the required preceding newline, which is consumed by the pattern in the
   // case of CHECK-EMPTY but not CHECK-NEXT.
for (const auto &Substitution : Substitutions) {
       SmallString<256> Msg;
       raw_svector_ostream OS(Msg);
       Expected<std::string> MatchedValue = Substitution->getResult();
 
       // Substitution failed or is not known at match time, print the undefined
       // variables it uses.
       if (!MatchedValue) {
         bool UndefSeen = false;
-        handleAllErrors(MatchedValue.takeError(), [](const NotFoundError &E) {},
-                        // Handled in PrintNoMatch().
-                        [](const ErrorDiagnostic &E) {},
-                        [&](const UndefVarError &E) {
-                          if (!UndefSeen) {
-                            OS << "uses undefined variable(s):";
-                            UndefSeen = true;
-                          }
-                          OS << " ";
-                          E.log(OS);
-                        });
+        handleAllErrors(
+            MatchedValue.takeError(), [](const NotFoundError &E) {},
+            // Handled in match().
+            [](const OverflowError &E) {},
       } else {
         // Substitution succeeded. Print substituted value.
         OS << "with \"";
         OS.write_escaped(Substitution->getFromString()) << "\" equal to \"";
         OS.write_escaped(*MatchedValue) << "\"";
       }
 
       if (MatchRange.isValid())
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<uint64_t> Value = Expression->getAST()->eval();
+      Expected<ExpressionValue> Value = Expression->getAST()->eval();
       if (!Value) {
         Errs = joinErrors(std::move(Errs), Value.takeError());
         continue;
       }
 
       assert(DefinedNumericVariable && "No variable defined");
       (*DefinedNumericVariable)->setValue(*Value);
 

llvm/lib/Support/FileCheckImpl.h

 #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,
     /// Value is an unsigned integer and should be printed as a decimal number.
     Unsigned,
+    /// Value is an unsigned integer and should be printed as a decimal number.
+    Signed,
     /// Value should be printed as an uppercase hex number.
     HexUpper,
     /// Value should be printed as a lowercase hex number.
     HexLower
   };
 
 private:
   Kind Value;
public:
   explicit ExpressionFormat(Kind Value) : Value(Value){};
 
   /// \returns a wildcard regular expression StringRef that matches any value
   /// in the format represented by this instance, or an error if the format is
   /// NoFormat.
   Expected<StringRef> getWildcardRegex() const;
 
   /// \returns the string representation of \p Value in the format represented
-  /// by this instance, or an error if the format is NoFormat.
-  Expected<std::string> getMatchingString(uint64_t Value) const;
+  /// by this instance, or an error if conversion to this format failed or the
+  /// format is NoFormat.
+  Expected<std::string> getMatchingString(ExpressionValue 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<uint64_t> valueFromStringRepr(StringRef StrVal,
+  Expected<ExpressionValue> 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> {
+public:
+  static char ID;
+
+  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:
+  uint64_t Value;
+  bool Signed;
+
+public:
+  explicit ExpressionValue(uint64_t Val, bool Signed)
+      : Value(Val), Signed(Signed) {}
+
+  bool isSigned() const { return Signed; }
+
+  /// Returns true is value is signed and negative, false otherwise.
+  bool isNegative() const;
+
+  /// \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);
+
 /// 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<uint64_t> eval() const = 0;
+  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.
-  uint64_t Value;
+  ExpressionValue Value;
 
 public:
-  /// Constructs a literal with the specified value parsed from
-  /// \p ExpressionStr.
-  ExpressionLiteral(StringRef ExpressionStr, uint64_t Val)
-      : ExpressionAST(ExpressionStr), Value(Val) {}
+  template <class T>
+  explicit ExpressionLiteral(StringRef ExpressionStr, T Val)
+      : ExpressionAST(ExpressionStr), Value(Val, std::is_signed<T>::value) {}
 
   /// \returns the literal's value.
-  Expected<uint64_t> eval() const override { return Value; }
+  Expected<ExpressionValue> 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 None otherwise.
-  Optional<uint64_t> Value;
+  Optional<ExpressionValue> Value;
 
   /// Line number where this variable is defined, or None if defined before
   /// input is parsed. Used to determine whether a variable is defined on the
   /// same line as a given use.
   Optional<size_t> DefLineNumber;
 
 public:
   /// Constructor for a variable \p Name with implicit format \p ImplicitFormat
   /// defined at line \p DefLineNumber or defined before input is parsed if
   /// \p DefLineNumber is None.
   explicit NumericVariable(StringRef Name, ExpressionFormat ImplicitFormat,
                            Optional<size_t> DefLineNumber = None)
       : Name(Name), ImplicitFormat(ImplicitFormat),
         DefLineNumber(DefLineNumber) {}
 
   /// \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.
-  Optional<uint64_t> getValue() const { return Value; }
+  Optional<ExpressionValue> getValue() const { return Value; }
 
   /// Sets value of this numeric variable to \p NewValue.
-  void setValue(uint64_t NewValue) { Value = NewValue; }
+  void setValue(ExpressionValue NewValue) { Value = NewValue; }
 
   /// Clears value of this numeric variable, regardless of whether it is
   /// currently defined or not.
   void clearValue() { Value = None; }
 
   /// \returns the line number where this variable is defined, if any, or None
   /// if defined before input is parsed.
   Optional<size_t> getDefLineNumber() const { return DefLineNumber; }
 };
 
 /// Class representing the use of a numeric variable in the AST of an
 /// expression.
 class NumericVariableUse : public ExpressionAST {
 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<uint64_t> eval() const override;
+  Expected<ExpressionValue> 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 = uint64_t (*)(uint64_t, uint64_t);
+using binop_eval_t = Expected<ExpressionValue> (*)(const ExpressionValue &,
+                                                   const ExpressionValue &);
 
 /// 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<uint64_t> eval() const override;
+  Expected<ExpressionValue> 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/numeric-expression.txt

 11
 CHECK-LABEL: REDEF
 CHECK-NEXT: [[#VAR1:]]
 
 ; Numeric variable definition with explicit matching format.
 DEF FMT
 c
 D
+-30
 CHECK-LABEL: DEF FMT
 CHECK-NEXT: [[#%x,VAR2:]]
 CHECK-NEXT: [[#%X,VAR3:]]
+CHECK-NEXT: [[#%d,VAR4:]]
 
 ; Numeric variable definition with explicit matching format with different
 ; spacing.
 DEF FMT SPC
 c
 CHECK-LABEL: DEF FMT SPC
 CHECK-NEXT: [[# %x , VAR2a : ]]
 
 ; Numeric variable definition with unsupported matching format.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes ERR,INVALID-FMT-SPEC1 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix INVALID-FMT-SPEC-MSG1 --strict-whitespace %s
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes ERR,INVALID-FMT-SPEC2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --check-prefix INVALID-FMT-SPEC-MSG2 --strict-whitespace %s
 
 DEF INVALID FMT
 INVVAR1=a
 INVVAR2=11
 ERR-LABEL: DEF INVALID FMT
 INVALID-FMT-SPEC1-NEXT: INVVAR1=[[#%c,INVVAR1:]]
 INVALID-FMT-SPEC2-NEXT: INVVAR2=[[#%hhd,INVVAR2:]]
 INVALID-FMT-SPEC-MSG1: numeric-expression.txt:[[#@LINE-2]]:37: error: invalid format specifier in expression
 INVALID-FMT-SPEC-MSG1-NEXT: {{I}}NVALID-FMT-SPEC1-NEXT: INVVAR1={{\[\[#%c,INVVAR1:\]\]}}
 INVALID-FMT-SPEC-MSG1-NEXT:    {{^}}                                    ^{{$}}
 INVALID-FMT-SPEC-MSG2: numeric-expression.txt:[[#@LINE-4]]:37: error: invalid format specifier in expression
 INVALID-FMT-SPEC-MSG2-NEXT: {{I}}NVALID-FMT-SPEC2-NEXT: INVVAR2={{\[\[#%hhd,INVVAR2:\]\]}}
 INVALID-FMT-SPEC-MSG2-NEXT:    {{^}}                                    ^{{$}}
 
 ; Numeric expressions in explicit matching format and default matching rule using
 ; variables defined on other lines without spaces.
 USE DEF FMT IMPL MATCH
-11 // VAR1
-12 // VAR1 + 1
-10 // VAR1 - 1
-c  // VAR2
-d  // VAR2 + 1
-b  // VAR2 - 1
-1a // VAR2 + 0xe
-1a // VAR2 + 0xE
-D  // VAR3
-E  // VAR3 + 1
-C  // VAR3 - 1
-1B // VAR3 + 0xe
-1B // VAR3 - oxE
-11 // VAR1a
-11 // VAR1b
-11 // VAR1c
+11  // VAR1
+12  // VAR1 + 1
+10  // VAR1 - 1
+c   // VAR2
+d   // VAR2 + 1
+b   // VAR2 - 1
+1a  // VAR2 + 0xe
+1a  // VAR2 + 0xE
+D   // VAR3
+E   // VAR3 + 1
+C   // VAR3 - 1
+1B  // VAR3 + 0xe
+1B  // VAR3 + 0xE
+-30 // VAR4
+-29 // VAR4 + 1
+-31 // VAR4 - 1
+42  // VAR4 + 72
+11  // VAR1a
+11  // VAR1b
+11  // VAR1c
 
-c  // VAR2a
+c   // VAR2a
 CHECK-LABEL: USE DEF FMT IMPL MATCH
 CHECK-NEXT: [[#%u,VAR1]]
 CHECK-NEXT: [[#%u,VAR1+1]]
 CHECK-NEXT: [[#%u,VAR1-1]]
 CHECK-NEXT: [[#%x,VAR2]]
 CHECK-NEXT: [[#%x,VAR2+1]]
 CHECK-NEXT: [[#%x,VAR2-1]]
 CHECK-NEXT: [[#%x,VAR2+0xe]]
 CHECK-NEXT: [[#%x,VAR2+0xE]]
 CHECK-NEXT: [[#%X,VAR3]]
 CHECK-NEXT: [[#%X,VAR3+1]]
 CHECK-NEXT: [[#%X,VAR3-1]]
 CHECK-NEXT: [[#%X,VAR3+0xe]]
 CHECK-NEXT: [[#%X,VAR3+0xE]]
+CHECK-NEXT: [[#%d,VAR4]]
+CHECK-NEXT: [[#%d,VAR4+1]]
+CHECK-NEXT: [[#%d,VAR4-1]]
+CHECK-NEXT: [[#%d,VAR4+72]]
 CHECK-NEXT: [[#%u,VAR1a]]
 CHECK-NEXT: [[#%u,VAR1b]]
 CHECK-NEXT: [[#%u,VAR1c]]
 CHECK-EMPTY:
 CHECK-NEXT: [[#%x,VAR2a]]
 
 ; Numeric expressions in explicit matching format and default matching rule using
 ; variables defined on other lines with different spacing.

 CHECK-NEXT: [[# %u , VAR1-1]]
 CHECK-NEXT: [[# %u , VAR1 -1]]
 CHECK-NEXT: [[# %u , VAR1 - 1]]
 CHECK-NEXT: [[# %u , VAR1 - 1 ]]
 
 ; Numeric expressions in implicit matching format and default matching rule using
 ; variables defined on other lines.
 USE IMPL FMT IMPL MATCH
-11 // VAR1
-12 // VAR1 + 1
-10 // VAR1 - 1
-c  // VAR2
-d  // VAR2 + 1
-b  // VAR2 - 1
-1a // VAR2 + 0xe
-1a // VAR2 + 0xE
-D  // VAR3
-E  // VAR3 + 1
-C  // VAR3 - 1
-1B // VAR3 + 0xe
-1B // VAR3 + 0xE
+11  // VAR1
+12  // VAR1 + 1
+10  // VAR1 - 1
+c   // VAR2
+d   // VAR2 + 1
+b   // VAR2 - 1
+1a  // VAR2 + 0xe
+1a  // VAR2 + 0xE
+D   // VAR3
+E   // VAR3 + 1
+C   // VAR3 - 1
+1B  // VAR3 + 0xe
+1B  // VAR3 + 0xE
+-30 // VAR4
+-29 // VAR4 + 1
+-31 // VAR4 - 1
 CHECK-LABEL: USE IMPL FMT IMPL MATCH
 CHECK-NEXT: [[#VAR1]]
 CHECK-NEXT: [[#VAR1+1]]
 CHECK-NEXT: [[#VAR1-1]]
 CHECK-NEXT: [[#VAR2]]
 CHECK-NEXT: [[#VAR2+1]]
 CHECK-NEXT: [[#VAR2-1]]
 CHECK-NEXT: [[#VAR2+0xe]]
 CHECK-NEXT: [[#VAR2+0xE]]
 CHECK-NEXT: [[#VAR3]]
 CHECK-NEXT: [[#VAR3+1]]
 CHECK-NEXT: [[#VAR3-1]]
 CHECK-NEXT: [[#VAR3+0xe]]
 CHECK-NEXT: [[#VAR3+0xE]]
+CHECK-NEXT: [[#VAR4]]
+CHECK-NEXT: [[#VAR4+1]]
+CHECK-NEXT: [[#VAR4-1]]
 
 ; Numeric expressions using variables defined on other lines and an immediate
 ; interpreted as an unsigned value.
 ; Note: 9223372036854775819 = 0x8000000000000000 + 11
 USE IMPL FMT IMPL MATCH UNSIGNED IMM
 9223372036854775819
 CHECK-LABEL: USE IMPL FMT IMPL MATCH UNSIGNED IMM
 CHECK-NEXT: [[#VAR1+0x8000000000000000]]
 
 ; Numeric expressions with matching format overriding the implicit format of
 ; variables defined on other lines.
 USE CONV FMT IMPL MATCH
 b  // %x, VAR1
 B  // %X, VAR1
+11 // %d, VAR1
 12 // %u, VAR2
 C  // %X, VAR2
+12 // %d, VAR2
 13 // %u, VAR3
 d  // %x, VAR3
+13 // %d, VAR3
+15 // %u, VAR4 + 45
+f  // %x, VAR4 + 45
+F  // %X, VAR4 + 45
 CHECK-LABEL: USE CONV FMT IMPL MATCH
 CHECK-NEXT: [[# %x, VAR1]]
 CHECK-NEXT: [[# %X, VAR1]]
+CHECK-NEXT: [[# %d, VAR1]]
 CHECK-NEXT: [[# %u, VAR2]]
 CHECK-NEXT: [[# %X, VAR2]]
+CHECK-NEXT: [[# %d, VAR2]]
 CHECK-NEXT: [[# %u, VAR3]]
 CHECK-NEXT: [[# %x, VAR3]]
+CHECK-NEXT: [[# %d, VAR3]]
+CHECK-NEXT: [[# %u, VAR4+45]]
+CHECK-NEXT: [[# %x, VAR4+45]]
+CHECK-NEXT: [[# %X, VAR4+45]]
 
 ; Conflicting implicit format.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes CHECK,FMT-CONFLICT1 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix FMT-CONFLICT1-MSG %s
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefixes CHECK,FMT-CONFLICT2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix FMT-CONFLICT2-MSG %s
 
 VAR USE IMPL FMT CONFLICT
 23
 FMT-CONFLICT1-LABEL: VAR USE IMPL FMT CONFLICT
-FMT-CONFLICT1-NEXT: [[#VAR1 + VAR2]]
-FMT-CONFLICT1-MSG: numeric-expression.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'VAR1' (%u) and 'VAR2' (%x), need an explicit format specifier
-FMT-CONFLICT1-MSG-NEXT: {{F}}MT-CONFLICT1-NEXT: {{\[\[#VAR1 \+ VAR2\]\]}}
+FMT-CONFLICT1-NEXT: [[#VAR1 + VAR4]]
+FMT-CONFLICT1-MSG: numeric-expression.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'VAR1' (%u) and 'VAR4' (%d), need an explicit format specifier
+FMT-CONFLICT1-MSG-NEXT: {{F}}MT-CONFLICT1-NEXT: {{\[\[#VAR1 \+ VAR4\]\]}}
 FMT-CONFLICT1-MSG-NEXT: {{^                       \^$}}
 
 VAR USE IMPL FMT CONFLICT COMPLEX
 34
 FMT-CONFLICT2-LABEL: VAR USE IMPL FMT CONFLICT
-FMT-CONFLICT2-NEXT: [[#VAR1 + VAR1a + VAR2]]
-FMT-CONFLICT2-MSG: numeric-expression.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'VAR1 + VAR1a' (%u) and 'VAR2' (%x), need an explicit format specifier
-FMT-CONFLICT2-MSG-NEXT: {{F}}MT-CONFLICT2-NEXT: {{\[\[#VAR1 \+ VAR1a \+ VAR2\]\]}}
+FMT-CONFLICT2-NEXT: [[#VAR1 + VAR1a + VAR4]]
+FMT-CONFLICT2-MSG: numeric-expression.txt:[[#@LINE-1]]:24: error: implicit format conflict between 'VAR1 + VAR1a' (%u) and 'VAR4' (%d), need an explicit format specifier
+FMT-CONFLICT2-MSG-NEXT: {{F}}MT-CONFLICT2-NEXT: {{\[\[#VAR1 \+ VAR1a \+ VAR4\]\]}}
 FMT-CONFLICT2-MSG-NEXT: {{^                       \^$}}
 
 ; Explicitly specified format can override conflicting implicit formats.
 VAR USE IMPL OVERRIDE FMT CONFLICT
 23
 CHECK-LABEL: VAR USE IMPL OVERRIDE FMT CONFLICT
 CHECK-NEXT: [[# %u, VAR1 + VAR2]]
 
 ; Numeric expressions using more than one variable defined on other lines.
 USE MULTI VAR
 31
 42
 CHECK-LABEL: USE MULTI VAR
-CHECK-NEXT: [[#VAR4:]]
-CHECK-NEXT: [[#VAR1+VAR4]]
+CHECK-NEXT: [[#VAR5:]]
+CHECK-NEXT: [[#VAR1+VAR5]]
 
 ; Numeric expression using a variable defined from a numeric expression.
 DEF EXPR GOOD MATCH
 42
 41
 ; CHECK-LABEL: DEF EXPR GOOD MATCH
 ; CHECK-NEXT: [[# VAR42:VAR1+31]]
 ; CHECK-NEXT: [[# VAR42-1]]

 22
 DC
 REDEF-NEW-FMT-LABEL: VAR REDEF FMT CHANGE
 REDEF-NEW-FMT-NEXT: [[#VAR1:]]
 REDEF-NEW-FMT-NEXT: [[#%X,VAR1:]]
 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,VAR1:\]\]}}
 REDEF-NEW-FMT-MSG-NEXT:    {{^}}                              ^{{$}}
+
+; Numeric expression with overflow.
+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: 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:    {{^}}                            ^{{$}}

llvm/unittests/Support/FileCheckTest.cpp

struct ExpressionFormatParameterisedFixture
   ExpressionFormat::Kind Kind;
   bool AllowHex;
   bool AllowUpperHex;
 };
 
 TEST_P(ExpressionFormatParameterisedFixture, Format) {
   SourceMgr SM;
   ExpressionFormat Format(Kind);
+  bool Signed = Kind == ExpressionFormat::Kind::Signed;
 
   Expected<StringRef> WildcardPattern = Format.getWildcardRegex();
   ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded());
-  Regex WildcardRegex(*WildcardPattern);
+  Regex WildcardRegex((Twine("^") + *WildcardPattern).str());
   ASSERT_TRUE(WildcardRegex.isValid());
   // Does not match empty string.
   EXPECT_FALSE(WildcardRegex.match(""));
   // Matches all decimal digits and matches several of them.
   SmallVector<StringRef, 4> Matches;
   StringRef DecimalDigits = "0123456789";
   ASSERT_TRUE(WildcardRegex.match(DecimalDigits, &Matches));
   EXPECT_EQ(Matches[0], DecimalDigits);
+  // Matches negative digits.
+  StringRef MinusFortyTwo = "-42";
+  bool MatchSuccess = WildcardRegex.match(MinusFortyTwo, &Matches);
+  if (Signed) {
+    ASSERT_TRUE(MatchSuccess);
+    EXPECT_EQ(Matches[0], MinusFortyTwo);
+  } else
+    EXPECT_FALSE(MatchSuccess);
   // Check non digits or digits with wrong casing are not matched.
   if (AllowHex) {
     StringRef HexOnlyDigits[] = {"abcdef", "ABCDEF"};
     StringRef AcceptedHexOnlyDigits =
         AllowUpperHex ? HexOnlyDigits[1] : HexOnlyDigits[0];
     StringRef RefusedHexOnlyDigits =
         AllowUpperHex ? HexOnlyDigits[0] : HexOnlyDigits[1];
     ASSERT_TRUE(WildcardRegex.match(AcceptedHexOnlyDigits, &Matches));
     EXPECT_EQ(Matches[0], AcceptedHexOnlyDigits);
     EXPECT_FALSE(WildcardRegex.match(RefusedHexOnlyDigits));
 
     EXPECT_FALSE(WildcardRegex.match("g"));
     EXPECT_FALSE(WildcardRegex.match("G"));
   } else {
     EXPECT_FALSE(WildcardRegex.match("a"));
     EXPECT_FALSE(WildcardRegex.match("A"));
   }
 
-  Expected<std::string> MatchingString = Format.getMatchingString(0U);
+  Expected<std::string> MatchingString =
+      Format.getMatchingString(ExpressionValue(0, /*Signed=*/false));
   ASSERT_THAT_EXPECTED(MatchingString, Succeeded());
   EXPECT_EQ(*MatchingString, "0");
-  MatchingString = Format.getMatchingString(9U);
+  MatchingString =
+      Format.getMatchingString(ExpressionValue(9, /*Signed=*/false));
   ASSERT_THAT_EXPECTED(MatchingString, Succeeded());
   EXPECT_EQ(*MatchingString, "9");
-  Expected<std::string> TenMatchingString = Format.getMatchingString(10U);
+  MatchingString =
+      Format.getMatchingString(ExpressionValue(-5, /*Signed=*/true));
+  if (Signed) {
+    ASSERT_THAT_EXPECTED(MatchingString, Succeeded());
+    EXPECT_EQ(*MatchingString, "-5");
+  } else {
+    // Error message tested in ExpressionValue unit tests.
+    EXPECT_THAT_EXPECTED(MatchingString, Failed());
+  }
+  uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max();
+  Expected<std::string> MaxUint64MatchingString =
+      Format.getMatchingString(ExpressionValue(MaxUint64, /*Signed=*/false));
+  Expected<std::string> TenMatchingString =
+      Format.getMatchingString(ExpressionValue(10, /*Signed=*/false));
   ASSERT_THAT_EXPECTED(TenMatchingString, Succeeded());
-  Expected<std::string> FifteenMatchingString = Format.getMatchingString(15U);
+  Expected<std::string> FifteenMatchingString =
+      Format.getMatchingString(ExpressionValue(15, /*Signed=*/false));
   ASSERT_THAT_EXPECTED(FifteenMatchingString, Succeeded());
   StringRef ExpectedTenMatchingString, ExpectedFifteenMatchingString;
+  std::string MaxUint64Str;
   if (AllowHex) {
     if (AllowUpperHex) {
+      MaxUint64Str = "FFFFFFFFFFFFFFFF";
       ExpectedTenMatchingString = "A";
       ExpectedFifteenMatchingString = "F";
     } else {
+      MaxUint64Str = "ffffffffffffffff";
       ExpectedTenMatchingString = "a";
       ExpectedFifteenMatchingString = "f";
     }
   } else {
+    MaxUint64Str = std::to_string(MaxUint64);
     ExpectedTenMatchingString = "10";
     ExpectedFifteenMatchingString = "15";
   }
+  if (Signed) {
+    // Error message tested in ExpressionValue unit tests.
+    EXPECT_THAT_EXPECTED(MaxUint64MatchingString, Failed());
+  } else {
+    ASSERT_THAT_EXPECTED(MaxUint64MatchingString, Succeeded());
+    EXPECT_EQ(*MaxUint64MatchingString, MaxUint64Str);
+  }
   EXPECT_EQ(*TenMatchingString, ExpectedTenMatchingString);
   EXPECT_EQ(*FifteenMatchingString, ExpectedFifteenMatchingString);
 
   StringRef BufferizedValidValueStr = bufferize(SM, "0");
-  Expected<uint64_t> Val =
+  Expected<ExpressionValue> Val =
       Format.valueFromStringRepr(BufferizedValidValueStr, SM);
   ASSERT_THAT_EXPECTED(Val, Succeeded());
-  EXPECT_EQ(*Val, 0U);
+  EXPECT_EQ(cantFail(Val->getSignedValue()), 0);
   BufferizedValidValueStr = bufferize(SM, "9");
   Val = Format.valueFromStringRepr(BufferizedValidValueStr, SM);
   ASSERT_THAT_EXPECTED(Val, Succeeded());
-  EXPECT_EQ(*Val, 9U);
-  StringRef BufferizedTenStr, BufferizedInvalidTenStr, BufferizedFifteenStr;
+  EXPECT_EQ(cantFail(Val->getSignedValue()), 9);
+  StringRef BufferizedMinusFiveStr = bufferize(SM, "-5");
+  Val = Format.valueFromStringRepr(BufferizedMinusFiveStr, SM);
+  StringRef OverflowErrorStr = "unable to represent numeric value";
+  if (Signed) {
+    ASSERT_THAT_EXPECTED(Val, Succeeded());
+    EXPECT_EQ(cantFail(Val->getSignedValue()), -5);
+  } else
+    expectDiagnosticError(OverflowErrorStr, Val.takeError());
+  StringRef BufferizedMaxUint64Str, BufferizedTenStr, BufferizedInvalidTenStr,
+      BufferizedFifteenStr;
   StringRef TenStr, FifteenStr, InvalidTenStr;
   if (AllowHex) {
     if (AllowUpperHex) {
       TenStr = "A";
       FifteenStr = "F";
       InvalidTenStr = "a";
     } else {
       TenStr = "a";
       FifteenStr = "f";
       InvalidTenStr = "A";
     }
   } else {
     TenStr = "10";
     FifteenStr = "15";
     InvalidTenStr = "A";
   }
+  BufferizedMaxUint64Str = bufferize(SM, MaxUint64Str);
+  Val = Format.valueFromStringRepr(BufferizedMaxUint64Str, SM);
+  if (Signed)
+    expectDiagnosticError(OverflowErrorStr, Val.takeError());
+  else {
+    ASSERT_THAT_EXPECTED(Val, Succeeded());
+    EXPECT_EQ(cantFail(Val->getUnsignedValue()), MaxUint64);
+  }
   BufferizedTenStr = bufferize(SM, TenStr);
   Val = Format.valueFromStringRepr(BufferizedTenStr, SM);
   ASSERT_THAT_EXPECTED(Val, Succeeded());
-  EXPECT_EQ(*Val, 10U);
+  EXPECT_EQ(cantFail(Val->getSignedValue()), 10);
   BufferizedFifteenStr = bufferize(SM, FifteenStr);
   Val = Format.valueFromStringRepr(BufferizedFifteenStr, SM);
   ASSERT_THAT_EXPECTED(Val, Succeeded());
-  EXPECT_EQ(*Val, 15U);
+  EXPECT_EQ(cantFail(Val->getSignedValue()), 15);
   // Wrong casing is not tested because valueFromStringRepr() relies on
   // StringRef's getAsInteger() which does not allow to restrict casing.
   BufferizedInvalidTenStr = bufferize(SM, InvalidTenStr);
   expectDiagnosticError(
-      "unable to represent numeric value",
+      OverflowErrorStr,
       Format.valueFromStringRepr(bufferize(SM, "G"), SM).takeError());
 
   // Check boolean operator.
   EXPECT_TRUE(bool(Format));
 }
 
 INSTANTIATE_TEST_CASE_P(
     AllowedExplicitExpressionFormat, ExpressionFormatParameterisedFixture,
     ::testing::Values(
         std::make_tuple(ExpressionFormat::Kind::Unsigned, /*AllowHex=*/false,
                         /*AllowUpperHex=*/false),
+        std::make_tuple(ExpressionFormat::Kind::Signed, /*AllowHex=*/false,
+                        /*AllowUpperHex=*/false),
         std::make_tuple(ExpressionFormat::Kind::HexLower, /*AllowHex=*/true,
                         /*AllowUpperHex=*/false),
         std::make_tuple(ExpressionFormat::Kind::HexUpper, /*AllowHex=*/true,
                         /*AllowUpperHex=*/true)), );
 
 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(18).takeError());
+  expectError<StringError>(
+      "trying to match value with invalid format",
+      NoFormat.getMatchingString(ExpressionValue(18, /*Signed=*/false))
+          .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);
 }
 
+TEST_F(FileCheckTest, ExpressionValue) {
+  // isSigned() and isNegative() tests.
+  ExpressionValue UnsignedTenValue(10, /*Signed=*/false);
+  EXPECT_FALSE(UnsignedTenValue.isSigned());
+  EXPECT_FALSE(UnsignedTenValue.isNegative());
+
+  ExpressionValue SignedTenValue(10, /*Signed=*/true);
+  EXPECT_TRUE(SignedTenValue.isSigned());
+  EXPECT_FALSE(SignedTenValue.isNegative());
+
+  ExpressionValue MinusTenValue(-10, /*Signed=*/true);
+  EXPECT_TRUE(MinusTenValue.isSigned());
+  EXPECT_TRUE(MinusTenValue.isNegative());
+
+  // getUnsignedValue() tests.
+  Expected<uint64_t> UnsignedValue = UnsignedTenValue.getUnsignedValue();
+  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
+  EXPECT_EQ(*UnsignedValue, 10U);
+
+  UnsignedValue = SignedTenValue.getUnsignedValue();
+  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
+  EXPECT_EQ(*UnsignedValue, 10U);
+
+  uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max();
+  ExpressionValue MaxUint64Value(MaxUint64, /*Signed=*/false);
+  UnsignedValue = MaxUint64Value.getUnsignedValue();
+  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
+  EXPECT_EQ(*UnsignedValue, MaxUint64);
+
+  expectError<OverflowError>("overflow error",
+                             MinusTenValue.getUnsignedValue().takeError());
+
+  // getSignedValue() tests.
+  Expected<int64_t> SignedValue = UnsignedTenValue.getSignedValue();
+  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
+  EXPECT_EQ(*SignedValue, 10);
+
+  SignedValue = SignedTenValue.getSignedValue();
+  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
+  EXPECT_EQ(*SignedValue, 10);
+
+  expectError<OverflowError>("overflow error",
+                             MaxUint64Value.getSignedValue().takeError());
+
+  SignedValue = MinusTenValue.getSignedValue();
+  ASSERT_THAT_EXPECTED(SignedValue, Succeeded());
+  EXPECT_EQ(*SignedValue, -10);
+
+  // getAbsolute() tests.
+  ExpressionValue AbsoluteTenValue = UnsignedTenValue.getAbsolute();
+  EXPECT_FALSE(AbsoluteTenValue.isSigned());
+  UnsignedValue = AbsoluteTenValue.getUnsignedValue();
+  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
+  EXPECT_EQ(*UnsignedValue, 10U);
+
+  AbsoluteTenValue = SignedTenValue.getAbsolute();
+  EXPECT_FALSE(AbsoluteTenValue.isSigned());
+  UnsignedValue = AbsoluteTenValue.getUnsignedValue();
+  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
+  EXPECT_EQ(*UnsignedValue, 10U);
+
+  AbsoluteTenValue = MinusTenValue.getAbsolute();
+  EXPECT_FALSE(AbsoluteTenValue.isSigned());
+  UnsignedValue = AbsoluteTenValue.getUnsignedValue();
+  ASSERT_THAT_EXPECTED(UnsignedValue, Succeeded());
+  EXPECT_EQ(*UnsignedValue, 10U);
+
+  // operator+ tests.
+  Expected<ExpressionValue> AdditionResult = MinusTenValue + MinusTenValue;
+  ASSERT_THAT_EXPECTED(AdditionResult, Succeeded());
+  EXPECT_TRUE(AdditionResult->isNegative());
+  Expected<int64_t> AdditionSignedValue = AdditionResult->getSignedValue();
+  ASSERT_THAT_EXPECTED(AdditionSignedValue, Succeeded());
+  EXPECT_EQ(*AdditionSignedValue, -20);
+
+  ExpressionValue MinInt64Value(std::numeric_limits<int64_t>::min(),
+                                /*Signed=*/true);
+  AdditionResult = MinInt64Value + MinusTenValue;
+  expectError<OverflowError>("overflow error", AdditionResult.takeError());
+
+  AdditionResult = MinusTenValue + UnsignedTenValue;
+  ASSERT_THAT_EXPECTED(AdditionResult, Succeeded());
+  EXPECT_FALSE(AdditionResult->isNegative());
+  Expected<int64_t> AdditionUnsignedValue = AdditionResult->getUnsignedValue();
+  ASSERT_THAT_EXPECTED(AdditionUnsignedValue, Succeeded());
+  EXPECT_EQ(*AdditionUnsignedValue, 0U);
+
+  AdditionResult = UnsignedTenValue + MinusTenValue;
+  ASSERT_THAT_EXPECTED(AdditionResult, Succeeded());
+  EXPECT_FALSE(AdditionResult->isNegative());
+  AdditionUnsignedValue = AdditionResult->getUnsignedValue();
+  ASSERT_THAT_EXPECTED(AdditionUnsignedValue, Succeeded());
+  EXPECT_EQ(*AdditionUnsignedValue, 0U);
+
+  AdditionResult = UnsignedTenValue + UnsignedTenValue;
+  ASSERT_THAT_EXPECTED(AdditionResult, Succeeded());
+  EXPECT_FALSE(AdditionResult->isNegative());
+  AdditionUnsignedValue = AdditionResult->getUnsignedValue();
+  ASSERT_THAT_EXPECTED(AdditionUnsignedValue, Succeeded());
+  EXPECT_EQ(*AdditionUnsignedValue, 20U);
+
+  AdditionResult = MaxUint64Value + UnsignedTenValue;
+  expectError<OverflowError>("overflow error", AdditionResult.takeError());
+
+  // operator- tests.
+  Expected<ExpressionValue> SubstractionResult = MinusTenValue - SignedTenValue;
+  ASSERT_THAT_EXPECTED(SubstractionResult, Succeeded());
+  EXPECT_TRUE(SubstractionResult->isNegative());
+  Expected<int64_t> SubstractionSignedValue =
+      SubstractionResult->getSignedValue();
+  ASSERT_THAT_EXPECTED(SubstractionSignedValue, Succeeded());
+  EXPECT_EQ(*SubstractionSignedValue, -20);
+
+  SubstractionResult = MinInt64Value - SignedTenValue;
+  expectError<OverflowError>("overflow error", SubstractionResult.takeError());
+
+  SubstractionResult = MinusTenValue - UnsignedTenValue;
+  expectError<OverflowError>("overflow error", SubstractionResult.takeError());
+
+  SubstractionResult = UnsignedTenValue - SignedTenValue;
+  ASSERT_THAT_EXPECTED(SubstractionResult, Succeeded());
+  EXPECT_FALSE(SubstractionResult->isNegative());
+  Expected<uint64_t> SubstractionUnsignedValue =
+      SubstractionResult->getUnsignedValue();
+  ASSERT_THAT_EXPECTED(SubstractionUnsignedValue, Succeeded());
+  EXPECT_EQ(*SubstractionUnsignedValue, 0U);
+}
+
 TEST_F(FileCheckTest, Literal) {
   SourceMgr SM;
 
   // Eval returns the literal's value.
-  ExpressionLiteral Ten(bufferize(SM, "10"), 10);
-  Expected<uint64_t> Value = Ten.eval();
+  ExpressionLiteral Ten(bufferize(SM, "10"), 10u);
+  Expected<ExpressionValue> Value = Ten.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
-  EXPECT_EQ(10U, *Value);
+  EXPECT_EQ(10, cantFail(Value->getSignedValue()));
   Expected<ExpressionFormat> ImplicitFormat = Ten.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::NoFormat);
 
+  // Min value can be correctly represented.
+  int64_t MinInt64 = std::numeric_limits<int64_t>::min();
+  ExpressionLiteral Min(bufferize(SM, std::to_string(MinInt64)), MinInt64);
+  Value = Min.eval();
+  ASSERT_TRUE(bool(Value));
+  EXPECT_EQ(std::numeric_limits<int64_t>::min(),
+            cantFail(Value->getSignedValue()));
+
   // Max value can be correctly represented.
   uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max();
   ExpressionLiteral Max(bufferize(SM, std::to_string(MaxUint64)), MaxUint64);
   Value = Max.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
-  EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
+  EXPECT_EQ(std::numeric_limits<uint64_t>::max(),
+            cantFail(Value->getUnsignedValue()));
 }
 
 TEST_F(FileCheckTest, Expression) {
   SourceMgr SM;
 
   std::unique_ptr<ExpressionLiteral> Ten =
-      std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), 10);
+      std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), 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
 expectUndefErrors(std::unordered_set<std::string> ExpectedUndefVarNames,
                   Error Err) {
   EXPECT_THAT_ERROR(handleErrors(std::move(Err),
                                  [&](const UndefVarError &E) {
                                    EXPECT_EQ(ExpectedUndefVarNames.erase(
                                                  std::string(E.getVarName())),
                                              1U);
                                  }),
                     Succeeded());
   EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
 }
 
-uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
+Expected<ExpressionValue> doAdd(const ExpressionValue &Op1,
+                                const ExpressionValue &Op2) {
+  if (Op1.isSigned()) {
+    int64_t Val1 = cantFail(Op1.getSignedValue());
+    int64_t Val2 = cantFail(Op2.getSignedValue());
+
+    return ExpressionValue(Val1 + Val2, /*Signed=*/true);
+  } else {
+    uint64_t Val1 = cantFail(Op1.getUnsignedValue());
+    uint64_t Val2 = cantFail(Op2.getUnsignedValue());
+
+    return ExpressionValue(Val1 + Val2, /*Signed=*/false);
+  }
+}
 
 TEST_F(FileCheckTest, NumericVariable) {
   SourceMgr SM;
 
   // Undefined variable: getValue and eval fail, error returned by eval holds
   // the name of the undefined variable.
   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<uint64_t> EvalResult = FooVarUse.eval();
+  Expected<ExpressionValue> EvalResult = FooVarUse.eval();
   expectUndefErrors({"FOO"}, EvalResult.takeError());
 
-  FooVar.setValue(42);
+  FooVar.setValue(ExpressionValue(42, /*Signed=*/false));
 
   // Defined variable: getValue and eval return value set.
-  Optional<uint64_t> Value = FooVar.getValue();
+  Optional<ExpressionValue> Value = FooVar.getValue();
   ASSERT_TRUE(Value);
-  EXPECT_EQ(42U, *Value);
+  EXPECT_EQ(42, cantFail(Value->getSignedValue()));
   EvalResult = FooVarUse.eval();
   ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
-  EXPECT_EQ(42U, *EvalResult);
+  EXPECT_EQ(42, cantFail(EvalResult->getSignedValue()));
 
   // Clearing variable: getValue and eval fail. Error returned by eval holds
   // the name of the cleared variable.
   FooVar.clearValue();
   EXPECT_FALSE(FooVar.getValue());
   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(42);
+  FooVar.setValue(ExpressionValue(42, /*Signed=*/false));
   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(18);
+  BarVar.setValue(ExpressionValue(18, /*Signed=*/false));
   std::unique_ptr<NumericVariableUse> BarVarUse =
       std::make_unique<NumericVariableUse>(BarStr, &BarVar);
   BinaryOperation Binop(ExprStr, doAdd, std::move(FooVarUse),
                         std::move(BarVarUse));
 
   // Defined variables: eval returns right value; implicit format is as
   // expected.
-  Expected<uint64_t> Value = Binop.eval();
+  Expected<ExpressionValue> Value = Binop.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
-  EXPECT_EQ(60U, *Value);
+  EXPECT_EQ(60, cantFail(Value->getSignedValue()));
   Expected<ExpressionFormat> ImplicitFormat = Binop.getImplicitFormat(SM);
   ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
   EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
 
   // 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, 18);
+      std::make_unique<ExpressionLiteral>(EighteenStr, 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, 18);
+  Eighteen = std::make_unique<ExpressionLiteral>(EighteenStr, 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, ParseNumericSubstitutionBlock) {
   expectDiagnosticError("unsupported operation 'U'",
                         Tester.parseSubst("42U").takeError());
 
   // Valid empty expression.
   EXPECT_THAT_EXPECTED(Tester.parseSubst(""), Succeeded());
 
   // Valid single operand expression.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO"), Succeeded());
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("18"), Succeeded());
+  uint64_t MaxUint64 = std::numeric_limits<uint64_t>::max();
+  EXPECT_THAT_EXPECTED(Tester.parseSubst(std::to_string(MaxUint64)),
+                       Succeeded());
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("0x12"), Succeeded());
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("-30"), Succeeded());
+  int64_t MinInt64 = std::numeric_limits<int64_t>::min();
+  EXPECT_THAT_EXPECTED(Tester.parseSubst(std::to_string(MinInt64)),
+                       Succeeded());
 
   // Invalid format.
   expectDiagnosticError("invalid matching format specification in expression",
                         Tester.parseSubst("X,FOO:").takeError());
   expectDiagnosticError("invalid format specifier in expression",
                         Tester.parseSubst("%F,FOO").takeError());
   expectDiagnosticError("invalid matching format specification in expression",
                         Tester.parseSubst("%X a,FOO").takeError());
TEST_F(FileCheckTest, ParseNumericSubstitutionBlock) {
 
   // Invalid hex literal in legacy @LINE expression.
   expectDiagnosticError(
       "unexpected characters at end of expression 'xC'",
       Tester.parseSubst("@LINE+0xC", /*LegacyLineExpr=*/true).takeError());
 
   // Valid expression with format specifier.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("%u, FOO"), Succeeded());
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("%d, FOO"), Succeeded());
   EXPECT_THAT_EXPECTED(Tester.parseSubst("%x, FOO"), Succeeded());
   EXPECT_THAT_EXPECTED(Tester.parseSubst("%X, FOO"), Succeeded());
 
   // Valid legacy @LINE expression.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("@LINE+2", /*IsLegacyNumExpr=*/true),
                        Succeeded());
 
   // Invalid legacy @LINE expression with more than 2 operands.
TEST_F(FileCheckTest, ParsePattern) {
 
   // Invalid legacy @LINE expression with non decimal literal.
   EXPECT_TRUE(Tester.parsePattern("[[@LINE+0x3]]"));
 }
 
 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",
+      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());
 
   // Check matching a definition only matches a number with the right format.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]"));
   expectNotFoundError(Tester.match("FAIL").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(10);
+  NVar.setValue(ExpressionValue(10, /*Signed=*/false));
   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<uint64_t> ExpressionVal = (*ExpressionPointer)->getAST()->eval();
+  Expected<ExpressionValue> ExpressionVal =
+      (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
-  EXPECT_EQ(*ExpressionVal, 18U);
+  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 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(*ExpressionVal, 20U);
-  ExpressionPointer =
-      P.parseNumericSubstitutionBlock(LocalNumVar3Ref, DefinedNumericVariable,
-                                      /*IsLegacyLineExpr=*/false,
-                                      LineNumber, &Cxt, SM);
+  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 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(*ExpressionVal, 12U);
+  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 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(*ExpressionVal, 36U);
+  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 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(*ExpressionVal, 36U);
+  EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
 }
 } // namespace