FileCheck [9/12]: Add support for matching formats

[thopre]

Summary

This patch is part of a patch series to add support for FileCheck
numeric expressions. This specific patch adds support for selecting a
matching format to match a numeric value against (ie. decimal, hex lower
case letters or hex upper case letters).

This commit allows to select what format a numeric value should be
matched against. The following formats are supported: decimal value,
lower case hex value and upper case hex value. Matching formats impact
both the format of numeric value to be matched as well as the format of
accepted numbers in a definition with empty numeric expression
constraint.

Default for absence of format is decimal value unless the numeric
expression constraint is non null and use a variable in which case the
format is the one used to define that variable. Conclict of format in
case of several variable being used is diagnosed and forces the user to
select a matching format explicitely.

This commit also enables immediates in numeric expressions to be in any
radix known to StringRef's GetAsInteger method, except for legacy
numeric expressions (ie [[@LINE+<offset>]] which only support decimal
immediates.

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)

[MaskRay]

llvm/lib/Support/FileCheck.cpp

55

I think if (StrVal.getAsInteger(Hex ? 16 : 10, Value)) is just as clear. (Or (Hex ? 16 : 10). The empty line above can also be deleted.

100

LeftFormat.Valid ? LeftFormat : RightFormat;

163

Delete the helper and inline it into the call sites.

265–266

I think if (!Expr.consumeInteger(AO == Literal ? 10 : 0, LiteralValue)) is just as clear as the current one.

[arichardson]

llvm/lib/Support/FileCheck.cpp

36

Maybe [0-9]+ instead of "[[:digit:]]+"?

80–81

if (Expression && Expression->getAST()) is a bit shorter and just as readable.

[jhenderson]

llvm/docs/CommandGuide/FileCheck.rst

609

Perhaps worth stating "61680" in hex, rather than decimal.

611

I'm getting confused by the syntax here not matching the syntax above for defining a numeric variable. Aren't the two essentially the same syntax, just with different parameters missing? If I'm not mistaken they can be unified to [[#%<fmtspc>,<NUMVAR>:<expr>]] where <expr> says what this matches against (if specified), <NUMVAR> says what numeric variable to store the result in (if specified) and fmtspec defines the format of the expression (if any) and that stored in the variable (if any).

Aside: does #%X match a hex number, but not store it?

615

"constraint, if any, and defaults to". The later sentence handles the "all the same" bit by talking of conflicts.

llvm/include/llvm/Support/FileCheck.h

51 ↗

(On Diff #205764)

I would call this UpperCase or Capitalize. If it is only ever used for hex values (I'm not sure if there are plans for e.g. uppercasing string values later on) storing an enumeration with HexUpper and HexLower, Unsigned values could also make sense.

I agree that an enum seems like the right way forward here, possibly with Conflict and Unspecified as other values in that enum.

67 ↗

(On Diff #205764)

"regexp"? I assume that should be "regular expression pattern"?

84 ↗

(On Diff #205764)

Is there going to be an ODR violation here, due to these being instantiated in the header?

152 ↗

(On Diff #205764)

Why shared_ptr? Shouldn't an expression be the sole owner of its AST?

154 ↗

(On Diff #205764)

i.e -> i.e.

161 ↗

(On Diff #205764)

ie. -> i.e.

Perhaps Format should take a default argument for an unsigned decimal?

The last clause ("set it to default one"...) then becomes unnecessary.

170 ↗

(On Diff #205764)

ie -> i.e.

(i) its explicit format, if any, otherwise (ii) its implicit format, if any, otherwise (iii) the default format.

186 ↗

(On Diff #205764)

If the expression is empty, Expression points to a FileCheckExpression instance...

264 ↗

(On Diff #205764)

if the implicit

265 ↗

(On Diff #205764)

conflict, and FormatNone

llvm/lib/Support/FileCheck.cpp

66

I believe you could do this in the initializer list:

: AST(AST)
, Format(Format.Valid ? Format : FormatUnsigned) {}

80–81

Readability is in the eye of the beholder. I personally find it more readable to compare against nullptr, because it is then clear that Expression is a pointer, not a boolean.

llvm/test/FileCheck/numeric-defines.txt

3–5

I feel like you're losing coverage here: where are command-line defined numeric variables tested with an implicit format specifier? I'd have a separate test for format specifiers, that explicitly focus on testing those and nothing else.

llvm/test/FileCheck/numeric-expression.txt

45–49

Do you really need every one of these test cases? It feels like the last one would be enough (and one with no spaces, which you have earlier on). Same goes for other instances like this elsewhere.

53

Should this be USE EXPL FMT IMPL MATCH?

139

Nit: missing trailing full stop.

165

Nit: missing trailing full stop.

The grammar of this statement needs significant improvement. How about "Explicitly specified format can override conflicting implicit formats."

This test case should be after the one that shows that explicit format specifiers override non-conflicting implicit ones, and probably also after a test case showing what happens when they conflict.

172

Nit: missing trailing full stop.

What is a "conversion matching format"?

184

Nit: missing trailing full stop.

198

In one of the other changes, you went to some effort to improve the readability of these using --strict-whitespace, so that the '^' line up with the correct thing. Could you replicate these improvements in this patch too, please?

332

Missing trailing full stop.

333–334

You're being inconsistent here with your '-' versus '--' switch usage. Please standardise to one or the other throughout the test.

340

This message is incomplete - which variables? What were their format specifiers?

llvm/test/FileCheck/string-defines-diagnostics.txt

30–31

Please re-add the second dash, to remain consistent with other tests in this file (why did you change it?)

llvm/unittests/Support/FileCheckTest.cpp

276–277

FileCheckExpression NumVarExpr(nullptr, FormatUnsigned);

Same kind of comment goes throughout changes in this file.

277–278

Why make_shared and not make_unique? In fact, why is this a smart pointer at all? Why not just create this on the stack, i.e. FileCheckNumericVariable FooVar (1, "FOO", &NumVarExpr);

Same comment goes in all sorts of places elsewhere.

[thopre]

Address most comments, 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.

llvm/docs/CommandGuide/FileCheck.rst

611

That's a mistake, well spotted. Yes #%X matches an hex number in capital letters but does not store it.

llvm/test/FileCheck/string-defines-diagnostics.txt

30–31

The patch initially only changed ERRCLIFMT into ERRCLINAME. Later when rebasing it after the updated previous patch with the -- syntax I missed the - to -- change when resolving conflicts in this file. Same for all other issues you mention in an earlier patch and end up in a later patch: either incorrect merging (happens a lot when the conflict spans many lines because it's easy to miss something) or it's new code and I forgot to apply some fix on there as well (for example the eg -> e.g. fixes).

In other word, my apologies for making you repeat your point, it's due to being absent-minded at times.

[jhenderson]

I've not looked at the tests in the latest version, but I've made a number of style and comment comments for you.

llvm/docs/CommandGuide/FileCheck.rst

615

default -> defaults

llvm/lib/Support/FileCheck.cpp

30–32

Probably the more canonical way of writing these sort of switch statements is:

switch (Value) {
case 1:
...
case 2:
...
default:
  llvm_unreachable("unknown format value");
}

(If the code isn't truly unreachable on the other hand, it should be an error, not an assertion)

99

I don't know about anybody else, but LeftFormat != NoFormat ? LeftFormat : RightFormat is more readable to me (and removes the need to hard-code the enum value).

llvm/lib/Support/FileCheckImpl.h

33–34

The comments in this class and its enum need updating following the recent changes to it.

Also, "printed into for matching" doesn't really make sense. Probably something like "converted into" would make more sense.

42

Perhaps change this to "Used when there are..."

68

explicit?

104–105

either implicit format of this AST ... or NoFormat if the AST has...

106

made -> made up

178

"without an explicit"

I don't think you need the rest of the sentence after that: the concept of a conflict isn't important to the variable.

[arichardson]

Some minor comments, but generally looking good to me.
We have a few downstream tests that will really benefit from matching Hex upper/lower so looking forward to this landing.

llvm/lib/Support/FileCheck.cpp

99

I agree, checking != NoFormat seems clearer to me rather than relying on NoFormat being zero.
Alternatively, we could use Optional<ExpressionFormat> but that seems like unnecessary overhead.

232

Not sure about the FormatValue name for the enum. Maybe something like Kind or Type?
Then this would be ExpressionFormat::Kind::Unsigned which I think reads slightly better.

333

Instead of checking for a comma (which be allowed to appear after the : in the future, I would check if the next non-whitespace character is a %. Or to simplify this we could require the % to immediately follow the # character?

373

Where does the following code modify Expr? Is it inside the call to parseNumericOperand?

llvm/lib/Support/FileCheckImpl.h

45

The hex comments don't match the order of the enum.
Since you are documenting all other members, maybe add Value should be printed an unsigned decimal number. to Unsigned?

56

This should be explicit. Although we could also remove it and always compare to NoFormat.

156

I would avoid the i.e+e.g sequence:
The format to use (e.g. hex upper case letters) when matching the value.

llvm/test/FileCheck/numeric-defines.txt

20–23

I find this slightly surprising. If I define a numeric variable on the command line with hex format, I would expect the value to be parsed as a hex number, i.e. 0x12 and not 0xc.

[thopre]

Address most review comments

[thopre]

llvm/lib/Support/FileCheck.cpp

99

Changed. Note that ExpressionFormat is a structure so this calls the overloaded boolean operator and does not rely on any hard-coded value.

333

I'm not sure I follow the intent of your message, are you against the syntax (i.e. there should be no comma at all) or the way it is parsed? Anyway, since the format comes first, I'm not sure how allowing a comma in the later part of the syntax would be a problem. If I remember well its use in the syntax was suggested to match the API of printf/scanf. Otherwise we'd have:
#%d FOOBAR:N+1 which I find less easy to read.

373

Yes and parseBinop.

llvm/test/FileCheck/numeric-defines.txt

20–23

I didn't think of that. What would be your expectation for implicit format though?

E.g. -D#%X,NUMVAL1=7 -D#NUMVAL2=12+NUMVAL1. Should NUMVAL2 be 0x17 or decimal 17?

[arichardson]

llvm/lib/Support/FileCheck.cpp

333

Sorry about the ambiguity. The current syntax is perfectly fine.

I was suggesting a change to the parsing code to check that the first non-whitespace char is a % first instead of searching for a comma. But this would only change the which error messages for certain invalid input so it shouldn't really matter.

llvm/test/FileCheck/numeric-defines.txt

20–23

I'm not entirely sure what the best solution there is.
I think NUMVAL2 should always evaluate to 19.
However, I don't have a strong preference whether it should capture decimal 19 or hex 0x13 (i.e. parse the number in the expresssion as decimal, but inherit format from the other variable).

Alternatively we could require an explicit format for those (probably rare?) cases.

[jhenderson]

llvm/lib/Support/FileCheckImpl.h

40

Am I right in thinking you can get rid of the = 0 now?

56

This comment isn't clear to me. I assume what it means by "if it can be matched" is "if it is a format that can be used in a match" ot something similar?

62

if neither is NoFormat and their kinds are the same.

llvm/test/FileCheck/numeric-defines.txt

4–5

Nit: trailing full stop.

You're also mixing your comment characters. Here you use '#', but two lines above you use ';'.

50

Nit: too many blank lines (1 is enough)

54

I'm not familiar with this "%ProtectFileCheckOutput". What is it for, and why do only some cases seem to use it?

73

You should probably also have this case where the format is on the second value, and not the first.

llvm/test/FileCheck/numeric-expression.txt

173

Aside from being fewer in number, how is this set different from the "USE DEF FMT IMPL MATCH" set?

llvm/unittests/Support/FileCheckTest.cpp

46

It might be interesting to show what happens when you pass an upper-case hex digit to a lower-case format and vice versa.

63

What's going on here?

[thopre]

Add example showing literals are always parsed as decimal

llvm/lib/Support/FileCheck.cpp

333

Yes, in one case one could diagnose a missing comma while in the other a missing percentage. This approach allows to reorder the code to parse each element of a numeric substitution (format specifier, variable definition, expression) when internal API change, as was done in earlier version of this patch. If you don't mind I'll keep it this way.

llvm/test/FileCheck/numeric-defines.txt

20–23

Is the way you expect 12 to be interpreted in '-D#%X,NUMVAL=12' and in '-D#%X,NUMVAL1=7 -D#NUMVAL2=12+NUMVAL1' different because of the explicit Vs implicit format or because you see the former as similar to a value in an input text (and thus 12 as 0x12) and the latter as a literal in a numeric expression (and thus 12 as decimal 12)?

I find it even more confusing to distinguish the behavior of literals between implicit and explicit format (e.g. '-D#%X,NUMVAL1=7 -D#%X,NUMVAL2=12+NUMVAL1' would interpret 12 as 0x12 then).

I also see several reasons to avoid the distinction between the 2 examples based on whether a variable is present after the equal sign:

• complexity: (i) more text needs to be added in the documentation to describe this distinction thus making the feature harder to comprehend IMHO and (ii) the parsing code needs to distinguish between these 2 cases
• consistency: the same syntax is used in both cases but the behaviour is different due to the use of a numeric variable after the equal sign
• unnecessary: the format specifier is needed because (i) the input text can contain a mixture of text and numeric values and (ii) hex numeric values can come with or without prefix, in lowercase or uppercase. It is thus necessary to indicate when something like "dead" is to be interpreted as a numeric value and when it shouldn't. There is not problem in a numeric substitution (whether one defined on the command line or in a check file) since there is no text in it and it is under control of the test writer which can add a prefix.

Therefore I strongly think anything after the equal sign is to be interpreted as a numeric expression and not an input. The distinction might appear clearer in the provision made by one of the later patch to support numeric subsitutions such as #%X,NUMVAL:<12 where the numeric expression value would be 12 and the input value could be 11 (input being B) and thus match.

I've added an example in the documentation to document that a literal is always intepreted as decimal in the absence of prefix (0x12 is allowed and interpreted as hex). Hopefully that'll alleviate some of your concern.

[thopre]

Address latest round of review comments

llvm/test/FileCheck/numeric-defines.txt

54

This is used when parsing the output of FileCheck to avoid things such as localization, see https://reviews.llvm.org/D65121 for more details

llvm/unittests/Support/FileCheckTest.cpp

46

valueFromStringRepr does not give an error in that case as it expects the value to match the format. This is because getAsInteger does not allow to check for the casing and I don't want to make the function more complex by checking it.

[jhenderson]

llvm/test/FileCheck/numeric-defines.txt

20–23

FWIW, I would find treating any number without 0x as hex to be ambiguous. I don't think the format specifier really should make a difference to that. After all, if you think of it in printf terms: printf("0x%x", 12) prints "0xc", not "0x12".

[jhenderson]

llvm/test/FileCheck/numeric-defines.txt

54

Got it, thanks!

llvm/unittests/Support/FileCheckTest.cpp

70

Have you considered using ASSERT_THAT_ERROR and EXPECT_THAT_ERROR in these tests?

[thopre]

llvm/test/FileCheck/numeric-defines.txt

20–23

@jhenderson I presume you were answering to Paul? Because FileCheck will indeed check the input file for 0xC when encountering CHECK: 0x[[#%X, 12]] so it's all good. As to the prefix, I supposed you meant for the literals inside the # syntax since prefix is not needed for printf/scanf: scanf("%X", x) will happily scan CAFE without expecting a prefix.

@probinson Since we are talking about parallels between variable definition and scanf on one side and numeric substitution and printf on the other side, we can look at the following examples:

• 0x[[#%X, VAR2:]] is equivalent to: scanf("%X", VAR2).
• 0x[[#%X, VAR1+12]] when VAR1 was defined with -D#VAR1=3 will be equivalent to checking the output of the following against the input file:

VAR1=3;
printf("0x%X", VAR1+12);

Note that C interprets 12 in decimal despite the %X format specifier of the printf which only influences the conversion of the resulting numeric value (3+12=15 is converted to F and thus the input file is checked for "0xF").

#SOMEVAR:<EXPR> is a shorthand for both, and thus a combination of printf+scanf with some input file check inbetween, e.g. 0x[[#%X, VAR2:VAR1+12]] when VAR1 is defined with -D#VAR1=3 is equivalent to checking the output of the following against the input file:

VAR1=3;
printf("0x%X", VAR1+12);

and scanning the matched input with:

scanf("0x%X", VAR2);

The case of #%X,VAR:12 is then just a special case, i.e. matching the input file against:

printf("%X", 12);

followed by scanning the matched text with:

scanf("%X", VAR);

[thopre]

Use EXPECT_THAT_ERROR when testing for an error in unittest

[jhenderson]

LGTM from me on this. I can't think of anything else I'd like addressing, but please wait for @arichardson and anybody else who wants to comment to be happy.

llvm/test/FileCheck/numeric-defines.txt

20–23

@thopre - I assume you meant @arichardson here, not @probinson...

I was responding to the general conversation, and giving my thoughts, so not addressing anybody specifically. Yes, the as-it-stands behaviour is what I would prefer, precisely for the reasons you outlined with the printf semantics.

[arichardson]

LGTM. Thanks for working on this feature!

llvm/lib/Support/FileCheck.cpp

333

Yes that seems perfectly fine.

llvm/test/FileCheck/numeric-defines.txt

20–23

@thopre Thanks for the detailed explanation. I think the current behaviour in the tests makes sense. Having the match format not affect the parsing of whats to the right of the = seems simpler and avoids problems.

[thopre]

My apologies but I still think there's changes needed on this patch. I had changed the status earlier but I presume updating the patch did reset the status to "needs review". I haven't covered all the API changes in the unittests and I'd like to address the comment from Paul about the lack of clarity of which variables have implicit format conflict. I'm happy to deal with the latter in a separate patch if people are eager to have this change (I'm personally looking forward to it being committed as well) but I want to at least finish the unit testing.

[thopre]

Complete unit testing of changes in the patch

[thopre]

Is everybody happy with the constness changes to the ExpressionFormat operators and the new unit tests?

[thopre]

llvm/test/FileCheck/numeric-expression.txt

340

Since this is already a sizable diff, I'd like to address this in a separate patch if you don't mind. It'll require recording more parsing state and I'm thinking about using a parser object for that and thus simplifying the interface of parsing functions (lots of info would be kept as internal state of the object).

[arichardson]

In D60389#1810018, @thopre wrote:

Is everybody happy with the constness changes to the ExpressionFormat operators and the new unit tests?

Looks fine to me. I would say say this can be committed if @jhenderson is happy with it and all tests pass. If there are any remaining issues those can always be fixed in follow-up commit.

llvm/lib/Support/FileCheckImpl.h

71

Since Kind is just an enum, the const is unnecessary for by-value arguments but I don't think it does any harm either.

[jhenderson]

No problem with the constness changes.

llvm/lib/Support/FileCheckImpl.h

71

It won't do any harm, I think, but it's inconsistent with style elsewhere, so I think it should be deleted (the const on the method is fine though of course).

llvm/unittests/Support/FileCheckTest.cpp

34

Nit: this comment isn't quite right. You probably wanted "methods' output", since its the output of the methods. However, I think a clearer phrase this and the similar comments to "Check unsgined decimal format methods", or possibly even "Check unsigned decimal format properties".

In fact, now that I think about it, perhaps it would make more sense for this test to be split into a separate TEST for each different format. The test name would then document what the test is for, and you wouldn't need the comment. You might even want to consider a parameterised test (see the TEST_P function), to avoid code duplication, for the Unsigned, HexLower and HexUpper cases.

37

ASSERT_THAT_EXPECTED(Wildcard, Succeeded());

Assert because otherwise the next line will crash if it fails, and the _THAT_EXPECTED macro for readability.

Same comment below.

Perhaps worth naming this UnsignedWildcard (HexLowerWildcard etc), and avoid reusing the variable in the other cases.

47–48

I've given this a bit more thought, and I think it would be better here and in similar situations with failing Expecteds to actually check the error contents. You can see examples of this in the DWARFDebugLineTest.cpp unit tests (look for the checkError function for a rough guide).

takeError on an Expected seems weird without first having checked that the Expected actually failed. You probably want EXPECT_THAT_EXPECTED(someFunctionThatReturnsAnExpected(), Failed()); if you aren't going to actually check the properties of the Error within the Expected.

82

Test "NoFormat" explicitly by passing it into the constructor and then consider a separate test to show that the default constructor generates a NoFormat kind.

Also NoneFormat -> NoFormat.

92

What about the other formats? Why is this here ratehr than in the individual test cases?

95

Self-comparison feels like a special case. You probably want to use a second format instance, I reckon.

104

Vs -> versus

320–321

This comment seems stale compared to what is being done below (i.e. it's not just about the eval() function it appears on the surface).

451

This '++' change, and the corresponding changes below, seem unrelated?

583–585

I've lost track. What's the difference between parsePatternExpect and parseSubstExpect? Why is it pattern, not subst here? Finally, what do these test cases have to do with formats?

707

does a check against "C" here make sense?

711

Does a check against "b" here make sense?

758

Debug printing left in by mistake?

933

ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
Same all over the place.

948–949

I know this isn't something directly related to your change, so it should be a later one, but you should also remove all uses of errorToBool in favour of checking the actual Error.

Sorry I didn't pick up on those in earlier reviews.

[thopre]

• Address unit tests review comments
• fix casing of first letter in an error message

[thopre]

llvm/unittests/Support/FileCheckTest.cpp

451

Indeed, made it into a separate patch: https://reviews.llvm.org/D72913

583–585

parsePatternExpect will call parsePattern which parse the rhs of a CHECK directive. parseSubstExpect calls parseNumericSubstitutionBlock which parses what's inside a # block. The use of parsePatternExpect is because I'm testing that legacy @LINE expression only accept what the old [[@LINE]] (without #) accepted before this patch set. The restriction for legacy @LINE expression is in parseNumericSubstitutionBlock and private functions it calls but the detection of a legacy @LINE expression is in parsePattern hence the use of parsePatternExpect.

The last of the 3 tests is format related because this patch also enables hex literals (I didn't want to make a separate patch for a few line diff). The other 2 should have been done in earlier patch. I've split these 2 into a separate patch: https://reviews.llvm.org/D72912

948–949

Done in https://reviews.llvm.org/D72914

[jhenderson]

llvm/unittests/Support/FileCheckTest.cpp

68–76

How about:

StringRef HexDigits = AllowUpperHex ? "ABCDEF" : "abcdef";
EXPECT_TRUE(WildcardRegex.match(HexDigits, &Matches));
EXPECT_EQ(Matches[0], HexDigits);

Remind me why we can't check the opposite cases are rejected here? That needs commenting at the very least.

Also, why is the check at line 70 ASSERT_TRUE, rather than EXPECT_TRUE?

94–105

I'd recommend the following, to reduce duplication of checks.

StringRef Ten;
StringRef Fifteen;
if (AllowHex) {
  if (AllowUpperHex) {
    Ten = "A";
    Fifteen = "F";
  } else {
    Ten = "a";
    Fifteen = "f";
  }
} else {
  Ten = "10";
  Fifteen = "15;
}
EXPECT_EQ(*TenMatchingString, Ten);
EXPECT_EQ(*FifteenMatchingString, Fifteen);

156

Formats -> Format

163

Probably worth a blank line to separate out the Conflict and NoFormat cases. Or just factor them into separate tests.

171

Formats -> Format

172

This comment is unnecessary - the test code is self-documenting.

177

Put a line break above the start of each case, i.e. at the start of each (set of) declaration(s). This will show which the cases more distinctly.

189

On further thought, consider replacing this comment with a new TEST, with the test naem documenting the test purpose.

320–321

, -> ;

641

format -> formats

645

format -> formats

686

What's the diference between this test case and the one above?

705

See comments in another review. Are this and the similar patterns below safe, if the Expected is in a success state?

948–951

Should this test the actual Error contents, like you do elsewhere?

965

Ditto.

[thopre]

Address all review comments

[thopre]

llvm/unittests/Support/FileCheckTest.cpp

68–76

It's an ASSERT because if the match fails it does not make sense checking Matches[0]. I've added negative testing, it's only for valueFromStringRepr that it is not possible (I've added a comment for that there).

705

With the latest previous patch yes.

[jhenderson]

Nearly there, from my point of view.

llvm/unittests/Support/FileCheckTest.cpp

94–105

This doesn't appear to have been done here, only in the bufferized bit below.

146–147

Spurious "to allow"?

[thopre]

Address unit tests review comments

llvm/unittests/Support/FileCheckTest.cpp

94–105

My bad, I don't know how I missed that.

[jhenderson]

LGTM.

@arichardson, do you have any more comments?

[arichardson]

Thanks! Looks good, just one minor typo in the documentation.

llvm/docs/CommandGuide/FileCheck.rst

596

accepted format specifiers

[thopre]

• Fix typo in doc
• remove sneaky literal for LineNumber in unit test

llvm/docs/CommandGuide/FileCheck.rst

.. option:: --enable-var-scope
 
   All other variables get undefined after each encountered ``CHECK-LABEL``.
 
 .. option:: -D<VAR=VALUE>
 
   Sets a filecheck pattern variable ``VAR`` with value ``VALUE`` that can be
   used in ``CHECK:`` lines.
 
-.. option:: -D#<NUMVAR>=<NUMERIC EXPRESSION>
+.. option:: -D#<FMT>,<NUMVAR>=<NUMERIC EXPRESSION>
 
-  Sets a filecheck numeric variable ``NUMVAR`` to the result of evaluating
-  ``<NUMERIC EXPRESSION>`` that can be used in ``CHECK:`` lines. See section
+  Sets a filecheck numeric variable ``NUMVAR`` of matching format ``FMT`` to
+  the result of evaluating ``<NUMERIC EXPRESSION>`` that can be used in
+  ``CHECK:`` lines.  See section
   ``FileCheck Numeric Variables and Expressions`` for details on supported
   numeric expressions.
 
 .. option:: -version
 
  Show the version number of this program.
 
 .. option:: -v

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 :program:`FileCheck` also supports numeric substitution blocks that allow
 defining numeric variables and checking for numeric values that satisfy a
 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 ``[[#<NUMVAR>:]]`` where
-``<NUMVAR>`` is the name of the numeric variable to define to the matching
+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``.
+
+* ``<NUMVAR>`` is the name of the numeric variable to define to the matching
   value.
 
 For example:
 
 .. code-block:: llvm
 
-    ; CHECK: mov r[[#REG:]], 42
+    ; CHECK: mov r[[#REG:]], 0x[[#%X,IMM:]]
+
+would match ``mov r5, 0xF0F0`` and set ``REG`` to the value ``5`` and ``IMM``
+to the value ``0xF0F0``.
 
-would match ``mov r5, 42`` and set ``REG`` to the value ``5``.
+The syntax of a numeric substitution is ``[[#%<fmtspec>,<expr>]]`` where:
 
-The syntax of a numeric substitution is ``[[#<expr>]]`` where ``<expr>`` is an
-expression. An expression is recursively defined as:
+* ``%<fmtspec>`` is the same matching format specifier as for defining numeric
+  variables but acting as a printf-style format to indicate how a numeric
+  expression value should be matched against.  If absent, the format specifier
+  is inferred from the matching format of the numeric variable(s) used by the
+  expression constraint if any, and defaults to ``%u`` if no numeric variable
+  is used.  In case of conflict between matching formats of several numeric
+  variables the format specifier is mandatory.
+
+* ``<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.
 
 For example:
 
 .. code-block:: llvm
 
     ; CHECK: load r[[#REG:]], [r0]
     ; CHECK: load r[[#REG+1]], [r1]
+    ; CHECK: Loading from 0x[[#%x,ADDR:] to 0x[[#ADDR + 7]]
 
 The above example would match the text:
 
 .. code-block:: gas
 
     load r5, [r0]
     load r6, [r1]
+    Loading from 0xa0463440 to 0xa0463447
 
 but would not match the text:
 
 .. code-block:: gas
 
     load r5, [r0]
     load r7, [r1]
+    Loading from 0xa0463440 to 0xa0463443
 
-due to ``7`` being unequal to ``5 + 1``.
+Due to ``7`` being unequal to ``5 + 1`` and ``a0463443`` being unequal to
+``a0463440 + 7``.
 
 The syntax also supports an empty expression, equivalent to writing {{[0-9]+}},
 for cases where the input must contain a numeric value but the value itself
 does not matter:
 
 .. code-block:: gas
 
     ; CHECK-NOT: mov r0, r[[#]]
 
 to check that a value is synthesized rather than moved around.
 
 A numeric variable can also be defined to the result of a numeric expression,
 in which case the numeric expression is checked and if verified the variable is
 assigned to the value. The unified syntax for both defining numeric variables
-and checking a numeric expression is thus ``[[#<NUMVAR>: <expr>]]`` with each
-element as described previously.
+and checking a numeric expression is thus ``[[#%<fmtspec>,<NUMVAR>: <expr>]]``
+with each element as described previously. One can use this syntax to make a
+testcase more self-describing by using variables instead of values:
+
+.. code-block:: gas
+
+    ; CHECK: mov r[[#REG_OFFSET:]], 0x[[#%X,FIELD_OFFSET:12]]
+    ; CHECK-NEXT: load r[[#]], [r[[#REG_BASE:]], r[[#REG_OFFSET]]]
+
+which would match:
+
+.. code-block:: gas
+
+    mov r4, 0xC
+    load r6, [r5, r4]
 
 The ``--enable-var-scope`` option has the same effect on numeric variables as
 on string variables.
 
 Important note: In its current implementation, an expression cannot use a
 numeric variable defined earlier in the same CHECK directive.
 
 FileCheck Pseudo Numeric Variables

llvm/lib/Support/FileCheck.cpp

 #include "llvm/Support/FormatVariadic.h"
 #include <cstdint>
 #include <list>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;
 
+Expected<StringRef> ExpressionFormat::getWildcardRegex() const {
+  switch (Value) {
+  case Kind::Unsigned:
+    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 {
+  switch (Value) {
+  case Kind::Unsigned:
+    return utostr(IntegerValue);
+  case Kind::HexUpper:
+    return utohexstr(IntegerValue, /*LowerCase=*/false);
+  case Kind::HexLower:
+    return utohexstr(IntegerValue, /*LowerCase=*/true);
+  default:
+    return createStringError(std::errc::invalid_argument,
+                             "trying to match value with invalid format");
+  }
+}
+
+Expected<uint64_t>
+ExpressionFormat::valueFromStringRepr(StringRef StrVal,
+                                      const SourceMgr &SM) const {
+  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");
+
+  return IntegerValue;
+}
+
 Expected<uint64_t> NumericVariableUse::eval() const {
   Optional<uint64_t> Value = Variable->getValue();
   if (Value)
     return *Value;
 
   return make_error<UndefVarError>(Name);
 }
 
 Expected<uint64_t> BinaryOperation::eval() const {
   Expected<uint64_t> LeftOp = LeftOperand->eval();
   Expected<uint64_t> 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);
 }
 
+ExpressionFormat BinaryOperation::getImplicitFormat() const {
+  ExpressionFormat LeftFormat = LeftOperand->getImplicitFormat();
+  ExpressionFormat RightFormat = RightOperand->getImplicitFormat();
+
+  ExpressionFormat Format =
+      LeftFormat != ExpressionFormat::Kind::NoFormat ? LeftFormat : RightFormat;
+  if (LeftFormat != ExpressionFormat::Kind::NoFormat &&
+      RightFormat != ExpressionFormat::Kind::NoFormat &&
+      LeftFormat != RightFormat)
+    Format = ExpressionFormat(ExpressionFormat::Kind::Conflict);
+
+  return Format;
+}
+
 Expected<std::string> NumericSubstitution::getResult() const {
-  Expected<uint64_t> EvaluatedValue = ExpressionASTPointer->eval();
+  assert(ExpressionPointer->getAST() != nullptr &&
+         "Substituting empty expression");
+  Expected<uint64_t> EvaluatedValue = ExpressionPointer->getAST()->eval();
   if (!EvaluatedValue)
     return EvaluatedValue.takeError();
-  return utostr(*EvaluatedValue);
+  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.
   Expected<StringRef> VarVal = Context->getPatternVarValue(FromStr);
   if (!VarVal)
     return VarVal.takeError();
   return Regex::escape(*VarVal);

 }
 
 // StringRef holding all characters considered as horizontal whitespaces by
 // FileCheck input canonicalization.
 constexpr StringLiteral SpaceChars = " \t";
 
 // 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 UndefVarError::ID = 0;
 char ErrorDiagnostic::ID = 0;
 char NotFoundError::ID = 0;
 
 Expected<NumericVariable *> Pattern::parseNumericVariableDefinition(
     StringRef &Expr, FileCheckPatternContext *Context,
-    Optional<size_t> LineNumber, const SourceMgr &SM) {
+    Optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
+    const SourceMgr &SM) {
   Expected<VariableProperties> ParseVarResult = parseVariable(Expr, SM);
   if (!ParseVarResult)
     return ParseVarResult.takeError();
   StringRef Name = ParseVarResult->Name;
 
   if (ParseVarResult->IsPseudo)
     return ErrorDiagnostic::get(
         SM, Name, "definition of pseudo numeric variable unsupported");
 
   // Detect collisions between string and numeric variables when the latter
   // is created later than the former.
   if (Context->DefinedVariableTable.find(Name) !=
       Context->DefinedVariableTable.end())
     return ErrorDiagnostic::get(
         SM, Name, "string variable with name '" + Name + "' already exists");
 
   Expr = Expr.ltrim(SpaceChars);
   if (!Expr.empty())
     return ErrorDiagnostic::get(
         SM, Expr, "unexpected characters after numeric variable name");
 
   NumericVariable *DefinedNumericVariable;
   auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
-  if (VarTableIter != Context->GlobalNumericVariableTable.end())
+  if (VarTableIter != Context->GlobalNumericVariableTable.end()) {
     DefinedNumericVariable = VarTableIter->second;
-  else
-    DefinedNumericVariable = Context->makeNumericVariable(Name, LineNumber);
+    if (DefinedNumericVariable->getImplicitFormat() != ImplicitFormat)
+      return ErrorDiagnostic::get(
+          SM, Expr, "format different from previous variable definition");
+  } else
+    DefinedNumericVariable =
+        Context->makeNumericVariable(Name, ImplicitFormat, LineNumber);
 
   return DefinedNumericVariable;
 }
 
 Expected<std::unique_ptr<NumericVariableUse>> Pattern::parseNumericVariableUse(
     StringRef Name, bool IsPseudo, Optional<size_t> LineNumber,
     FileCheckPatternContext *Context, const SourceMgr &SM) {
   if (IsPseudo && !Name.equals("@LINE"))
     return ErrorDiagnostic::get(
         SM, Name, "invalid pseudo numeric variable '" + Name + "'");
 
   // Numeric variable definitions and uses are parsed in the order in which
   // they appear in the CHECK patterns. For each definition, the pointer to the
   // class instance of the corresponding numeric variable definition is stored
   // in GlobalNumericVariableTable in parsePattern. Therefore, if the pointer
   // we get below is null, it means no such variable was defined before. When
   // that happens, we create a dummy variable so that parsing can continue. All
   // uses of undefined variables, whether string or numeric, are then diagnosed
   // in printSubstitutions() after failing to match.
   auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
   NumericVariable *NumericVariable;
   if (VarTableIter != Context->GlobalNumericVariableTable.end())
     NumericVariable = VarTableIter->second;
   else {
-    NumericVariable = Context->makeNumericVariable(Name);
+    NumericVariable = Context->makeNumericVariable(
+        Name, ExpressionFormat(ExpressionFormat::Kind::Unsigned));
     Context->GlobalNumericVariableTable[Name] = NumericVariable;
   }
 
   Optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();
   if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)
     return ErrorDiagnostic::get(
         SM, Name,
         "numeric variable '" + Name +
if (AO == AllowedOperand::LineVar || AO == AllowedOperand::Any) {
     if (AO == AllowedOperand::LineVar)
       return ParseVarResult.takeError();
     // Ignore the error and retry parsing as a literal.
     consumeError(ParseVarResult.takeError());
   }
 
   // Otherwise, parse it as a literal.
   uint64_t LiteralValue;
-  if (!Expr.consumeInteger(/*Radix=*/10, LiteralValue))
+  if (!Expr.consumeInteger((AO == AllowedOperand::LegacyLiteral) ? 10 : 0,
+                           LiteralValue))
     return std::make_unique<ExpressionLiteral>(LiteralValue);
 
   return ErrorDiagnostic::get(SM, Expr,
                               "invalid operand format '" + Expr + "'");
 }
 
 static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp + RightOp;
Pattern::parseBinop(StringRef &Expr, std::unique_ptr<ExpressionAST> LeftOp,
   }
 
   // Parse right operand.
   Expr = Expr.ltrim(SpaceChars);
   if (Expr.empty())
     return ErrorDiagnostic::get(SM, Expr, "missing operand in expression");
   // The second operand in a legacy @LINE expression is always a literal.
   AllowedOperand AO =
-      IsLegacyLineExpr ? AllowedOperand::Literal : AllowedOperand::Any;
+      IsLegacyLineExpr ? AllowedOperand::LegacyLiteral : AllowedOperand::Any;
   Expected<std::unique_ptr<ExpressionAST>> RightOpResult =
       parseNumericOperand(Expr, AO, LineNumber, Context, SM);
   if (!RightOpResult)
     return RightOpResult;
 
   Expr = Expr.ltrim(SpaceChars);
   return std::make_unique<BinaryOperation>(EvalBinop, std::move(LeftOp),
                                            std::move(*RightOpResult));
 }
 
-Expected<std::unique_ptr<ExpressionAST>> Pattern::parseNumericSubstitutionBlock(
+Expected<std::unique_ptr<Expression>> Pattern::parseNumericSubstitutionBlock(
     StringRef Expr, Optional<NumericVariable *> &DefinedNumericVariable,
     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
     FileCheckPatternContext *Context, const SourceMgr &SM) {
   std::unique_ptr<ExpressionAST> ExpressionASTPointer = nullptr;
   StringRef DefExpr = StringRef();
   DefinedNumericVariable = None;
+  ExpressionFormat ExplicitFormat = ExpressionFormat();
+
+  // Parse format specifier.
+  size_t FormatSpecEnd = Expr.find(',');
+  if (FormatSpecEnd != StringRef::npos) {
+    Expr = Expr.ltrim(SpaceChars);
+    if (!Expr.consume_front("%"))
+      return ErrorDiagnostic::get(
+          SM, Expr, "invalid matching format specification in expression");
+
+    // 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 'x':
+      ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::HexLower);
+      break;
+    case 'X':
+      ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::HexUpper);
+      break;
+    default:
+      return ErrorDiagnostic::get(SM, fmtloc,
+                                  "invalid format specifier in expression");
+    }
+
+    Expr = Expr.ltrim(SpaceChars);
+    if (!Expr.consume_front(","))
+      return ErrorDiagnostic::get(
+          SM, Expr, "invalid matching format specification in expression");
+  }
+
   // Save variable definition expression if any.
   size_t DefEnd = Expr.find(':');
   if (DefEnd != StringRef::npos) {
     DefExpr = Expr.substr(0, DefEnd);
     Expr = Expr.substr(DefEnd + 1);
   }
 
   // Parse the expression itself.
   Expr = Expr.ltrim(SpaceChars);
+  StringRef UseExpr = Expr;
   if (!Expr.empty()) {
     // The first operand in a legacy @LINE expression is always the @LINE
     // pseudo variable.
     AllowedOperand AO =
         IsLegacyLineExpr ? AllowedOperand::LineVar : AllowedOperand::Any;
     Expected<std::unique_ptr<ExpressionAST>> ParseResult =
         parseNumericOperand(Expr, AO, LineNumber, Context, SM);
     while (ParseResult && !Expr.empty()) {
       ParseResult = parseBinop(Expr, std::move(*ParseResult), IsLegacyLineExpr,
                                LineNumber, Context, SM);
       // Legacy @LINE expressions only allow 2 operands.
       if (ParseResult && IsLegacyLineExpr && !Expr.empty())
         return ErrorDiagnostic::get(
             SM, Expr,
             "unexpected characters at end of expression '" + Expr + "'");
     }
     if (!ParseResult)
-      return ParseResult;
+      return ParseResult.takeError();
     ExpressionASTPointer = std::move(*ParseResult);
   }
 
+  // Select format of the expression, i.e. (i) its explicit format, if any,
+  // otherwise (ii) its implicit format, if any, otherwise (iii) the default
+  // format (unsigned). Error out in case of conflicting implicit format
+  // without explicit format.
+  ExpressionFormat Format,
+      ImplicitFormat = ExpressionASTPointer
+                           ? ExpressionASTPointer->getImplicitFormat()
+                           : ExpressionFormat(ExpressionFormat::Kind::NoFormat);
+  if (bool(ExplicitFormat))
+    Format = ExplicitFormat;
+  else if (ImplicitFormat == ExpressionFormat::Kind::Conflict)
+    return ErrorDiagnostic::get(
+        SM, UseExpr,
+        "variables with conflicting format specifier: need an explicit one");
+  else if (bool(ImplicitFormat))
+    Format = ImplicitFormat;
+  else
+    Format = ExpressionFormat(ExpressionFormat::Kind::Unsigned);
+
+  std::unique_ptr<Expression> ExpressionPointer =
+      std::make_unique<Expression>(std::move(ExpressionASTPointer), Format);
+
   // Parse the numeric variable definition.
   if (DefEnd != StringRef::npos) {
     DefExpr = DefExpr.ltrim(SpaceChars);
-    Expected<NumericVariable *> ParseResult =
-        parseNumericVariableDefinition(DefExpr, Context, LineNumber, SM);
+    Expected<NumericVariable *> ParseResult = parseNumericVariableDefinition(
+        DefExpr, Context, LineNumber, ExpressionPointer->getFormat(), SM);
 
     if (!ParseResult)
       return ParseResult.takeError();
     DefinedNumericVariable = *ParseResult;
   }
 
-  return std::move(ExpressionASTPointer);
+  return std::move(ExpressionPointer);
 }
 
 bool Pattern::parsePattern(StringRef PatternStr, StringRef Prefix,
                            SourceMgr &SM, const FileCheckRequest &Req) {
   bool MatchFullLinesHere = Req.MatchFullLines && CheckTy != Check::CheckNot;
   IgnoreCase = Req.IgnoreCase;
 
   PatternLoc = SMLoc::getFromPointer(PatternStr.data());
if (PatternStr.startswith("[[")) {
             MatchStr = OrigMatchStr;
             IsLegacyLineExpr = IsNumBlock = true;
           } else
             SubstStr = Name;
         }
       }
 
       // Parse numeric substitution block.
-      std::unique_ptr<ExpressionAST> ExpressionASTPointer;
+      std::unique_ptr<Expression> ExpressionPointer;
       Optional<NumericVariable *> DefinedNumericVariable;
       if (IsNumBlock) {
-        Expected<std::unique_ptr<ExpressionAST>> ParseResult =
+        Expected<std::unique_ptr<Expression>> ParseResult =
             parseNumericSubstitutionBlock(MatchStr, DefinedNumericVariable,
                                           IsLegacyLineExpr, LineNumber, Context,
                                           SM);
         if (!ParseResult) {
           logAllUnhandledErrors(ParseResult.takeError(), errs());
           return true;
         }
-        ExpressionASTPointer = std::move(*ParseResult);
-        SubstNeeded = ExpressionASTPointer != nullptr;
+        ExpressionPointer = std::move(*ParseResult);
+        SubstNeeded = ExpressionPointer->getAST() != nullptr;
         if (DefinedNumericVariable) {
           IsDefinition = true;
           DefName = (*DefinedNumericVariable)->getName();
         }
         if (SubstNeeded)
           SubstStr = MatchStr;
-        else
-          MatchRegexp = "[0-9]+";
+        else {
+          ExpressionFormat Format = ExpressionPointer->getFormat();
+          MatchRegexp = cantFail(Format.getWildcardRegex());
+        }
       }
 
       // Handle variable definition: [[<def>:(...)]] and [[#(...)<def>:(...)]].
       if (IsDefinition) {
         RegExStr += '(';
         ++SubstInsertIdx;
 
         if (IsNumBlock) {
if (PatternStr.startswith("[[")) {
           }
           AddBackrefToRegEx(CaptureParenGroup);
         } else {
           // Handle substitution of string variables ([[<var>]]) defined in
           // previous CHECK patterns, and substitution of expressions.
           Substitution *Substitution =
               IsNumBlock
                   ? Context->makeNumericSubstitution(
-                        SubstStr, std::move(ExpressionASTPointer),
-                        SubstInsertIdx)
+                        SubstStr, std::move(ExpressionPointer), SubstInsertIdx)
                   : Context->makeStringSubstitution(SubstStr, SubstInsertIdx);
           Substitutions.push_back(Substitution);
         }
       }
     }
 
     // Handle fixed string matches.
     // Find the end, which is the start of the next regex.
for (const auto &NumericVariableDef : NumericVariableDefs) {
     const NumericVariableMatch &NumericVariableMatch =
         NumericVariableDef.getValue();
     unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;
     assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");
     NumericVariable *DefinedNumericVariable =
         NumericVariableMatch.DefinedNumericVariable;
 
     StringRef MatchedValue = MatchInfo[CaptureParenGroup];
-    uint64_t Val;
-    if (MatchedValue.getAsInteger(10, Val))
-      return ErrorDiagnostic::get(SM, MatchedValue,
-                                  "Unable to represent numeric value");
-    DefinedNumericVariable->setValue(Val);
+    ExpressionFormat Format = DefinedNumericVariable->getImplicitFormat();
+    Expected<uint64_t> 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.
   size_t MatchStartSkip = CheckTy == Check::CheckEmpty;
   MatchLen = FullMatch.size() - MatchStartSkip;
   return FullMatch.data() - Buffer.data() + MatchStartSkip;

 FileCheckPatternContext::makeStringSubstitution(StringRef VarName,
                                                 size_t InsertIdx) {
   Substitutions.push_back(
       std::make_unique<StringSubstitution>(this, VarName, InsertIdx));
   return Substitutions.back().get();
 }
 
 Substitution *FileCheckPatternContext::makeNumericSubstitution(
-    StringRef ExpressionStr,
-    std::unique_ptr<ExpressionAST> ExpressionASTPointer, size_t InsertIdx) {
+    StringRef ExpressionStr, std::unique_ptr<Expression> Expression,
+    size_t InsertIdx) {
   Substitutions.push_back(std::make_unique<NumericSubstitution>(
-      this, ExpressionStr, std::move(ExpressionASTPointer), InsertIdx));
+      this, ExpressionStr, std::move(Expression), InsertIdx));
   return Substitutions.back().get();
 }
 
 size_t Pattern::FindRegexVarEnd(StringRef Str, SourceMgr &SM) {
   // Offset keeps track of the current offset within the input Str
   size_t Offset = 0;
   // [...] Nesting depth
   size_t BracketDepth = 0;
FindFirstMatchingPrefix(Regex &PrefixRE, StringRef &Buffer,
 
   // We ran out of buffer while skipping partial matches so give up.
   return {StringRef(), StringRef()};
 }
 
 void FileCheckPatternContext::createLineVariable() {
   assert(!LineVariable && "@LINE pseudo numeric variable already created");
   StringRef LineName = "@LINE";
-  LineVariable = makeNumericVariable(LineName);
+  LineVariable = makeNumericVariable(
+      LineName, ExpressionFormat(ExpressionFormat::Kind::Unsigned));
   GlobalNumericVariableTable[LineName] = LineVariable;
 }
 
 FileCheck::FileCheck(FileCheckRequest Req)
     : Req(Req), PatternContext(std::make_unique<FileCheckPatternContext>()),
       CheckStrings(std::make_unique<std::vector<FileCheckString>>()) {}
 
 FileCheck::~FileCheck() = default;
for (std::pair<size_t, size_t> CmdlineDefIndices : CmdlineDefsIndices) {
     }
 
     // Numeric variable definition.
     if (CmdlineDef[0] == '#') {
       // Now parse the definition both to check that the syntax is correct and
       // to create the necessary class instance.
       StringRef CmdlineDefExpr = CmdlineDef.substr(1);
       Optional<NumericVariable *> DefinedNumericVariable;
-      Expected<std::unique_ptr<ExpressionAST>> ExpressionASTResult =
+      Expected<std::unique_ptr<Expression>> ExpressionResult =
           Pattern::parseNumericSubstitutionBlock(
               CmdlineDefExpr, DefinedNumericVariable, false, None, this, SM);
-      if (!ExpressionASTResult) {
-        Errs = joinErrors(std::move(Errs), ExpressionASTResult.takeError());
+      if (!ExpressionResult) {
+        Errs = joinErrors(std::move(Errs), ExpressionResult.takeError());
         continue;
       }
-      std::unique_ptr<ExpressionAST> ExpressionASTPointer =
-          std::move(*ExpressionASTResult);
+      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 = ExpressionASTPointer->eval();
+      Expected<uint64_t> 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.
 //===----------------------------------------------------------------------===//
 
+/// 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,
+    /// Used when there are several conflicting implicit formats in an
+    /// expression.
+    Conflict,
+    /// Value is an unsigned integer and should be printed as a decimal number.
+    Unsigned,
+    /// Value should be printed as an uppercase hex number.
+    HexUpper,
+    /// Value should be printed as a lowercase hex number.
+    HexLower
+  };
+
+private:
+  Kind Value;
+
+public:
+  /// Evaluates a format to true if it can be used in a match.
+  explicit operator bool() const {
+    return Value != Kind::NoFormat && Value != Kind::Conflict;
+  }
+
+  /// Define format equality: formats are equal if neither is NoFormat and
+  /// their kinds are the same.
+  bool operator==(const ExpressionFormat &Other) const {
+    return Value != Kind::NoFormat && Value == Other.Value;
+  }
+
+  bool operator!=(const ExpressionFormat &other) const {
+    return !(*this == other);
+  }
+
+  bool operator==(Kind OtherValue) const { return Value == OtherValue; }
+
+  bool operator!=(Kind OtherValue) const { return !(*this == OtherValue); }
+
+  ExpressionFormat() : Value(Kind::NoFormat){};
+  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 or Conflict.
+  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 or Conflict.
+  Expected<std::string> getMatchingString(uint64_t 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,
+                                         const SourceMgr &SM) const;
+};
+
 /// Base class representing the AST of a given expression.
 class ExpressionAST {
 public:
   virtual ~ExpressionAST() = default;
 
   /// 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;
+
+  /// \returns either the implicit format of this AST, FormatConflict 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 ExpressionFormat getImplicitFormat() 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;
 
public:
 
   /// Print name of variable associated with this error.
   void log(raw_ostream &OS) const override {
     OS << "\"";
     OS.write_escaped(VarName) << "\"";
   }
 };
 
+/// Class representing an expression and its matching format.
+class Expression {
+private:
+  /// Pointer to AST of the expression.
+  std::unique_ptr<ExpressionAST> AST;
+
+  /// Format to use (e.g. hex upper case letters) when matching the value.
+  ExpressionFormat Format;
+
+public:
+  /// Generic constructor for an expression represented by the given \p AST and
+  /// whose matching format is \p Format.
+  Expression(std::unique_ptr<ExpressionAST> AST, ExpressionFormat Format)
+      : AST(std::move(AST)), Format(Format) {}
+
+  /// \returns pointer to AST of the expression. Pointer is guaranteed to be
+  /// valid as long as this object is.
+  ExpressionAST *getAST() const { return AST.get(); }
+
+  ExpressionFormat getFormat() const { return Format; }
+};
+
 /// Class representing a numeric variable and its associated current value.
 class NumericVariable {
 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;
 
   /// 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 defined at line \p DefLineNumber or
-  /// defined before input is parsed if \p DefLineNumber is None.
-  explicit NumericVariable(StringRef Name,
+  /// 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), DefLineNumber(DefLineNumber) {}
+      : 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; }
 
   /// Sets value of this numeric variable to \p NewValue.
   void setValue(uint64_t NewValue) { Value = NewValue; }
 
   /// Clears value of this numeric variable, regardless of whether it is
   /// currently defined or not.
private:
   NumericVariable *Variable;
 
 public:
   NumericVariableUse(StringRef Name, NumericVariable *Variable)
       : Name(Name), Variable(Variable) {}
 
   /// \returns the value of the variable referenced by this instance.
   Expected<uint64_t> eval() const override;
+
+  /// \returns implicit format of this numeric variable.
+  ExpressionFormat getImplicitFormat() const override {
+    return Variable->getImplicitFormat();
+  }
 };
 
 /// Type of functions evaluating a given binary operation.
 using binop_eval_t = uint64_t (*)(uint64_t, uint64_t);
 
 /// Class representing a single binary operation in the AST of an expression.
 class BinaryOperation : public ExpressionAST {
 private:
BinaryOperation(binop_eval_t EvalBinop, std::unique_ptr<ExpressionAST> 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;
+
+  /// \returns the implicit format of this AST, if any, a format conflict 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).
+  ExpressionFormat getImplicitFormat() const override;
 };
 
 class FileCheckPatternContext;
 
 /// Class representing a substitution to perform in the RegExStr string.
 class Substitution {
 protected:
   /// Pointer to a class instance holding, among other things, the table with
public:
   /// when defined, or an error if the variable is undefined.
   Expected<std::string> getResult() const override;
 };
 
 class NumericSubstitution : public Substitution {
 private:
   /// Pointer to the class representing the expression whose value is to be
   /// substituted.
-  std::unique_ptr<ExpressionAST> ExpressionASTPointer;
+  std::unique_ptr<Expression> ExpressionPointer;
 
 public:
-  NumericSubstitution(FileCheckPatternContext *Context, StringRef Expr,
-                      std::unique_ptr<ExpressionAST> ExprAST, size_t InsertIdx)
-      : Substitution(Context, Expr, InsertIdx) {
-    ExpressionASTPointer = std::move(ExprAST);
-  }
+  NumericSubstitution(FileCheckPatternContext *Context, StringRef ExpressionStr,
+                      std::unique_ptr<Expression> ExpressionPointer,
+                      size_t InsertIdx)
+      : Substitution(Context, ExpressionStr, InsertIdx),
+        ExpressionPointer(std::move(ExpressionPointer)) {}
 
   /// \returns a string containing the result of evaluating the expression in
   /// this substitution, or an error if evaluation failed.
   Expected<std::string> getResult() const override;
 };
 
 //===----------------------------------------------------------------------===//
 // Pattern handling code.
private:
   /// Pointer to the class instance representing the @LINE pseudo variable for
   /// easily updating its value.
   NumericVariable *LineVariable = nullptr;
 
   /// Vector holding pointers to all parsed numeric variables. Used to
   /// automatically free them once they are guaranteed to no longer be used.
   std::vector<std::unique_ptr<NumericVariable>> NumericVariables;
 
+  /// Vector holding pointers to all parsed expressions. Used to automatically
+  /// free the expressions once they are guaranteed to no longer be used.
+  std::vector<std::unique_ptr<Expression>> Expressions;
+
   /// Vector holding pointers to all substitutions. Used to automatically free
   /// them once they are guaranteed to no longer be used.
   std::vector<std::unique_ptr<Substitution>> Substitutions;
 
 public:
   /// \returns the value of string variable \p VarName or an error if no such
   /// variable has been defined.
   Expected<StringRef> getPatternVarValue(StringRef VarName);
private:
   template <class... Types> NumericVariable *makeNumericVariable(Types... args);
 
   /// Makes a new string substitution and registers it for destruction when the
   /// context is destroyed.
   Substitution *makeStringSubstitution(StringRef VarName, size_t InsertIdx);
 
   /// Makes a new numeric substitution and registers it for destruction when
   /// the context is destroyed.
-  Substitution *
-  makeNumericSubstitution(StringRef ExpressionStr,
-                          std::unique_ptr<ExpressionAST> ExpressionAST,
+  Substitution *makeNumericSubstitution(StringRef ExpressionStr,
+                                        std::unique_ptr<Expression> Expression,
                                         size_t InsertIdx);
 };
 
 /// Class to represent an error holding a diagnostic with location information
 /// used when printing it.
 class ErrorDiagnostic : public ErrorInfo<ErrorDiagnostic> {
 private:
   SMDiagnostic Diagnostic;
 
class Pattern {
   /// VariableDefs will map "bar" to the third parenthesis group which captures
   /// the second definition of "bar".
   ///
   /// Note: uses std::map rather than StringMap to be able to get the key when
   /// iterating over values.
   std::map<StringRef, unsigned> VariableDefs;
 
   /// Structure representing the definition of a numeric variable in a pattern.
-  /// It holds the pointer to the class representing the numeric variable whose
-  /// value is being defined and the number of the parenthesis group in
-  /// RegExStr to capture that value.
+  /// It holds the pointer to the class instance holding the value and matching
+  /// format of the numeric variable whose value is being defined and the
+  /// number of the parenthesis group in RegExStr to capture that value.
   struct NumericVariableMatch {
-    /// Pointer to class representing the numeric variable whose value is being
-    /// defined.
+    /// Pointer to class instance holding the value and matching format of the
+    /// numeric variable being defined.
     NumericVariable *DefinedNumericVariable;
 
     /// Number of the parenthesis group in RegExStr that captures the value of
     /// this numeric variable definition.
     unsigned CaptureParenGroup;
   };
 
   /// Holds the number of the parenthesis group in RegExStr and pointer to the
public:
   /// \p Str from the variable name.
   static Expected<VariableProperties> parseVariable(StringRef &Str,
                                                     const SourceMgr &SM);
   /// Parses \p Expr for a numeric substitution block at line \p LineNumber,
   /// or before input is parsed if \p LineNumber is None. Parameter
   /// \p IsLegacyLineExpr indicates whether \p Expr should be a legacy @LINE
   /// expression and \p Context points to the class instance holding the live
   /// string and numeric variables. \returns a pointer to the class instance
-  /// representing the AST of the expression whose value must be substitued, or
-  /// an error holding a diagnostic against \p SM if parsing fails. If
-  /// substitution was successful, sets \p DefinedNumericVariable to point to
-  /// the class representing the numeric variable defined in this numeric
-  /// substitution block, or None if this block does not define any variable.
-  static Expected<std::unique_ptr<ExpressionAST>> parseNumericSubstitutionBlock(
+  /// representing the expression whose value must be substitued, or an error
+  /// holding a diagnostic against \p SM if parsing fails. If substitution was
+  /// successful, sets \p DefinedNumericVariable to point to the class
+  /// representing the numeric variable defined in this numeric substitution
+  /// block, or None if this block does not define any variable.
+  static Expected<std::unique_ptr<Expression>> parseNumericSubstitutionBlock(
       StringRef Expr, Optional<NumericVariable *> &DefinedNumericVariable,
       bool IsLegacyLineExpr, Optional<size_t> LineNumber,
       FileCheckPatternContext *Context, const SourceMgr &SM);
   /// Parses the pattern in \p PatternStr and initializes this Pattern instance
   /// accordingly.
   ///
   /// \p Prefix provides which prefix is being matched, \p Req describes the
   /// global options that influence the parsing such as whitespace
private:
 
   /// Parses \p Expr for the name of a numeric variable to be defined at line
   /// \p LineNumber, or before input is parsed if \p LineNumber is None.
   /// \returns a pointer to the class instance representing that variable,
   /// creating it if needed, or an error holding a diagnostic against \p SM
   /// should defining such a variable be invalid.
   static Expected<NumericVariable *> parseNumericVariableDefinition(
       StringRef &Expr, FileCheckPatternContext *Context,
-      Optional<size_t> LineNumber, const SourceMgr &SM);
+      Optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
+      const SourceMgr &SM);
   /// Parses \p Name as a (pseudo if \p IsPseudo is true) numeric variable use
   /// at line \p LineNumber, or before input is parsed if \p LineNumber is
   /// None. Parameter \p Context points to the class instance holding the live
   /// string and numeric variables. \returns the pointer to the class instance
   /// representing that variable if successful, or an error holding a
   /// diagnostic against \p SM otherwise.
   static Expected<std::unique_ptr<NumericVariableUse>> parseNumericVariableUse(
       StringRef Name, bool IsPseudo, Optional<size_t> LineNumber,
       FileCheckPatternContext *Context, const SourceMgr &SM);
-  enum class AllowedOperand { LineVar, Literal, Any };
+  enum class AllowedOperand { LineVar, LegacyLiteral, Any };
   /// Parses \p Expr for use of a numeric operand at line \p LineNumber, or
   /// before input is parsed if \p LineNumber is None. Accepts both literal
   /// values and numeric variables, depending on the value of \p AO. Parameter
   /// \p Context points to the class instance holding the live string and
   /// numeric variables. \returns the class representing that operand in the
   /// AST of the expression or an error holding a diagnostic against \p SM
   /// otherwise.
   static Expected<std::unique_ptr<ExpressionAST>>

llvm/test/FileCheck/line-count.txt

 57
 ; RUN: %ProtectFileCheckOutput \
 ; RUN: not FileCheck -check-prefix BAD12 -input-file %s %s 2>&1 \
 ; RUN:   | FileCheck -check-prefix ERR12 %s
 61
 62 BAD12: [[#@LINE-1]] NOT HERE
 63 ERR12: note: with "@LINE-1" equal to "61"
 64
-65 CHECK: [[#@LINE]] CHECK
-66 CHECK: [[# @LINE]] CHECK
-67 CHECK: [[# @LINE ]] CHECK
+; RUN: %ProtectFileCheckOutput \
+; RUN: not FileCheck --check-prefix BAD13 --input-file %s %s 2>&1 \
+; RUN:   | FileCheck --check-prefix ERR13 %s
 68
-69 CHECK: [[#@LINE-1]]
-70 CHECK: [[# @LINE-1]] CHECK
-71 CHECK: [[# @LINE -1]] CHECK
-72 CHECK: [[# @LINE - 1]] CHECK
-73 CHECK: [[# @LINE - 1 ]] CHECK
+69 BAD13: [[@LINE-0xA]]
+70 ERR13: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of expression 'xA'
+71
+72 CHECK: [[#@LINE]] CHECK
+73 CHECK: [[# @LINE]] CHECK
+74 CHECK: [[# @LINE ]] CHECK
+75
+76 CHECK: [[#@LINE-1]]
+77 CHECK: [[# @LINE-1]] CHECK
+78 CHECK: [[# @LINE -1]] CHECK
+79 CHECK: [[# @LINE - 1]] CHECK
+80 CHECK: [[# @LINE - 1 ]] CHECK

llvm/test/FileCheck/numeric-defines-diagnostics.txt

 ; Test incorrect syntax for -D# option is correctly diagnosed.
 
 ; Invalid variable name: starts with a digit.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#10VALUE=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLIFMT
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLINAME
 
-NUMERRCLIFMT:Global defines:1:46: error: invalid variable name
-NUMERRCLIFMT-NEXT:Global define #1: #10VALUE=10 (parsed as: {{\[\[#10VALUE:10\]\]}})
-    NUMERRCLIFMT-NEXT:                                             ^
+NUMERRCLINAME:Global defines:1:46: error: invalid variable name
+NUMERRCLINAME-NEXT:Global define #1: #10VALUE=10 (parsed as: {{\[\[#10VALUE:10\]\]}})
+    NUMERRCLINAME-NEXT:                                             ^
 
 ; Invalid definition of pseudo variable.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#@VALUE=10 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLIPSEUDO
 
 NUMERRCLIPSEUDO:Global defines:1:45: error: definition of pseudo numeric variable unsupported
 NUMERRCLIPSEUDO-NEXT:Global define #1: #@VALUE=10 (parsed as: {{\[\[#@VALUE:10\]\]}})
     NUMERRCLIPSEUDO-NEXT:                                            ^
 
 ; Invalid definition of an expression.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D#VALUE+2=10 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLITRAIL
 
 NUMERRCLITRAIL:Global defines:1:51: error: unexpected characters after numeric variable name
 NUMERRCLITRAIL-NEXT:Global define #1: #VALUE+2=10 (parsed as: {{\[\[#VALUE\+2:10\]\]}})
      NUMERRCLITRAIL-NEXT:                                                  ^
+
+; Invalid format for variable.
+RUN: not FileCheck -D#,VALUE=10 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix NUMERRCLIFMT
+
+NUMERRCLIFMT:Global defines:1:45: error: invalid matching format specification in expression
+NUMERRCLIFMT-NEXT:Global define #1: #,VALUE=10 (parsed as: {{\[\[#,VALUE:10\]\]}})
+    NUMERRCLIFMT-NEXT:                                            ^

llvm/test/FileCheck/numeric-defines.txt

 ; Test functionality of -D# option: numeric variables are defined to the right
 ; value and CHECK directives using them match as expected given the value set.
 
-RUN: FileCheck -D#NUMVAL1=8 -D#NUMVAL2='NUMVAL1 + 4' -check-prefixes CHECKNUM1,CHECKNUM2 -input-file %s %s
+; Tests with default format specifier.
+RUN: FileCheck -D#NUMVAL1=8 -D#NUMVAL2='NUMVAL1 + 4' --check-prefixes CHECKNUM1,CHECKNUM2 --input-file %s %s
 
 RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -D#NUMVAL1=7 -D#NUMVAL2=12 -check-prefix CHECKNUM1 -input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRMSG1
+RUN: not FileCheck -D#NUMVAL1=7 -D#NUMVAL2=12 --check-prefix CHECKNUM1 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRMSG1
 
 RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -D#NUMVAL1=8 -D#NUMVAL2=8 -check-prefix CHECKNUM2 -input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRMSG2
+RUN: not FileCheck -D#NUMVAL1=8 -D#NUMVAL2=8 --check-prefix CHECKNUM2 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRMSG2
 
 RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -D#NUMVAL1=8 -D#NUMVAL2=8 -check-prefix NUMNOT -input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace -check-prefixes NOT-NUMERRMSG1
+RUN: not FileCheck -D#NUMVAL1=8 -D#NUMVAL2=8 --check-prefix NUMNOT1 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NOT-NUMERRMSG1
 
 RUN: %ProtectFileCheckOutput \
-RUN: not FileCheck -D#NUMVAL1=7 -D#NUMVAL2=12 -check-prefix NUMNOT -input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace -check-prefixes NOT-NUMERRMSG2
-RUN: FileCheck -D#NUMVAL1=7 -D#NUMVAL2=8 -check-prefixes NUMNOT -input-file %s %s
+RUN: not FileCheck -D#NUMVAL1=7 -D#NUMVAL2=12 --check-prefix NUMNOT1 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NOT-NUMERRMSG2
+
+RUN: FileCheck -D#NUMVAL1=7 -D#NUMVAL2=8 --check-prefix NUMNOT1 --input-file %s %s
 
 Numeric value #1 = 8
 Numeric value #2 = 12
 CHECKNUM1: Numeric value #1 = [[#NUMVAL1]]
 CHECKNUM2: Numeric value #2 = [[#NUMVAL2]]
-NUMNOT-NOT: Numeric value #1 = [[#NUMVAL1]]
-NUMNOT-NOT: Numeric value #2 = [[#NUMVAL2]]
+NUMNOT1-NOT: Numeric value #1 = [[#NUMVAL1]]
+NUMNOT1-NOT: Numeric value #2 = [[#NUMVAL2]]
 
 NUMERRMSG1: defines.txt:[[#@LINE-5]]:12: error: CHECKNUM1: expected string not found in input
 NUMERRMSG1: defines.txt:1:1: note: scanning from here
 NUMERRMSG1: defines.txt:1:1: note: with "NUMVAL1" equal to "7"
 NUMERRMSG1: defines.txt:[[#@LINE-10]]:1: note: possible intended match here
 
 NUMERRMSG2: defines.txt:[[#@LINE-9]]:12: error: CHECKNUM2: expected string not found in input
 NUMERRMSG2: defines.txt:1:1: note: scanning from here
 NUMERRMSG2: defines.txt:1:1: note: with "NUMVAL2" equal to "8"
 NUMERRMSG2: defines.txt:[[#@LINE-14]]:1: note: possible intended match here
 
-NOT-NUMERRMSG1: defines.txt:[[#@LINE-13]]:13: error: {{NUMNOT}}-NOT: excluded string found in input
+NOT-NUMERRMSG1: defines.txt:[[#@LINE-13]]:14: error: {{NUMNOT1}}-NOT: excluded string found in input
 NOT-NUMERRMSG1: defines.txt:[[#@LINE-18]]:1: note: found here
 NOT-NUMERRMSG1: defines.txt:[[#@LINE-19]]:1: note: with "NUMVAL1" equal to "8"
 
-NOT-NUMERRMSG2: defines.txt:[[#@LINE-16]]:13: error: {{NUMNOT}}-NOT: excluded string found in input
+NOT-NUMERRMSG2: defines.txt:[[#@LINE-16]]:14: error: {{NUMNOT1}}-NOT: excluded string found in input
 NOT-NUMERRMSG2: defines.txt:[[#@LINE-21]]:1: note: found here
 NOT-NUMERRMSG2: defines.txt:[[#@LINE-22]]:1: note: with "NUMVAL2" equal to "12"
+
+; Tests with explicit format specifiers.
+RUN: FileCheck -D#%X,NUMVAL3=8 -D#%X,NUMVAL4='NUMVAL3 + 4' --check-prefixes CHECKNUM3,CHECKNUM4 --input-file %s %s
+
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck -D#%X,NUMVAL3=7 -D#%X,NUMVAL4=12 --check-prefix CHECKNUM3 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRMSG3
+
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck -D#%X,NUMVAL3=8 -D#%X,NUMVAL4=8 --check-prefix CHECKNUM4 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NUMERRMSG4
+
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck -D#%X,NUMVAL3=8 -D#%X,NUMVAL4=8 --check-prefix NUMNOT2 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NOT-NUMERRMSG3
+
+RUN: %ProtectFileCheckOutput \
+RUN: not FileCheck -D#%X,NUMVAL3=7 -D#%X,NUMVAL4=12 --check-prefix NUMNOT2 --input-file %s %s 2>&1 \
+RUN:   | FileCheck %s --strict-whitespace --check-prefix NOT-NUMERRMSG4
+
+RUN: FileCheck -D#%X,NUMVAL3=7 -D#%X,NUMVAL4=8 --check-prefix NUMNOT2 --input-file %s %s
+
+; Test with explicit and default format specifiers.
+RUN: FileCheck -D#NUMVAL3=8 -D#%X,NUMVAL4='NUMVAL3 + 4' --check-prefixes CHECKNUM3,CHECKNUM4 --input-file %s %s
+; Test with explicit and implicit format specifiers.
+RUN: FileCheck -D#%X,NUMVAL3=8 -D#NUMVAL4='NUMVAL3 + 4' --check-prefixes CHECKNUM3,CHECKNUM4 --input-file %s %s
+
+Numeric value #3 = 8
+Numeric value #4 = C
+CHECKNUM3: Numeric value #3 = [[#NUMVAL3]]
+CHECKNUM4: Numeric value #4 = [[#NUMVAL4]]
+NUMNOT2-NOT: Numeric value #3 = [[#NUMVAL3]]
+NUMNOT2-NOT: Numeric value #4 = [[#NUMVAL4]]
+
+NUMERRMSG3: defines.txt:[[#@LINE-5]]:12: error: CHECKNUM3: expected string not found in input
+NUMERRMSG3: defines.txt:1:1: note: scanning from here
+NUMERRMSG3: defines.txt:1:1: note: with "NUMVAL3" equal to "7"
+NUMERRMSG3: defines.txt:[[#@LINE-10]]:1: note: possible intended match here
+
+NUMERRMSG4: defines.txt:[[#@LINE-9]]:12: error: CHECKNUM4: expected string not found in input
+NUMERRMSG4: defines.txt:1:1: note: scanning from here
+NUMERRMSG4: defines.txt:1:1: note: with "NUMVAL4" equal to "8"
+NUMERRMSG4: defines.txt:[[#@LINE-14]]:1: note: possible intended match here
+
+NOT-NUMERRMSG3: defines.txt:[[#@LINE-13]]:14: error: {{NUMNOT2}}-NOT: excluded string found in input
+NOT-NUMERRMSG3: defines.txt:[[#@LINE-18]]:1: note: found here
+NOT-NUMERRMSG3: defines.txt:[[#@LINE-19]]:1: note: with "NUMVAL3" equal to "8"
+
+NOT-NUMERRMSG4: defines.txt:[[#@LINE-16]]:14: error: {{NUMNOT2}}-NOT: excluded string found in input
+NOT-NUMERRMSG4: defines.txt:[[#@LINE-21]]:1: note: found here
+NOT-NUMERRMSG4: defines.txt:[[#@LINE-22]]:1: note: with "NUMVAL4" equal to "C"

llvm/test/FileCheck/numeric-expression.txt

 RUN: FileCheck --input-file %s %s
 
 ; We use CHECK-NEXT directives to force a match on all lines with digits.
 
-; Numeric variable definition without spaces.
-DEF NO SPC
+; Numeric variable definition with default matching format without spaces.
+DEF DEFAULT FMT NO SPC
 10
-CHECK-LABEL: DEF NO SPC
+CHECK-LABEL: DEF DEFAULT FMT NO SPC
 CHECK-NEXT: [[#VAR1:]]
 
-; Numeric variable definition with different spacing.
-DEF SPC
+; Numeric variable definition with default matching format with different
+; spacing.
+DEF DEFAULT FMT SPC
 11
 11
 11
-CHECK-LABEL: DEF SPC
+CHECK-LABEL: DEF DEFAULT FMT SPC
 CHECK-NEXT: [[# VAR1a:]]
 CHECK-NEXT: [[# VAR1b :]]
 CHECK-NEXT: [[# VAR1c : ]]
 
 ; Numeric variable redefinition.
 REDEF NO SPC
 11
 CHECK-LABEL: REDEF
 CHECK-NEXT: [[#VAR1:]]
 
-; Numeric expressions using variables defined on other lines without spaces.
-USE NO SPC
+; Numeric variable definition with explicit matching format.
+DEF FMT
+c
+D
+CHECK-LABEL: DEF FMT
+CHECK-NEXT: [[#%x,VAR2:]]
+CHECK-NEXT: [[#%X,VAR3:]]
+
+; 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: 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: 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
 12
 10
+c
+d
+b
+1a
+D
+E
+C
+1B
 11
 11
 11
-CHECK-LABEL: USE
-CHECK-NEXT: [[#VAR1]]
-CHECK-NEXT: [[#VAR1+1]]
-CHECK-NEXT: [[#VAR1-1]]
-CHECK-NEXT: [[#VAR1a]]
-CHECK-NEXT: [[#VAR1b]]
-CHECK-NEXT: [[#VAR1c]]
-
-; Numeric expressions using variables defined on other lines with different
-; spacing.
-USE SPC
+c
+c
+c
+c
+c
+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+14]]
+CHECK-NEXT: [[#%X,VAR3]]
+CHECK-NEXT: [[#%X,VAR3+1]]
+CHECK-NEXT: [[#%X,VAR3-1]]
+CHECK-NEXT: [[#%X,VAR3+14]]
+CHECK-NEXT: [[#%u,VAR1a]]
+CHECK-NEXT: [[#%u,VAR1b]]
+CHECK-NEXT: [[#%u,VAR1c]]
+CHECK-NEXT: [[#%x,VAR2a]]
+
+; Numeric expressions in explicit matching format and default matching rule using
+; variables defined on other lines with different spacing.
+USE EXPL FMT IMPL MATCH SPC
+11
 11
 11
 12
 12
 12
 12
+12
+12
 10
 10
 10
 10
-CHECK-LABEL: USE SPC
-CHECK-NEXT: [[# VAR1]]
-CHECK-NEXT: [[# VAR1 ]]
-CHECK-NEXT: [[# VAR1+1]]
-CHECK-NEXT: [[# VAR1 +1]]
-CHECK-NEXT: [[# VAR1 + 1]]
-CHECK-NEXT: [[# VAR1 + 1 ]]
-CHECK-NEXT: [[# VAR1-1]]
-CHECK-NEXT: [[# VAR1 -1]]
-CHECK-NEXT: [[# VAR1 - 1]]
-CHECK-NEXT: [[# VAR1 - 1 ]]
+10
+10
+CHECK-LABEL: USE EXPL FMT IMPL MATCH SPC
+CHECK-NEXT: [[#%u, VAR1]]
+CHECK-NEXT: [[# %u, VAR1]]
+CHECK-NEXT: [[# %u, VAR1 ]]
+CHECK-NEXT: [[#%u, VAR1+1]]
+CHECK-NEXT: [[# %u, VAR1+1]]
+CHECK-NEXT: [[# %u , VAR1+1]]
+CHECK-NEXT: [[# %u , VAR1 +1]]
+CHECK-NEXT: [[# %u , VAR1 + 1]]
+CHECK-NEXT: [[# %u , VAR1 + 1 ]]
+CHECK-NEXT: [[#%u, VAR1-1]]
+CHECK-NEXT: [[# %u, VAR1-1]]
+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
+12
+10
+c
+d
+b
+1a
+D
+E
+C
+1B
+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+14]]
+CHECK-NEXT: [[#VAR3]]
+CHECK-NEXT: [[#VAR3+1]]
+CHECK-NEXT: [[#VAR3-1]]
+CHECK-NEXT: [[#VAR3+14]]
 
 ; Numeric expressions using variables defined on other lines and an immediate
 ; interpreted as an unsigned value.
 ; Note: 9223372036854775819 = 0x8000000000000000 + 11
-;       9223372036854775808 = 0x8000000000000000
-USE UNSIGNED IMM
+USE IMPL FMT IMPL MATCH UNSIGNED IMM
 9223372036854775819
-CHECK-LABEL: USE UNSIGNED IMM
-CHECK-NEXT: [[#VAR1+9223372036854775808]]
+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
+B
+12
+13
+CHECK-LABEL: USE CONV FMT IMPL MATCH
+CHECK-NEXT: [[# %x, VAR1]]
+CHECK-NEXT: [[# %X, VAR1]]
+CHECK-NEXT: [[# %u, VAR2]]
+CHECK-NEXT: [[# %u, VAR3]]
+
+; Conflicting implicit format.
+RUN: not FileCheck --check-prefixes CHECK,FMT-CONFLICT --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefix FMT-CONFLICT-MSG %s
+
+VAR USE IMPL FMT CONFLICT
+23
+FMT-CONFLICT-LABEL: VAR USE IMPL FMT CONFLICT
+FMT-CONFLICT-NEXT: [[#VAR1 + VAR2]]
+FMT-CONFLICT-MSG: numeric-expression.txt:[[#@LINE-1]]:23: error: variables with conflicting format specifier: need an explicit one
+FMT-CONFLICT-MSG-NEXT: {{F}}MT-CONFLICT-NEXT: {{\[\[#VAR1 \+ VAR2\]\]}}
+FMT-CONFLICT-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: [[#VAR2:]]
-CHECK-NEXT: [[#VAR1+VAR2]]
+CHECK-NEXT: [[#VAR4:]]
+CHECK-NEXT: [[#VAR1+VAR4]]
 
 ; 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]]
 
 ; Empty numeric expression.
 EMPTY NUM EXPR
 foo 104 bar
-; CHECK-LABEL: EMPTY NUM EXPR
-; CHECK-NEXT: foo [[#]] bar
+CHECK-LABEL: EMPTY NUM EXPR
+CHECK-NEXT: foo [[#]] bar
 
 ; Numeric expression using undefined variables.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix UNDEF-USE --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix UNDEF-USE-MSG %s
 
 UNDEF VAR USE
 UNDEFVAR: 11

 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix BIGVAL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix BIGVAL-MSG %s
 
 BIG VALUE
 NUMVAR: 10000000000000000000000
 BIGVAL-LABEL: BIG VALUE
 BIGVAL-NEXT: NUMVAR: [[#NUMVAR:]]
-BIGVAL-MSG: numeric-expression.txt:[[#@LINE-3]]:9: error: Unable to represent numeric value
+BIGVAL-MSG: numeric-expression.txt:[[#@LINE-3]]:9: error: unable to represent numeric value
  BIGVAL-MSG-NEXT: {{N}}UMVAR: 10000000000000000000000
 BIGVAL-MSG-NEXT: {{^}}        ^{{$}}
 
 ; Verify that when a variable is set to an expression the expression is still
 ; checked.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix DEF-EXPR-FAIL --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix DEF-EXPR-FAIL-MSG %s
 
 DEF EXPR WRONG MATCH
 20
 43
 DEF-EXPR-FAIL-LABEL: DEF EXPR WRONG MATCH
 DEF-EXPR-FAIL-NEXT: [[# VAR20:]]
 DEF-EXPR-FAIL-NEXT: [[# VAR42: VAR20+22]]
 DEF-EXPR-FAIL-MSG: numeric-expression.txt:[[#@LINE-1]]:21: error: {{D}}EF-EXPR-FAIL-NEXT: is not on the line after the previous match
 DEF-EXPR-FAIL-MSG-NEXT: {{D}}EF-EXPR-FAIL-NEXT: {{\[\[# VAR42: VAR20\+22\]\]}}
 DEF-EXPR-FAIL-MSG-NEXT:   {{^}}                    ^{{$}}
 
 ; Verify that using a numeric variable defined on the same line (whether from
 ; input or from an expression) is rejected.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix SAME-LINE-USE1 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix SAME-LINE-USE-MSG1 %s
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck --check-prefix SAME-LINE-USE2 --input-file %s %s 2>&1 \
 RUN:   | FileCheck --strict-whitespace --check-prefix SAME-LINE-USE-MSG2 %s
 
 SAME LINE USE
 3
 4 5
 SAME-LINE-USE1-LABEL: SAME LINE USE
 SAME-LINE-USE1-NEXT: [[#]]
 SAME-LINE-USE1-NEXT: [[#VAR1:]] [[#VAR1+1]]
 SAME-LINE-USE-MSG1: numeric-expression.txt:[[#@LINE-1]]:36: error: numeric variable 'VAR1' defined earlier in the same CHECK directive
 SAME-LINE-USE-MSG1-NEXT: {{S}}AME-LINE-USE1-NEXT: {{\[\[#VAR1:\]\] \[\[#VAR1\+1\]\]}}
 SAME-LINE-USE-MSG1-NEXT:        {{^}}                                   ^{{$}}
 
 SAME-LINE-USE2-LABEL: SAME LINE USE
 SAME-LINE-USE2-NEXT: [[#VAR1:]]
 SAME-LINE-USE2-NEXT: [[#VAR2:VAR1+1]] [[#VAR2+1]]
 SAME-LINE-USE-MSG2: numeric-expression.txt:[[#@LINE-1]]:42: error: numeric variable 'VAR2' defined earlier in the same CHECK directive
 SAME-LINE-USE-MSG2-NEXT: {{S}}AME-LINE-USE2-NEXT: {{\[\[#VAR2:VAR1\+1\]\] \[\[#VAR2\+1\]\]}}
 SAME-LINE-USE-MSG2-NEXT:        {{^}}                                         ^{{$}}
+
+; Invalid change of format in variable redefinition.
+RUN: not FileCheck --check-prefix REDEF-NEW-FMT --input-file %s %s 2>&1 \
+RUN:   | FileCheck --strict-whitespace --check-prefix REDEF-NEW-FMT-MSG %s
+
+VAR REDEF FMT CHANGE
+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: {{^                              \^$}}

llvm/test/FileCheck/string-defines-diagnostics.txt

 RUN: %ProtectFileCheckOutput not FileCheck -D= --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --check-prefix ERRCLIVAR2
 
 ERRCLIVAR2: Missing variable name in command-line definition '-D='
 
 ; Invalid variable name: starts with a digit.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D10VALUE=10 --input-file %s %s 2>&1 \
-RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ERRCLIFMT
+RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ERRCLINAME
 
-ERRCLIFMT:Global defines:1:19: error: invalid variable name
-ERRCLIFMT-NEXT:Global define #1: 10VALUE=10
-ERRCLIFMT-NEXT:                  ^
+ERRCLINAME:Global defines:1:19: error: invalid variable name
+ERRCLINAME-NEXT:Global define #1: 10VALUE=10
+ERRCLINAME-NEXT:                  ^
 
 ; Invalid definition of pseudo variable.
 RUN: %ProtectFileCheckOutput \
 RUN: not FileCheck -D@VALUE=10 --input-file %s %s 2>&1 \
 RUN:   | FileCheck %s --strict-whitespace --match-full-lines --check-prefix ERRCLIPSEUDO
 
 ERRCLIPSEUDO:Global defines:1:19: error: invalid name in string variable definition '@VALUE'
 ERRCLIPSEUDO-NEXT:Global define #1: @VALUE=10

llvm/unittests/Support/FileCheckTest.cpp

 //===- llvm/unittest/Support/FileCheckTest.cpp - FileCheck tests --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/FileCheck.h"
 #include "../lib/Support/FileCheckImpl.h"
+#include "llvm/Support/Regex.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
+#include <tuple>
 #include <unordered_set>
 
 using namespace llvm;
 
 namespace {
 
 class FileCheckTest : public ::testing::Test {};
 
+static StringRef bufferize(SourceMgr &SM, StringRef Str) {
+  std::unique_ptr<MemoryBuffer> Buffer =
+      MemoryBuffer::getMemBufferCopy(Str, "TestBuffer");
+  StringRef StrBufferRef = Buffer->getBuffer();
+  SM.AddNewSourceBuffer(std::move(Buffer), SMLoc());
+  return StrBufferRef;
+}
+
+template <typename ErrorT>
+static void expectError(StringRef ExpectedMsg, Error Err) {
+  bool ErrorHandled = false;
+  EXPECT_THAT_ERROR(handleErrors(std::move(Err),
+                                 [&](const ErrorT &E) {
+                                   EXPECT_NE(
+                                       E.message().find(ExpectedMsg.str()),
+                                       std::string::npos);
+                                   ErrorHandled = true;
+                                 }),
+                    Succeeded());
+  EXPECT_TRUE(ErrorHandled);
+}
+
+static void expectDiagnosticError(StringRef ExpectedMsg, Error Err) {
+  expectError<ErrorDiagnostic>(ExpectedMsg, std::move(Err));
+}
+
+struct ExpressionFormatParameterisedFixture
+    : public ::testing::TestWithParam<
+          std::tuple<ExpressionFormat::Kind, bool, bool>> {
+  void SetUp() { std::tie(Kind, AllowHex, AllowUpperHex) = GetParam(); }
+
+  ExpressionFormat::Kind Kind;
+  bool AllowHex;
+  bool AllowUpperHex;
+};
+
+TEST_P(ExpressionFormatParameterisedFixture, Format) {
+  SourceMgr SM;
+  ExpressionFormat Format(Kind);
+
+  Expected<StringRef> WildcardPattern = Format.getWildcardRegex();
+  ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded());
+  Regex WildcardRegex(*WildcardPattern);
+  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);
+  // 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);
+  ASSERT_THAT_EXPECTED(MatchingString, Succeeded());
+  EXPECT_EQ(*MatchingString, "0");
+  MatchingString = Format.getMatchingString(9U);
+  ASSERT_THAT_EXPECTED(MatchingString, Succeeded());
+  EXPECT_EQ(*MatchingString, "9");
+  Expected<std::string> TenMatchingString = Format.getMatchingString(10U);
+  ASSERT_THAT_EXPECTED(TenMatchingString, Succeeded());
+  Expected<std::string> FifteenMatchingString = Format.getMatchingString(15U);
+  ASSERT_THAT_EXPECTED(FifteenMatchingString, Succeeded());
+  StringRef ExpectedTenMatchingString, ExpectedFifteenMatchingString;
+  if (AllowHex) {
+    if (AllowUpperHex) {
+      ExpectedTenMatchingString = "A";
+      ExpectedFifteenMatchingString = "F";
+    } else {
+      ExpectedTenMatchingString = "a";
+      ExpectedFifteenMatchingString = "f";
+    }
+  } else {
+    ExpectedTenMatchingString = "10";
+    ExpectedFifteenMatchingString = "15";
+  }
+  EXPECT_EQ(*TenMatchingString, ExpectedTenMatchingString);
+  EXPECT_EQ(*FifteenMatchingString, ExpectedFifteenMatchingString);
+
+  StringRef BufferizedValidValueStr = bufferize(SM, "0");
+  Expected<uint64_t> Val =
+      Format.valueFromStringRepr(BufferizedValidValueStr, SM);
+  ASSERT_THAT_EXPECTED(Val, Succeeded());
+  EXPECT_EQ(*Val, 0U);
+  BufferizedValidValueStr = bufferize(SM, "9");
+  Val = Format.valueFromStringRepr(BufferizedValidValueStr, SM);
+  ASSERT_THAT_EXPECTED(Val, Succeeded());
+  EXPECT_EQ(*Val, 9U);
+  StringRef 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";
+  }
+  BufferizedTenStr = bufferize(SM, TenStr);
+  Val = Format.valueFromStringRepr(BufferizedTenStr, SM);
+  ASSERT_THAT_EXPECTED(Val, Succeeded());
+  EXPECT_EQ(*Val, 10U);
+  BufferizedFifteenStr = bufferize(SM, FifteenStr);
+  Val = Format.valueFromStringRepr(BufferizedFifteenStr, SM);
+  ASSERT_THAT_EXPECTED(Val, Succeeded());
+  EXPECT_EQ(*Val, 15U);
+  // 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",
+      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::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());
+  EXPECT_FALSE(bool(NoFormat));
+}
+
+TEST_F(FileCheckTest, ConflictFormatProperties) {
+  ExpressionFormat ConflictFormat(ExpressionFormat::Kind::Conflict);
+  expectError<StringError>("trying to match value with invalid format",
+                           ConflictFormat.getWildcardRegex().takeError());
+  expectError<StringError>("trying to match value with invalid format",
+                           ConflictFormat.getMatchingString(18).takeError());
+  EXPECT_FALSE(bool(ConflictFormat));
+}
+
+TEST_F(FileCheckTest, FormatEqualityOperators) {
+  ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned);
+  ExpressionFormat UnsignedFormat2(ExpressionFormat::Kind::Unsigned);
+  EXPECT_TRUE(UnsignedFormat == UnsignedFormat2);
+  EXPECT_FALSE(UnsignedFormat != UnsignedFormat2);
+
+  ExpressionFormat HexLowerFormat(ExpressionFormat::Kind::HexLower);
+  EXPECT_FALSE(UnsignedFormat == HexLowerFormat);
+  EXPECT_TRUE(UnsignedFormat != HexLowerFormat);
+
+  ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
+  ExpressionFormat NoFormat2(ExpressionFormat::Kind::NoFormat);
+  EXPECT_FALSE(NoFormat == NoFormat2);
+  EXPECT_TRUE(NoFormat != NoFormat2);
+
+  ExpressionFormat ConflictFormat(ExpressionFormat::Kind::Conflict);
+  ExpressionFormat ConflictFormat2(ExpressionFormat::Kind::Conflict);
+  EXPECT_TRUE(ConflictFormat == ConflictFormat2);
+  EXPECT_FALSE(ConflictFormat != ConflictFormat2);
+}
+
+TEST_F(FileCheckTest, FormatKindEqualityOperators) {
+  ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned);
+  EXPECT_TRUE(UnsignedFormat == ExpressionFormat::Kind::Unsigned);
+  EXPECT_FALSE(UnsignedFormat != ExpressionFormat::Kind::Unsigned);
+  EXPECT_FALSE(UnsignedFormat == ExpressionFormat::Kind::HexLower);
+  EXPECT_TRUE(UnsignedFormat != ExpressionFormat::Kind::HexLower);
+  ExpressionFormat ConflictFormat(ExpressionFormat::Kind::Conflict);
+  EXPECT_TRUE(ConflictFormat == ExpressionFormat::Kind::Conflict);
+  EXPECT_FALSE(ConflictFormat != ExpressionFormat::Kind::Conflict);
+  ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
+  EXPECT_TRUE(NoFormat == ExpressionFormat::Kind::NoFormat);
+  EXPECT_FALSE(NoFormat != ExpressionFormat::Kind::NoFormat);
+}
+
 TEST_F(FileCheckTest, Literal) {
   // Eval returns the literal's value.
   ExpressionLiteral Ten(10);
   Expected<uint64_t> Value = Ten.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
   EXPECT_EQ(10U, *Value);
+  EXPECT_EQ(Ten.getImplicitFormat(), ExpressionFormat::Kind::NoFormat);
 
   // Max value can be correctly represented.
   ExpressionLiteral Max(std::numeric_limits<uint64_t>::max());
   Value = Max.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
   EXPECT_EQ(std::numeric_limits<uint64_t>::max(), *Value);
 }
 
 static std::string toString(const std::unordered_set<std::string> &Set) {
   bool First = true;
   std::string Str;
   for (StringRef S : Set) {
     Str += Twine(First ? "{" + S : ", " + S).str();
     First = false;
   }
   Str += '}';
   return Str;
 }
 
+TEST_F(FileCheckTest, Expression) {
+  std::unique_ptr<ExpressionLiteral> Ten =
+      std::make_unique<ExpressionLiteral>(10);
+  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(E.getVarName()), 1U);
                    }),
       Succeeded());
   EXPECT_TRUE(ExpectedUndefVarNames.empty()) << toString(ExpectedUndefVarNames);
 }
 
 uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
 
 TEST_F(FileCheckTest, NumericVariable) {
   // Undefined variable: getValue and eval fail, error returned by eval holds
   // the name of the undefined variable.
-  NumericVariable FooVar("FOO", 1);
+  NumericVariable FooVar("FOO",
+                         ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
   EXPECT_EQ("FOO", FooVar.getName());
+  EXPECT_EQ(FooVar.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
   NumericVariableUse FooVarUse("FOO", &FooVar);
+  EXPECT_EQ(FooVarUse.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
   EXPECT_FALSE(FooVar.getValue());
   Expected<uint64_t> EvalResult = FooVarUse.eval();
   expectUndefErrors({"FOO"}, EvalResult.takeError());
 
   FooVar.setValue(42);
 
   // Defined variable: getValue and eval return value set.
   Optional<uint64_t> Value = FooVar.getValue();
   ASSERT_TRUE(Value);
   EXPECT_EQ(42U, *Value);
   EvalResult = FooVarUse.eval();
   ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
   EXPECT_EQ(42U, *EvalResult);
 
   // 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) {
-  NumericVariable FooVar("FOO", 1);
+  NumericVariable FooVar("FOO",
+                         ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
   FooVar.setValue(42);
   std::unique_ptr<NumericVariableUse> FooVarUse =
       std::make_unique<NumericVariableUse>("FOO", &FooVar);
-  NumericVariable BarVar("BAR", 2);
+  NumericVariable BarVar("BAR",
+                         ExpressionFormat(ExpressionFormat::Kind::Unsigned), 2);
   BarVar.setValue(18);
   std::unique_ptr<NumericVariableUse> BarVarUse =
       std::make_unique<NumericVariableUse>("BAR", &BarVar);
   BinaryOperation Binop(doAdd, std::move(FooVarUse), std::move(BarVarUse));
 
-  // Defined variable: eval returns right value.
+  // Defined variables: eval returns right value; implicit format is as
+  // expected.
   Expected<uint64_t> Value = Binop.eval();
   ASSERT_THAT_EXPECTED(Value, Succeeded());
   EXPECT_EQ(60U, *Value);
+  EXPECT_EQ(Binop.getImplicitFormat(), 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.
+  FooVarUse = std::make_unique<NumericVariableUse>("FOO", &FooVar);
+  std::unique_ptr<ExpressionLiteral> Eighteen =
+      std::make_unique<ExpressionLiteral>(18);
+  Binop = BinaryOperation(doAdd, std::move(FooVarUse), std::move(Eighteen));
+  EXPECT_EQ(Binop.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
+  FooVarUse = std::make_unique<NumericVariableUse>("FOO", &FooVar);
+  Eighteen = std::make_unique<ExpressionLiteral>(18);
+  Binop = BinaryOperation(doAdd, std::move(Eighteen), std::move(FooVarUse));
+  EXPECT_EQ(Binop.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
+
+  // Variables with different implicit format conflict.
+  NumericVariable BazVar("BAZ",
+                         ExpressionFormat(ExpressionFormat::Kind::HexLower), 3);
+  FooVarUse = std::make_unique<NumericVariableUse>("BAZ", &FooVar);
+  std::unique_ptr<NumericVariableUse> BazVarUse =
+      std::make_unique<NumericVariableUse>("BAZ", &BazVar);
+  Binop = BinaryOperation(doAdd, std::move(FooVarUse), std::move(BazVarUse));
+  EXPECT_EQ(Binop.getImplicitFormat(), ExpressionFormat::Kind::Conflict);
 }
 
 TEST_F(FileCheckTest, ValidVarNameStart) {
   EXPECT_TRUE(Pattern::isValidVarNameStart('a'));
   EXPECT_TRUE(Pattern::isValidVarNameStart('G'));
   EXPECT_TRUE(Pattern::isValidVarNameStart('_'));
   EXPECT_FALSE(Pattern::isValidVarNameStart('2'));
   EXPECT_FALSE(Pattern::isValidVarNameStart('$'));
   EXPECT_FALSE(Pattern::isValidVarNameStart('@'));
   EXPECT_FALSE(Pattern::isValidVarNameStart('+'));
   EXPECT_FALSE(Pattern::isValidVarNameStart('-'));
   EXPECT_FALSE(Pattern::isValidVarNameStart(':'));
 }
 
-static StringRef bufferize(SourceMgr &SM, StringRef Str) {
-  std::unique_ptr<MemoryBuffer> Buffer =
-      MemoryBuffer::getMemBufferCopy(Str, "TestBuffer");
-  StringRef StrBufferRef = Buffer->getBuffer();
-  SM.AddNewSourceBuffer(std::move(Buffer), SMLoc());
-  return StrBufferRef;
-}
-
-template <typename ErrorT>
-static void expectError(StringRef ExpectedMsg, Error Err) {
-  bool ErrorHandled = false;
-  EXPECT_THAT_ERROR(handleErrors(std::move(Err),
-                                 [&](const ErrorT &E) {
-                                   EXPECT_NE(
-                                       E.message().find(ExpectedMsg.str()),
-                                       std::string::npos);
-                                   ErrorHandled = true;
-                                 }),
-                    Succeeded());
-  EXPECT_TRUE(ErrorHandled);
-}
-
-static void expectDiagnosticError(StringRef ExpectedMsg, Error Err) {
-  expectError<ErrorDiagnostic>(ExpectedMsg, std::move(Err));
-}
-
 TEST_F(FileCheckTest, ParseVar) {
   SourceMgr SM;
   StringRef OrigVarName = bufferize(SM, "GoodVar42");
   StringRef VarName = OrigVarName;
   Expected<Pattern::VariableProperties> ParsedVarResult =
       Pattern::parseVariable(VarName, SM);
   ASSERT_THAT_EXPECTED(ParsedVarResult, Succeeded());
   EXPECT_EQ(ParsedVarResult->Name, OrigVarName);

 }
 
 class PatternTester {
 private:
   size_t LineNumber = 1;
   SourceMgr SM;
   FileCheckRequest Req;
   FileCheckPatternContext Context;
   Pattern P{Check::CheckPlain, &Context, LineNumber};
 
 public:
   PatternTester() {
     std::vector<std::string> GlobalDefines;
     GlobalDefines.emplace_back(std::string("#FOO=42"));
     GlobalDefines.emplace_back(std::string("BAR=BAZ"));
     // An ASSERT_FALSE would make more sense but cannot be used in a
     // constructor.
public:
   }
 
   void initNextPattern() {
     P = Pattern(Check::CheckPlain, &Context, ++LineNumber);
   }
 
   size_t getLineNumber() const { return LineNumber; }
 
-  Expected<std::unique_ptr<ExpressionAST>>
+  Expected<std::unique_ptr<Expression>>
   parseSubst(StringRef Expr, bool IsLegacyLineExpr = false) {
     StringRef ExprBufferRef = bufferize(SM, Expr);
     Optional<NumericVariable *> DefinedNumericVariable;
     return P.parseNumericSubstitutionBlock(
         ExprBufferRef, DefinedNumericVariable, IsLegacyLineExpr, LineNumber,
         &Context, SM);
   }
 
expectDiagnosticError("definition of pseudo numeric variable unsupported",
                         Tester.parseSubst("@LINE:").takeError());
 
   expectDiagnosticError("string variable with name 'BAR' already exists",
                         Tester.parseSubst("BAR:").takeError());
 
   expectDiagnosticError("unexpected characters after numeric variable name",
                         Tester.parseSubst("VAR GARBAGE:").takeError());
 
+  // Change of format.
+  expectDiagnosticError("format different from previous variable definition",
+                        Tester.parseSubst("%X,FOO:").takeError());
+
+  // Invalid format.
+  expectDiagnosticError("invalid matching format specification in expression",
+                        Tester.parseSubst("X,VAR1:").takeError());
+  expectDiagnosticError("invalid format specifier in expression",
+                        Tester.parseSubst("%F,VAR1:").takeError());
+  expectDiagnosticError("invalid matching format specification in expression",
+                        Tester.parseSubst("%X a,VAR1:").takeError());
+
+  // Acceptable variable definition.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR1:"), Succeeded());
   EXPECT_THAT_EXPECTED(Tester.parseSubst("  VAR2:"), Succeeded());
   EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR3  :"), Succeeded());
   EXPECT_THAT_EXPECTED(Tester.parseSubst("VAR3:  "), Succeeded());
+
+  // Acceptable variable definition with format specifier. Use parsePattern for
+  // variables whose definition needs to be visible for later checks.
+  EXPECT_FALSE(Tester.parsePattern("[[#%u, VAR_UNSIGNED:]]"));
+  EXPECT_FALSE(Tester.parsePattern("[[#%x, VAR_LOWER_HEX:]]"));
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("%X, VAR_UPPER_HEX:"), Succeeded());
+
+  // Acceptable variable definition from a numeric expression.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("FOOBAR: FOO+1"), Succeeded());
 
-  // Numeric expression.
+  // Numeric expression. Switch to next line to make above valid definition
+  // available in expressions.
+  Tester.initNextPattern();
 
   // Invalid variable name.
   expectDiagnosticError("invalid operand format '%VAR'",
                         Tester.parseSubst("%VAR").takeError());
 
   expectDiagnosticError("invalid pseudo numeric variable '@FOO'",
                         Tester.parseSubst("@FOO").takeError());
 
TEST_F(FileCheckTest, ParseNumericSubstitutionBlock) {
   // Invalid literal.
   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());
 
+  // 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());
+
   // Valid expression with 2 or more operands.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+3"), Succeeded());
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+0xC"), Succeeded());
   EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO-3+FOO"), Succeeded());
 
   expectDiagnosticError("unsupported operation '/'",
                         Tester.parseSubst("@LINE/2").takeError());
 
   expectDiagnosticError("missing operand in expression",
                         Tester.parseSubst("@LINE+").takeError());
 
   // Errors in RHS operand are bubbled up by parseBinop() to
   // parseNumericSubstitutionBlock().
   expectDiagnosticError("invalid operand format '%VAR'",
                         Tester.parseSubst("@LINE+%VAR").takeError());
 
   // Invalid legacy @LINE expression with non literal rhs.
   expectDiagnosticError(
       "invalid operand format '@LINE'",
       Tester.parseSubst("@LINE+@LINE", /*IsLegacyNumExpr=*/true).takeError());
 
   // Invalid legacy @LINE expression made of a single literal.
   expectDiagnosticError(
       "invalid variable name",
       Tester.parseSubst("2", /*IsLegacyNumExpr=*/true).takeError());
 
+  // 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("%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.
   expectDiagnosticError(
       "unexpected characters at end of expression '+@LINE'",
       Tester.parseSubst("@LINE+2+@LINE", /*IsLegacyNumExpr=*/true).takeError());
   expectDiagnosticError(
       "unexpected characters at end of expression '+2'",
       Tester.parseSubst("@LINE+2+2", /*IsLegacyNumExpr=*/true).takeError());
+
+  // Valid expression with several variables when their implicit formats do not
+  // conflict.
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("FOO+VAR_UNSIGNED"), Succeeded());
+
+  // Valid implicit format conflict in presence of explicit formats.
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("%X,FOO+VAR_LOWER_HEX"), Succeeded());
+
+  // Implicit format conflict.
+  expectDiagnosticError(
+      "variables with conflicting format specifier: need an explicit one",
+      Tester.parseSubst("FOO+VAR_LOWER_HEX").takeError());
 }
 
 TEST_F(FileCheckTest, ParsePattern) {
   PatternTester Tester;
 
   // Invalid space in string substitution.
   EXPECT_TRUE(Tester.parsePattern("[[ BAR]]"));
 
TEST_F(FileCheckTest, ParsePattern) {
   // Valid string variable definition.
   EXPECT_FALSE(Tester.parsePattern("[[PAT:[0-9]+]]"));
 
   // Invalid numeric substitution.
   EXPECT_TRUE(Tester.parsePattern("[[#42INVALID]]"));
 
   // Valid numeric substitution.
   EXPECT_FALSE(Tester.parsePattern("[[#FOO]]"));
+
+  // Valid legacy @LINE expression.
+  EXPECT_FALSE(Tester.parsePattern("[[@LINE+2]]"));
+
+  // Invalid legacy @LINE expression with non decimal literal.
+  EXPECT_TRUE(Tester.parsePattern("[[@LINE+0x3]]"));
 }
 
 TEST_F(FileCheckTest, Match) {
   PatternTester Tester;
 
   // Check matching an empty expression only matches a number.
   ASSERT_FALSE(Tester.parsePattern("[[#]]"));
   expectNotFoundError(Tester.match("FAIL").takeError());
   EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
 
-  // Check matching a definition only matches a number.
+  // Check matching a definition only matches a number with the right format.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR:]]"));
   expectNotFoundError(Tester.match("FAIL").takeError());
   expectNotFoundError(Tester.match("").takeError());
   EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
+  Tester.initNextPattern();
+  Tester.parsePattern("[[#%u,NUMVAR_UNSIGNED:]]");
+  expectNotFoundError(Tester.match("C").takeError());
+  EXPECT_THAT_EXPECTED(Tester.match("20"), Succeeded());
+  Tester.initNextPattern();
+  Tester.parsePattern("[[#%x,NUMVAR_LOWER_HEX:]]");
+  expectNotFoundError(Tester.match("g").takeError());
+  expectNotFoundError(Tester.match("C").takeError());
+  EXPECT_THAT_EXPECTED(Tester.match("c"), Succeeded());
+  Tester.initNextPattern();
+  Tester.parsePattern("[[#%X,NUMVAR_UPPER_HEX:]]");
+  expectNotFoundError(Tester.match("H").takeError());
+  expectNotFoundError(Tester.match("b").takeError());
+  EXPECT_THAT_EXPECTED(Tester.match("B"), Succeeded());
+
+  // Check matching expressions with no explicit format matches the values in
+  // the right format.
+  Tester.initNextPattern();
+  Tester.parsePattern("[[#NUMVAR_UNSIGNED-5]]");
+  expectNotFoundError(Tester.match("f").takeError());
+  expectNotFoundError(Tester.match("F").takeError());
+  EXPECT_THAT_EXPECTED(Tester.match("15"), Succeeded());
+  Tester.initNextPattern();
+  Tester.parsePattern("[[#NUMVAR_LOWER_HEX+1]]");
+  expectNotFoundError(Tester.match("13").takeError());
+  expectNotFoundError(Tester.match("D").takeError());
+  EXPECT_THAT_EXPECTED(Tester.match("d"), Succeeded());
+  Tester.initNextPattern();
+  Tester.parsePattern("[[#NUMVAR_UPPER_HEX+1]]");
+  expectNotFoundError(Tester.match("12").takeError());
+  expectNotFoundError(Tester.match("c").takeError());
+  EXPECT_THAT_EXPECTED(Tester.match("C"), Succeeded());
 
   // Check matching an undefined variable returns a NotFound error.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("100"));
   expectNotFoundError(Tester.match("101").takeError());
 
   // Check matching the defined variable matches the correct number only.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR]]"));
   EXPECT_THAT_EXPECTED(Tester.match("18"), Succeeded());
 
   // Check matching several substitutions does not match them independently.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("[[#NUMVAR]] [[#NUMVAR+2]]"));
   expectNotFoundError(Tester.match("19 21").takeError());
   expectNotFoundError(Tester.match("18 21").takeError());
   EXPECT_THAT_EXPECTED(Tester.match("18 20"), Succeeded());
 
-  // Check matching a numeric expression using @LINE after match failure uses
+  // Check matching a numeric expression using @LINE after a match failure uses
   // the correct value for @LINE.
   Tester.initNextPattern();
   ASSERT_FALSE(Tester.parsePattern("[[#@LINE]]"));
   // Ok, @LINE matches the current line number.
   EXPECT_THAT_EXPECTED(Tester.match(std::to_string(Tester.getLineNumber())),
                        Succeeded());
   Tester.initNextPattern();
   // Match with substitution failure.
   ASSERT_FALSE(Tester.parsePattern("[[#UNKNOWN]]"));
   expectUndefErrors({"UNKNOWN"}, Tester.match("FOO").takeError());
   Tester.initNextPattern();
   // Check that @LINE matches the later (given the calls to initNextPattern())
   // line number.
TEST_F(FileCheckTest, Substitution) {
   // Substitution of an undefined string variable fails and error holds that
   // variable's name.
   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", 1);
+  NumericVariable NVar("N", ExpressionFormat(ExpressionFormat::Kind::Unsigned),
+                       1);
   NVar.setValue(10);
   auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar);
-  NumericSubstitution SubstitutionN(&Context, "N", std::move(NVarUse),
+  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("10", *SubstValue);
+  EXPECT_EQ("A", *SubstValue);
 
   // Substitution of an undefined numeric variable fails, error holds name of
   // undefined variable.
   NVar.clearValue();
   SubstValue = SubstitutionN.getResult();
   expectUndefErrors({"N"}, SubstValue.takeError());
 
   // Substitution of a defined string variable returns the right value.
TEST_F(FileCheckTest, FileCheckContext) {
   GlobalDefines.clear();
   // Clear local variables to remove dummy numeric variable x that
   // parseNumericSubstitutionBlock would have created and stored in
   // GlobalNumericVariableTable.
   Cxt.clearLocalVars();
   GlobalDefines.emplace_back(std::string("LocalVar=FOO"));
   GlobalDefines.emplace_back(std::string("EmptyVar="));
   GlobalDefines.emplace_back(std::string("#LocalNumVar1=18"));
-  GlobalDefines.emplace_back(std::string("#LocalNumVar2=LocalNumVar1+2"));
+  GlobalDefines.emplace_back(std::string("#%x,LocalNumVar2=LocalNumVar1+2"));
+  GlobalDefines.emplace_back(std::string("#LocalNumVar3=0xc"));
   ASSERT_THAT_ERROR(Cxt.defineCmdlineVariables(GlobalDefines, SM), Succeeded());
 
   // Create @LINE pseudo numeric variable and check it is present by matching
   // it.
   size_t LineNumber = 1;
   Pattern P(Check::CheckPlain, &Cxt, LineNumber);
   FileCheckRequest Req;
   Cxt.createLineVariable();
   ASSERT_FALSE(P.parsePattern("[[@LINE]]", "CHECK", SM, Req));
   size_t MatchLen;
   ASSERT_THAT_EXPECTED(P.match("1", MatchLen, SM), Succeeded());
 
 #ifndef NDEBUG
   // Recreating @LINE pseudo numeric variable fails.
   EXPECT_DEATH(Cxt.createLineVariable(),
                "@LINE pseudo numeric variable already created");
 #endif
 
   // Check defined variables are present and undefined ones are absent.
   StringRef LocalVarStr = "LocalVar";
   StringRef LocalNumVar1Ref = bufferize(SM, "LocalNumVar1");
   StringRef LocalNumVar2Ref = bufferize(SM, "LocalNumVar2");
+  StringRef LocalNumVar3Ref = bufferize(SM, "LocalNumVar3");
   StringRef EmptyVarStr = "EmptyVar";
   StringRef UnknownVarStr = "UnknownVar";
   Expected<StringRef> LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
   Optional<NumericVariable *> DefinedNumericVariable;
-  Expected<std::unique_ptr<ExpressionAST>> ExpressionASTPointer =
+  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(ExpressionASTPointer, Succeeded());
-  Expected<uint64_t> ExpressionVal = (*ExpressionASTPointer)->eval();
+  ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
+  Expected<uint64_t> ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
   EXPECT_EQ(*ExpressionVal, 18U);
-  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
+  ExpressionPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar2Ref, DefinedNumericVariable,
       /*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
-  ASSERT_THAT_EXPECTED(ExpressionASTPointer, Succeeded());
-  ExpressionVal = (*ExpressionASTPointer)->eval();
+  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);
+  ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
+  ExpressionVal = (*ExpressionPointer)->getAST()->eval();
+  ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
+  EXPECT_EQ(*ExpressionVal, 12U);
   ASSERT_THAT_EXPECTED(EmptyVar, Succeeded());
   EXPECT_EQ(*EmptyVar, "");
   expectUndefErrors({UnknownVarStr}, UnknownVar.takeError());
 
   // Clear local variables and check they become absent.
   Cxt.clearLocalVars();
   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   expectUndefErrors({LocalVarStr}, LocalVar.takeError());
   // Check a numeric expression's evaluation fails if called after clearing of
   // local variables, if it was created before. This is important because local
   // variable clearing due to --enable-var-scope happens after numeric
   // expressions are linked to the numeric variables they use.
-  expectUndefErrors({"LocalNumVar2"},
-                    (*ExpressionASTPointer)->eval().takeError());
+  expectUndefErrors({"LocalNumVar3"},
+                    (*ExpressionPointer)->getAST()->eval().takeError());
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
-  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
+  ExpressionPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar1Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
-  ASSERT_THAT_EXPECTED(ExpressionASTPointer, Succeeded());
-  ExpressionVal = (*ExpressionASTPointer)->eval();
+  ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
+  ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   expectUndefErrors({"LocalNumVar1"}, ExpressionVal.takeError());
-  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
+  ExpressionPointer = P.parseNumericSubstitutionBlock(
       LocalNumVar2Ref, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
-  ASSERT_THAT_EXPECTED(ExpressionASTPointer, Succeeded());
-  ExpressionVal = (*ExpressionASTPointer)->eval();
+  ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
+  ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   expectUndefErrors({"LocalNumVar2"}, ExpressionVal.takeError());
   EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   expectUndefErrors({"EmptyVar"}, EmptyVar.takeError());
   // Clear again because parseNumericSubstitutionBlock would have created a
   // dummy variable and stored it in GlobalNumericVariableTable.
   Cxt.clearLocalVars();
 
   // Redefine global variables and check variables are defined again.
   GlobalDefines.emplace_back(std::string("$GlobalVar=BAR"));
   GlobalDefines.emplace_back(std::string("#$GlobalNumVar=36"));
   ASSERT_THAT_ERROR(Cxt.defineCmdlineVariables(GlobalDefines, SM), Succeeded());
   StringRef GlobalVarStr = "$GlobalVar";
   StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");
   Expected<StringRef> GlobalVar = Cxt.getPatternVarValue(GlobalVarStr);
   ASSERT_THAT_EXPECTED(GlobalVar, Succeeded());
   EXPECT_EQ(*GlobalVar, "BAR");
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
-  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
+  ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
-  ASSERT_THAT_EXPECTED(ExpressionASTPointer, Succeeded());
-  ExpressionVal = (*ExpressionASTPointer)->eval();
+  ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
+  ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
   EXPECT_EQ(*ExpressionVal, 36U);
 
   // Clear local variables and check global variables remain defined.
   Cxt.clearLocalVars();
   EXPECT_THAT_EXPECTED(Cxt.getPatternVarValue(GlobalVarStr), Succeeded());
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
-  ExpressionASTPointer = P.parseNumericSubstitutionBlock(
+  ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
-  ASSERT_THAT_EXPECTED(ExpressionASTPointer, Succeeded());
-  ExpressionVal = (*ExpressionASTPointer)->eval();
+  ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
+  ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
   EXPECT_EQ(*ExpressionVal, 36U);
 }
 } // namespace