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

54

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.

131

LeftFormat.Valid ? LeftFormat : RightFormat;

213

Delete the helper and inline it into the call sites.

312–313

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

[arichardson]

llvm/lib/Support/FileCheck.cpp

35

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

102–103

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

[jhenderson]

llvm/docs/CommandGuide/FileCheck.rst

596

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

598

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?

599

"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

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

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

84

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

161

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

163

i.e -> i.e.

166–170

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

170

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.

179

ie -> i.e.

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

249

if the implicit

250

conflict, and FormatNone

llvm/lib/Support/FileCheck.cpp

65

I believe you could do this in the initializer list:

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

102–103

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

7–1

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

38–42

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.

46

Should this be USE EXPL FMT IMPL MATCH?

106

Nit: missing trailing full stop.

132

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.

146

Nit: missing trailing full stop.

What is a "conversion matching format"?

158

Nit: missing trailing full stop.

172

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?

262

Missing trailing full stop.

263–264

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

270

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

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

28–29 ↗

(On Diff #205764)

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

43–44

FileCheckExpression NumVarExpr(nullptr, FormatUnsigned);

Same kind of comment goes throughout changes in this file.

44–45

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

598

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

28–29 ↗

(On Diff #205764)

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

599

default -> defaults

llvm/lib/Support/FileCheck.cpp

29–31

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)

130

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 ↗

(On Diff #233319)

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 ↗

(On Diff #233319)

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

68 ↗

(On Diff #233319)

explicit?

95–96 ↗

(On Diff #233319)

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

97 ↗

(On Diff #233319)

made -> made up

171 ↗

(On Diff #233319)

"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

130

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.

274

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.

428

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?

435

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

llvm/lib/Support/FileCheckImpl.h

45 ↗

(On Diff #233319)

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 ↗

(On Diff #233319)

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

147 ↗

(On Diff #233319)

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

7–8

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

130

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

428

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.

435

Yes and parseBinop.

llvm/test/FileCheck/numeric-defines.txt

7–8

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

428

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

7–8

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 ↗

(On Diff #236043)

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

56 ↗

(On Diff #236043)

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 ↗

(On Diff #236043)

if neither is NoFormat and their kinds are the same.

llvm/test/FileCheck/numeric-defines.txt

7–8

Nit: trailing full stop.

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

11

Nit: too many blank lines (1 is enough)

15

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

34

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

147

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

llvm/unittests/Support/FileCheckTest.cpp

40

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

57

What's going on here?

[thopre]

Add example showing literals are always parsed as decimal

llvm/lib/Support/FileCheck.cpp

428

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

7–8

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

15

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

40

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

7–8

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

15

Got it, thanks!

llvm/unittests/Support/FileCheckTest.cpp

64

Have you considered using ASSERT_THAT_ERROR and EXPECT_THAT_ERROR in these tests?

[thopre]

llvm/test/FileCheck/numeric-defines.txt

7–8

@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

7–8

@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

428

Yes that seems perfectly fine.

llvm/test/FileCheck/numeric-defines.txt

7–8

@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

270

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 ↗

(On Diff #236817)

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 ↗

(On Diff #236817)

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

28

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.

31

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.

41–42

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.

43–44

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).

76

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.

86

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

89

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

98

Vs -> versus

172–173

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

287–289

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?

338

does a check against "C" here make sense?

339

Debug printing left in by mistake?

342

Does a check against "b" here make sense?

489

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

495–496

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

172–173

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

287–289

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

495–496

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

[jhenderson]

llvm/unittests/Support/FileCheckTest.cpp

43–44

, -> ;

62–70

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?

88–99

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);

150

Formats -> Format

157

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

165

Formats -> Format

166

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

171

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.

183

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

288

format -> formats

292

format -> formats

319

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

331

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

495–496

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

503–504

Ditto.

[thopre]

Address all review comments

[thopre]

llvm/unittests/Support/FileCheckTest.cpp

62–70

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).

331

With the latest previous patch yes.

[jhenderson]

Nearly there, from my point of view.

llvm/unittests/Support/FileCheckTest.cpp

88–99

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

140–141

Spurious "to allow"?

[thopre]

Address unit tests review comments

llvm/unittests/Support/FileCheckTest.cpp

88–99

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

582

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

 FileCheck Numeric Variables and Expressions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 :program:`FileCheck` also allows defining numeric variables and checking for
 numeric values that satisfy a numeric expression constraint based on those
 variables. 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 value.
+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 specifier 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, 42`` and set ``REG`` to the value ``5``.
+would match ``mov r5, 0xF0F0`` and set ``REG`` to the value ``5`` and ``IMM``
+to the value ``61680``.
 
 The syntax to check a numeric expression constraint is
-``[[#<expr>]]`` where:
+``[[#%<fmtspec>:<expr>]]`` where:
+
+* ``%<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 they are all the same, and default 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 a numeric expression whose operands are either numeric
-  variables previously defined or integer literals.  Currently supported
+* ``<expr>>`` is a numeric expression whose operands are either numeric
+  variables previously defined or integer immediates.  Currently supported
   numeric operations are ``+`` and ``-``. A single numeric variable or
   integer literal is also accepted.
 
 For example:
 
 .. code-block:: llvm
 
     ; CHECK: add r[[#REG:]], r[[#REG]], r[[#REG+1]]
+    ; CHECK: copying from 0x[[#%x,ADDR:] to 0x[[#ADDR + 8]]
 
 The above example would match the line:
 
 .. code-block:: llvm
 
     add r5, r5, r6
+    copying from 0xa0463440 to 0xa0463448
 
 but would not match the line:
 
 .. code-block:: llvm
 
     add r5, r5, r7
+    copying from 0xa0463440 to 0xa0463444
 
-due to ``7`` being unequal to ``5 + 1``.
+Due to ``7`` being unequal to ``5 + 1`` and ``a0463444`` being unequal to
+``a0463440 + 8``.
 
 A numeric variable can also be defined to the result of a numeric expression,
 in which case the numeric expression constraint 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
 ``[[#%<fmtspec>,<NUMVAR>: <constraint> <expr>]]`` with each element as
 described previously.
 

llvm/include/llvm/Support/FileCheck.h

struct FileCheckRequest {
   bool Verbose = false;
   bool VerboseVerbose = false;
 };
 
 //===----------------------------------------------------------------------===//
 // Numeric expression handling code.
 //===----------------------------------------------------------------------===//
 
+/// Bitfield representing the format a numeric expression value should be
+/// printed into for matching. Used to represent both explicit format
+/// specifiers as well as implicit format from using numeric variables.
+struct FileCheckNumExprFmt {
+  /// Value should be printed as hex number.
+  unsigned Hex : 1;
+  /// Value should be printed using upper case letters, only used for hex
+  /// numbers.
+  unsigned Cap : 1;
+
+  /// When unset, denote absence of format and thus that all of the other
+  /// fields are to be ignored. Used for implicit format of literals and empty
+  /// expressions.
+  unsigned Valid : 1;
+
+  /// If set, there are several conflicting implicit formats in an expression.
+  unsigned Conflict : 1;
+
+  /// Define format equality: formats are equal if all bits are identical.
+  bool operator==(const FileCheckNumExprFmt &other);
+  bool operator!=(const FileCheckNumExprFmt &other) {
+    return !(*this == other);
+  }
+
+  /// Return wildcard regexp StringRef to match any value in the format
+  /// represented by this instance.
+  StringRef getWildcardRegex() const;
+
+  /// Return the string representation of \p Value in the format represented by
+  /// this instance.
+  std::string getMatchingString(uint64_t Value) const;
+
+  /// Return the value corresponding to string representation \p StrVal
+  /// according to the matching format represented by this instance or nothing
+  /// if \p StrVal does not correspond to a valid and representable value.
+  llvm::Optional<uint64_t> valueFromStringRepr(StringRef StrVal) const;
+};
+
+/// Initializer for numeric expression without format.
+const FileCheckNumExprFmt FmtNone = {0, 0, 0, 0};
+/// Initializer for numeric expression matched as unsigned value.
+const FileCheckNumExprFmt FmtUnsigned = {0, 0, 1, 0};
+/// Initializer for numeric expression matched as lower case hex value.
+const FileCheckNumExprFmt FmtLowHex = {1, 0, 1, 0};
+/// Initializer for numeric expression matched as capital case hex value.
+const FileCheckNumExprFmt FmtCapHex = {1, 1, 1, 0};
+
 /// Base class representing the AST of a given numeric expression.
 class FileCheckNumExprAST {
 public:
   virtual ~FileCheckNumExprAST() = default;
 
   /// Evaluates and \returns the value of the expression represented by this
   /// AST.
   virtual llvm::Optional<uint64_t> eval() const = 0;
 
+  /// \returns implicit format of this AST, FmtConflict if implicit formats of
+  /// the AST's components conflict and Fmt none if the AST has no implicit
+  /// format (e.g. AST is made of a single literal).
+  virtual FileCheckNumExprFmt getImplicitFmt() const = 0;
+
   /// Appends names of undefined variables used in the expression represented
   /// by this AST. Must be overriden in any subclass representing an expression
   /// that can contain a variable.
   virtual void
   appendUndefVarNames(std::vector<StringRef> &UndefVarNames) const {}
 };
 
 /// Class representing a literal in the AST of a numeric expression.
 class FileCheckNumExprLiteral : public FileCheckNumExprAST {
 private:
   /// Actual value of the literal.
   uint64_t Value;
 
 public:
   /// Constructor for an unsigned literal.
   FileCheckNumExprLiteral(uint64_t Val) : Value(Val) {}
 
   /// Evaluates and returns the value of the expression represented by this
   /// AST. Therefore, \returns the literal's value.
   llvm::Optional<uint64_t> eval() const { return Value; }
+
+  /// Return implicit format of this AST, therefore FmtNone.
+  FileCheckNumExprFmt getImplicitFmt() const { return FmtNone; }
 };
 
 /// Class representing a numeric expression and its matching format.
 class FileCheckNumExpr {
 private:
   /// Pointer to AST of the numeric expression.
   std::shared_ptr<FileCheckNumExprAST> AST;
 
+  /// Matching format, i.e format (e.g. hex upper case letters) to use for the
+  /// value when matching it.
+  FileCheckNumExprFmt Fmt;
+
 public:
   /// Generic constructor for a numeric expression whose equality constraint is
-  /// represented by \p AST.
-  FileCheckNumExpr(std::shared_ptr<FileCheckNumExprAST> AST) : AST(AST) {}
+  /// represented by \p AST and matching format is \p Fmt. If matching format
+  /// is unset (ie. no explicit or implicit matching format), set it to default
+  /// one (unsigned decimal integer).
+  FileCheckNumExpr(std::shared_ptr<FileCheckNumExprAST> AST,
+                   FileCheckNumExprFmt Fmt);
 
   /// \returns pointer to AST of the numeric expression. Pointer is guaranteed
   /// to be valid as long as this object is.
   FileCheckNumExprAST *getAST() const { return AST.get(); }
+
+  /// \returns effective format of this numeric expression, ie (i) its explicit
+  /// format if any, (ii) its implicit format if any or (iii) the default
+  /// format.
+  FileCheckNumExprFmt getEffectiveFmt() { return Fmt; }
 };
 
 /// Class representing a numeric variable with a given value in the AST of a
 /// numeric expression. Each definition of a variable gets its own instance of
 /// this class, variable uses share the same instance as the respective
 /// definition.
 class FileCheckNumericVariable : public FileCheckNumExprAST {
 private:
   /// Name of the numeric variable.
   StringRef Name;
 
   /// Pointer to numeric expression defining this numeric variable. Null for
   /// pseudo variable whose value is known at parse time (e.g. @LINE pseudo
   /// variable) or cleared local variable. If numeric expression is empty
   /// NumExpr points to a FileCheckNumExpr with a null AST.
   FileCheckNumExpr *NumExpr;
 
   /// Value of numeric variable, if defined, or None otherwise.
   llvm::Optional<uint64_t> Value;
 
   /// Line number where this variable is defined. Used to determine whether a
   /// variable is defined on the same line as a given use.
   unsigned DefLineNumber;
 
 public:
   /// Constructor for a variable \p Name defined at line \p DefLineNumber to
   /// the numeric expression represented by NumExpr.
   FileCheckNumericVariable(StringRef Name, FileCheckNumExpr *NumExpr,
                            unsigned DefLineNumber)
       : Name(Name), NumExpr(NumExpr), Value(llvm::None),
         DefLineNumber(DefLineNumber) {}
 
   /// Constructor for numeric variable \p Name with a known \p Value at parse
   /// time (e.g. the @LINE numeric variable).
   explicit FileCheckNumericVariable(StringRef Name, uint64_t Value)
       : Name(Name), NumExpr(nullptr), Value(Value) {}
 
   /// \returns name of that numeric variable.
   StringRef getName() const { return Name; }
 
   /// \returns numeric expression associated with this numeric variable.
   FileCheckNumExpr *getNumExpr() const { return NumExpr; }
 
   /// Evaluates and returns the value of the expression represented by this
   /// AST. Therefore, \returns this variable's value or the value of its
   /// associated numeric expression, if any.
   llvm::Optional<uint64_t> eval() const;
 
   /// \returns whether this variable's value is known at match time, when
   /// performing the substitutions.
   bool isMatchTimeKnown() const;
 
+  /// \returns implicit format of this numeric variable.
+  FileCheckNumExprFmt getImplicitFmt() const;
+
   /// Appends numeric variable's name to UndefVarNames if undefined.
   void appendUndefVarNames(std::vector<StringRef> &UndefVarNames) const;
 
   /// Sets value of this numeric variable if not defined. \returns whether the
   /// variable was already defined.
   bool setValue(uint64_t Value);
 
   /// Clears value of this numeric variable. \returns whether the variable was

 public:
   FileCheckASTBinop(binop_eval_t EvalBinop,
                     std::shared_ptr<FileCheckNumExprAST> OperandLeft,
                     std::shared_ptr<FileCheckNumExprAST> OperandRight)
       : LeftOp(OperandLeft), RightOp(OperandRight), EvalBinop(EvalBinop) {}
 
   /// Evaluates and \returns the value of the binary operation represented by
   /// this AST. Uses EvalBinop to perform the binary operation on the values of
   /// recursively evaluating the left and right operands.
   llvm::Optional<uint64_t> eval() const;
 
+  /// \returns implicit format of this AST, FmtConflict if implicit formats of
+  /// the AST's components conflict and Fmt none if the AST has no implicit
+  /// format (e.g. AST is made of a single literal).
+  FileCheckNumExprFmt getImplicitFmt() const;
+
   /// Appends names of undefined variables used in any of the operands of this
   /// binary operation.
   void appendUndefVarNames(std::vector<StringRef> &UndefVarNames) const;
 };
 
 class FileCheckPatternContext;
 
 /// Class representing a substitution to perform in the string to match.
public:
   std::string getDescription(StringRef Prefix) const;
 };
 } // namespace Check
 
 struct FileCheckDiag;
 
 /// Structure representing the definition of a numeric variable in a pattern.
 /// It holds the parenthesized capture number and the pointer to the class
-/// representing the numeric variable whose value is being defined.
+/// instance holding the value and matching format of the numeric variable
+/// being defined.
 struct FileCheckNumExprMatch {
-  /// 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.
   FileCheckNumericVariable *DefinedNumericVariable;
 
   /// Parenthesized capture number for this numeric variable definition.
   unsigned CaptureParen;
 };
 
 /// Class holding the FileCheckPattern global state, shared by all patterns:
 /// tables holding values of variables and whether they are defined or not at
public:
 
   /// Undefines local variables (variables whose name does not start with a '$'
   /// sign), i.e. removes them from GlobalVariableTable.
   void clearLocalVars();
 
 private:
   /// Makes a new numeric expression instance and registers it for destruction
   /// when the context is destroyed.
-  FileCheckNumExpr *makeNumExpr(std::shared_ptr<FileCheckNumExprAST> AST);
+  FileCheckNumExpr *makeNumExpr(std::shared_ptr<FileCheckNumExprAST> AST,
+                                FileCheckNumExprFmt Fmt);
 };
 
 class FileCheckPattern {
   SMLoc PatternLoc;
 
   /// A fixed string to match as the pattern or empty if this pattern requires
   /// a regex match.
   StringRef FixedStr;

llvm/lib/Support/FileCheck.cpp

 #include <cstdint>
 #include <list>
 #include <map>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;
 
+bool FileCheckNumExprFmt::operator==(const FileCheckNumExprFmt &other) {
+  return Valid == other.Valid && Hex == other.Hex && Cap == other.Cap;
+}
+
+StringRef FileCheckNumExprFmt::getWildcardRegex() const {
+  assert(Valid && !Conflict && "Trying to match value with invalid format");
+  if (Hex) {
+    if (Cap)
+      return StringRef("[[:digit:]A-F]+");
+    else
+      return StringRef("[[:digit:]a-f]+");
+  } else
+    return StringRef("[[:digit:]]+");
+}
+
+std::string FileCheckNumExprFmt::getMatchingString(uint64_t Value) const {
+  assert(Valid && !Conflict && "Trying to match value with invalid format");
+  if (Hex)
+    return utohexstr(Value, !Cap);
+  else
+    return utostr(Value);
+}
+
+llvm::Optional<uint64_t>
+FileCheckNumExprFmt::valueFromStringRepr(StringRef StrVal) const {
+  unsigned Radix = Hex ? 16 : 10;
+  uint64_t Value;
+
+  if (StrVal.getAsInteger(Radix, Value))
+    return llvm::None;
+
+  return Value;
+}
+
+FileCheckNumExpr::FileCheckNumExpr(std::shared_ptr<FileCheckNumExprAST> AST,
+                                   FileCheckNumExprFmt Fmt)
+    : AST(AST) {
+  if (Fmt.Valid)
+    this->Fmt = Fmt;
+  else
+    this->Fmt = FmtUnsigned;
+}
+
 llvm::Optional<uint64_t> FileCheckNumericVariable::eval() const {
   if (Value)
     return Value;
 
   if (NumExpr == nullptr || NumExpr->getAST() == nullptr)
     return llvm::None;
 
   return NumExpr->getAST()->eval();
 }
 
 bool FileCheckNumericVariable::isMatchTimeKnown() const {
   if (Value)
     return true;
 
   return NumExpr != nullptr && NumExpr->getAST() != nullptr;
 }
 
+FileCheckNumExprFmt FileCheckNumericVariable::getImplicitFmt() const {
+  if (NumExpr == nullptr)
+    return FmtNone;
+
+  return NumExpr->getEffectiveFmt();
+}
+
 void FileCheckNumericVariable::appendUndefVarNames(
     std::vector<StringRef> &UndefVarNames) const {
   if (!Value)
     UndefVarNames.emplace_back(Name);
 }
 
 bool FileCheckNumericVariable::setValue(uint64_t NewValue) {
   if (Value)
     return true;
   Value = NewValue;
   return false;
 }
 
 bool FileCheckNumericVariable::clearValue() {
   if (!Value)
     return true;
   Value = llvm::None;
   NumExpr = nullptr;
   return false;
 }
 
 llvm::Optional<uint64_t> FileCheckASTBinop::eval() const {
   llvm::Optional<uint64_t> LeftOp = this->LeftOp->eval();
   llvm::Optional<uint64_t> RightOp = this->RightOp->eval();
 
   // Uses undefined variable.
   if (!LeftOp || !RightOp)
     return llvm::None;
 
   return EvalBinop(*LeftOp, *RightOp);
 }
 
+FileCheckNumExprFmt FileCheckASTBinop::getImplicitFmt() const {
+  FileCheckNumExprFmt LeftFmt = LeftOp->getImplicitFmt();
+  FileCheckNumExprFmt RightFmt = RightOp->getImplicitFmt();
+
+  FileCheckNumExprFmt Fmt = (LeftFmt.Valid) ? LeftFmt : RightFmt;
+  if (LeftFmt.Valid && RightFmt.Valid && LeftFmt != RightFmt)
+    Fmt.Conflict = 1;
+
+  return Fmt;
+}
+
+/// Append names of undefined variables used in any of the operands of this
+/// binary operation.
 void FileCheckASTBinop::appendUndefVarNames(
     std::vector<StringRef> &UndefVarNames) const {
   LeftOp->appendUndefVarNames(UndefVarNames);
   RightOp->appendUndefVarNames(UndefVarNames);
 }
 
 llvm::Optional<std::string> FileCheckPatternSubstitution::getResult() const {
   if (IsNumExpr) {
     assert(NumExpr->getAST() != nullptr &&
            "Substituting empty numeric expression");
     llvm::Optional<uint64_t> EvaluatedValue = NumExpr->getAST()->eval();
     if (!EvaluatedValue)
       return llvm::None;
-    return utostr(*EvaluatedValue);
+    FileCheckNumExprFmt Fmt = NumExpr->getEffectiveFmt();
+    return Fmt.getMatchingString(*EvaluatedValue);
   }
 
   // Look up the value and escape it so that we can put it into the regex.
   llvm::Optional<StringRef> VarVal = Context->getPatternVarValue(FromStr);
   if (!VarVal)
     return llvm::None;
   return Regex::escape(*VarVal);
 }
bool FileCheckPattern::parseVariable(StringRef Str, bool &IsPseudo,
   TrailIdx = I;
   return false;
 }
 
 // StringRef holding all characters considered as horizontal whitespaces by
 // FileCheck input canonicalization.
 StringRef SpaceChars = " \t";
 
+// Parsing helper function that strips the string in \p SkipStr from S. Returns
+// true if string SkipStr was not in s and Optional was false. Returns false
+// otherwise.
+static bool stripFront(StringRef &S, const StringRef &SkipStr, bool Optional) {
+  if (!S.consume_front(SkipStr) && !Optional)
+    return true;
+  return false;
+}
+
 // 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;
 }
 
 bool FileCheckPattern::parseNumericVariable(StringRef &Expr, StringRef &Name,
bool FileCheckPattern::parseNumericVariable(StringRef &Expr, StringRef &Name,
 
   // This method is indirectly called from ParsePattern for all numeric
   // variable definitions and uses in the order in which they appear in the
   // CHECK pattern. For each definition, the pointer to the corresponding AST
   // class instance is stored in GlobalNumericVariableTable. Therefore the
   // pointer we get below is for the AST class instance corresponding to the
   // last definition of the variable before this use.
   auto VarTableIter = Context->GlobalNumericVariableTable.find(Name);
   if (VarTableIter == Context->GlobalNumericVariableTable.end()) {
     SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error,
                     "using undefined numeric variable '" + Name + "'");
     return true;
   }
 
   FileCheckNumericVariable *NumericVariable = VarTableIter->second.get();
   if (!IsPseudo && NumericVariable->getDefLineNumber() == LineNumber &&
       !NumericVariable->isMatchTimeKnown()) {
if (!parseNumericVariable(Expr, Name, false /*IsDefinition*/,
           Context->GlobalNumericVariableTable.find(Name)->second;
       return NumericVariable;
     }
   }
 
   // Otherwise, parse it as a literal.
   if (AO != LegacyLiteral && AO != Any)
     return nullptr;
+  unsigned Radix = (AO == LegacyLiteral) ? 10 : 0;
   uint64_t LiteralValue;
-  if (Expr.consumeInteger(10, LiteralValue))
+  if (Expr.consumeInteger(Radix, LiteralValue))
     return nullptr;
   return std::make_shared<FileCheckNumExprLiteral>(LiteralValue);
 }
 
 static uint64_t add(uint64_t LeftOp, uint64_t RightOp) {
   return LeftOp + RightOp;
 }
 
std::shared_ptr<FileCheckNumExprAST> FileCheckPattern::parseFileCheckBinop(
   return std::make_shared<FileCheckASTBinop>(EvalBinop, LeftOp, RightOp);
 }
 
 FileCheckNumExpr *FileCheckPattern::parseNumericExpression(
     StringRef Expr, FileCheckNumericVariable *&DefinedNumericVariable,
     bool Legacy, const SourceMgr &SM) const {
   std::shared_ptr<FileCheckNumExprAST> NumExprAST;
   StringRef DefExpr = StringRef();
+  FileCheckNumExprFmt ExplicitFmt = FmtNone;
+
+  // Parse format specifier.
+  size_t FmtSpecEnd = Expr.find(',');
+  if (FmtSpecEnd != StringRef::npos) {
+    Expr = Expr.ltrim(SpaceChars);
+    if (stripFront(Expr, "%", false /*Optional*/)) {
+      SM.PrintMessage(
+          SMLoc::getFromPointer(Expr.data()), SourceMgr::DK_Error,
+          "invalid matching format specification in numeric expression");
+      return nullptr;
+    }
+
+    // Check for unknown matching format specifier and set matching format in
+    // class instance representing this numeric expression.
+    SMLoc fmtloc = SMLoc::getFromPointer(Expr.data());
+    switch (popFront(Expr)) {
+    case 'u':
+      ExplicitFmt = FmtUnsigned;
+      break;
+    case 'x':
+      ExplicitFmt = FmtLowHex;
+      break;
+    case 'X':
+      ExplicitFmt = FmtCapHex;
+      break;
+    default:
+      SM.PrintMessage(fmtloc, SourceMgr::DK_Error,
+                      "invalid format specifier in numeric expression");
+      return nullptr;
+    }
+
+    Expr = Expr.ltrim(SpaceChars);
+    if (stripFront(Expr, ",", false /*Optional*/)) {
+      SM.PrintMessage(
+          SMLoc::getFromPointer(Expr.data()), SourceMgr::DK_Error,
+          "invalid matching format specification in numeric expression");
+      return nullptr;
+    }
+  }
 
   DefinedNumericVariable = nullptr;
   // 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 numeric expression itself.
   Expr = Expr.ltrim(SpaceChars);
+  StringRef UseExpr = Expr;
   if (!Expr.empty()) {
     // First operand in legacy numeric expression is the @LINE pseudo variable.
     enum AllowedOperand AO = Legacy ? LegacyVar : Any;
     NumExprAST = parseNumericOperand(Expr, AO, SM);
     while (NumExprAST != nullptr && !Expr.empty()) {
       NumExprAST = parseFileCheckBinop(Expr, NumExprAST, Legacy, SM);
       // Legacy numeric expressions only allow 2 operands.
       if (Legacy && !Expr.empty()) {
         SM.PrintMessage(SMLoc::getFromPointer(Expr.data()), SourceMgr::DK_Error,
                         "unexpected characters at end of numeric expression '" +
                             Expr + "'");
         return nullptr;
       }
     }
     if (NumExprAST == nullptr) {
       SM.PrintMessage(SMLoc::getFromPointer(Expr.data()), SourceMgr::DK_Error,
                       "invalid operand format '" + Expr + "'");
       return nullptr;
     }
   }
 
-  FileCheckNumExpr *NumExpr = Context->makeNumExpr(NumExprAST);
+  FileCheckNumExprFmt Fmt,
+      ImplicitFmt = NumExprAST ? NumExprAST->getImplicitFmt() : FmtNone;
+  // Select explicit matching format if any, implicit one otherwise. Error out
+  // in case of conflicting implicit format without explicit format.
+  if (ExplicitFmt.Valid)
+    Fmt = ExplicitFmt;
+  else if (ImplicitFmt.Conflict) {
+    SM.PrintMessage(
+        SMLoc::getFromPointer(UseExpr.data()), SourceMgr::DK_Error,
+        "variables with conflicting format specifier: need an explicit one");
+    return nullptr;
+  } else
+    Fmt = ImplicitFmt;
+
+  FileCheckNumExpr *NumExpr = Context->makeNumExpr(NumExprAST, Fmt);
 
   // Parse numeric variable definition.
   if (!DefExpr.empty()) {
     DefExpr = DefExpr.ltrim(SpaceChars);
     StringRef Name;
     if (parseNumericVariable(DefExpr, Name, true /*IsDefinition*/,
                              false /*AcceptFail*/, SM)) {
       // Invalid variable definition. Error reporting done in parsing function.
if (PatternStr.startswith("[[")) {
           return true;
         IsNumExpr = true;
         IsVarDef = DefinedNumericVariable != nullptr;
         SubstNeeded = NumExpr->getAST() != nullptr;
         if (IsVarDef)
           DefName = DefinedNumericVariable->getName();
         if (SubstNeeded)
           SubstStr = MatchStr;
-        else
-          MatchRegexp = StringRef("[0-9]+");
+        else {
+          FileCheckNumExprFmt Fmt = NumExpr->getEffectiveFmt();
+          MatchRegexp = Fmt.getWildcardRegex();
+        }
       }
 
       // Handle variable definition: [[<def>:(...)]] and [[#(...)<def>:(...)]].
       if (IsVarDef) {
         RegExStr += '(';
         ++SubstInsertIdx;
 
         if (IsNumExpr) {
size_t FileCheckPattern::match(StringRef Buffer, size_t &MatchLen,
   for (const auto &NumericVariableDef : NumericVariableDefs) {
     assert(NumericVariableDef.second.CaptureParen < MatchInfo.size() &&
            "Internal paren error");
     unsigned CaptureParen = NumericVariableDef.second.CaptureParen;
     FileCheckNumericVariable *DefinedNumericVariable =
         NumericVariableDef.second.DefinedNumericVariable;
 
     StringRef MatchedValue = MatchInfo[CaptureParen];
-    uint64_t Val;
-    if (MatchedValue.getAsInteger(10, Val)) {
+    assert(DefinedNumericVariable->getNumExpr() != nullptr);
+    FileCheckNumExprFmt Fmt =
+        DefinedNumericVariable->getNumExpr()->getEffectiveFmt();
+    llvm::Optional<uint64_t> Value = Fmt.valueFromStringRepr(MatchedValue);
+    if (!Value) {
       SM.PrintMessage(SMLoc::getFromPointer(MatchedValue.data()),
                       SourceMgr::DK_Error, "Unable to represent numeric value");
     }
-    if (DefinedNumericVariable->setValue(Val))
+    if (DefinedNumericVariable->setValue(*Value))
       assert(false && "Numeric variable redefined");
   }
 
   // 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;
FileCheckPatternContext::getPatternVarValue(StringRef VarName) {
   auto VarIter = GlobalVariableTable.find(VarName);
   if (VarIter == GlobalVariableTable.end())
     return llvm::None;
 
   return VarIter->second;
 }
 
 FileCheckNumExpr *
-FileCheckPatternContext::makeNumExpr(std::shared_ptr<FileCheckNumExprAST> AST) {
-  NumExprs.emplace_back(new FileCheckNumExpr(AST));
+FileCheckPatternContext::makeNumExpr(std::shared_ptr<FileCheckNumExprAST> AST,
+                                     FileCheckNumExprFmt Fmt) {
+  NumExprs.emplace_back(new FileCheckNumExpr(AST, Fmt));
   return NumExprs.back().get();
 }
 
 size_t FileCheckPattern::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;

llvm/test/FileCheck/line-count.txt

 ; RUN: FileCheck -input-file %s %s
 ; RUN: not FileCheck -check-prefix BAD1 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR1 %s
 ; RUN: not FileCheck -check-prefix BAD2 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR2 %s
 ; RUN: not FileCheck -check-prefix BAD3 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR3 %s
 ; RUN: not FileCheck -check-prefix BAD4 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR4 %s
 ; RUN: not FileCheck -check-prefix BAD5 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR5 %s
 ; RUN: not FileCheck -check-prefix BAD6 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR6 %s
 ; RUN: not FileCheck -check-prefix BAD7 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR7 %s
 ; RUN: not FileCheck -check-prefix BAD8 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR8 %s
 ; RUN: not FileCheck -check-prefix BAD9 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR9 %s
 ; RUN: not FileCheck -check-prefix BAD10 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR10 %s
 ; RUN: not FileCheck -check-prefix BAD11 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR11 %s
-13
-14 aaa
-15 bbb
-16 ccc
-17 CHECK: [[@LINE-3]] {{a}}aa
-18 CHECK: [[@LINE-3]] {{b}}bb
-19 CHECK: [[@LINE-3]] {{c}}cc
-20 foobar
-21 CHECK: [[@LINE-1]] {{foo}}bar
-22
-23 arst CHECK: [[@LINE]] {{a}}rst
-24
-25 BAD1: [[@LINE:cant-have-regex]]
-26 ERR1: line-count.txt:[[#@LINE-1]]:12: error: invalid name in pattern variable definition
-27
-28 BAD2: [[ @LINE]]
-29 ERR2: line-count.txt:[[#@LINE-1]]:12: error: unexpected whitespace
-30
-31 BAD3: [[@LINE ]]
-32 ERR3: line-count.txt:[[#@LINE-1]]:17: error: unexpected whitespace
-33
-34 BAD4: [[ @LINE-1]]
-35 ERR4: line-count.txt:[[#@LINE-1]]:12: error: unexpected whitespace
-36
-37 BAD5: [[@LINE -1]]
-38 ERR5: line-count.txt:[[#@LINE-1]]:17: error: unexpected whitespace
-39
-40 BAD6: [[@LINE- 1]]
-41 ERR6: line-count.txt:[[#@LINE-1]]:18: error: unexpected whitespace
-42
-43 BAD7: [[@LINE-1 ]]
-44 ERR7: line-count.txt:[[#@LINE-1]]:19: error: unexpected whitespace
-45
-46 BAD8: [[@LIN]]
-47 ERR8: line-count.txt:[[#@LINE-1]]:12: error: invalid pseudo numeric variable '@LIN'
-48
-49 BAD9: [[@LINE*2]]
-50 ERR9: line-count.txt:[[#@LINE-1]]:17: error: unsupported numeric operation '*'
-51
-52 BAD10: [[@LINE-x]]
-53 ERR10: line-count.txt:[[#@LINE-1]]:19: error: invalid operand format 'x'
-54
-55 BAD11: [[@LINE-1x]]
-56 ERR11: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of numeric expression 'x'
-57
-58 CHECK: [[#@LINE]] CHECK
-59 CHECK: [[# @LINE]] CHECK
-60 CHECK: [[# @LINE ]] CHECK
+; RUN: not FileCheck -check-prefix BAD12 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR12 %s
+14
+15 aaa
+16 bbb
+17 ccc
+18 CHECK: [[@LINE-3]] {{a}}aa
+19 CHECK: [[@LINE-3]] {{b}}bb
+20 CHECK: [[@LINE-3]] {{c}}cc
+21 foobar
+22 CHECK: [[@LINE-1]] {{foo}}bar
+23
+24 arst CHECK: [[@LINE]] {{a}}rst
+25
+26 BAD1: [[@LINE:cant-have-regex]]
+27 ERR1: line-count.txt:[[#@LINE-1]]:12: error: invalid name in pattern variable definition
+28
+29 BAD2: [[ @LINE]]
+30 ERR2: line-count.txt:[[#@LINE-1]]:12: error: unexpected whitespace
+31
+32 BAD3: [[@LINE ]]
+33 ERR3: line-count.txt:[[#@LINE-1]]:17: error: unexpected whitespace
+34
+35 BAD4: [[ @LINE-1]]
+36 ERR4: line-count.txt:[[#@LINE-1]]:12: error: unexpected whitespace
+37
+38 BAD5: [[@LINE -1]]
+39 ERR5: line-count.txt:[[#@LINE-1]]:17: error: unexpected whitespace
+40
+41 BAD6: [[@LINE- 1]]
+42 ERR6: line-count.txt:[[#@LINE-1]]:18: error: unexpected whitespace
+43
+44 BAD7: [[@LINE-1 ]]
+45 ERR7: line-count.txt:[[#@LINE-1]]:19: error: unexpected whitespace
+46
+47 BAD8: [[@LIN]]
+48 ERR8: line-count.txt:[[#@LINE-1]]:12: error: invalid pseudo numeric variable '@LIN'
+49
+50 BAD9: [[@LINE*2]]
+51 ERR9: line-count.txt:[[#@LINE-1]]:17: error: unsupported numeric operation '*'
+52
+53 BAD10: [[@LINE-x]]
+54 ERR10: line-count.txt:[[#@LINE-1]]:19: error: invalid operand format 'x'
+55
+56 BAD11: [[@LINE-1x]]
+57 ERR11: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of numeric expression 'x'
+58
+59 BAD12: [[@LINE-0xA]]
+60 ERR12: line-count.txt:[[#@LINE-1]]:20: error: unexpected characters at end of numeric expression 'xA'
 61
-62 CHECK: [[#@LINE-1]]
-63 CHECK: [[# @LINE-1]] CHECK
-64 CHECK: [[# @LINE -1]] CHECK
-65 CHECK: [[# @LINE - 1]] CHECK
-66 CHECK: [[# @LINE - 1 ]] CHECK
+62 CHECK: [[#@LINE]] CHECK
+63 CHECK: [[# @LINE]] CHECK
+64 CHECK: [[# @LINE ]] CHECK
+65
+66 CHECK: [[#@LINE-1]]
+67 CHECK: [[# @LINE-1]] CHECK
+68 CHECK: [[# @LINE -1]] CHECK
+69 CHECK: [[# @LINE - 1]] CHECK
+70 CHECK: [[# @LINE - 1 ]] CHECK

llvm/test/FileCheck/numeric-defines.txt

-; RUN: FileCheck -D#NUMVAL1=8 -D#NUMVAL2='NUMVAL1 + 4' -check-prefix CHECKNUM -input-file %s %s
-; RUN: not FileCheck -D#NUMVAL2=8 -check-prefix CHECKNUM -input-file %s %s 2>&1 \
+; RUN: FileCheck -D#%X,NUMVAL1=8 -D#NUMVAL2='NUMVAL1 + 4' -check-prefix CHECKNUM -input-file %s %s
+; RUN: not FileCheck -D#%X,NUMVAL1=8 -D#NUMVAL2='NUMVAL1+6' -check-prefix CHECKNUM -input-file %s %s 2>&1 \
 ; RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRMSG
-; RUN: not FileCheck -D#NUMVAL2=12 -check-prefix NUMNOT -input-file %s %s 2>&1 \
+; RUN: not FileCheck -D#%X,NUMVAL1=8 -D#NUMVAL2='NUMVAL1+4' -check-prefix NUMNOT -input-file %s %s 2>&1 \
 ; RUN:   | FileCheck %s --strict-whitespace -check-prefix NOT-NUMERRMSG
-; RUN: FileCheck -D#NUMVAL2=8 -check-prefixes NUMNOT -input-file %s %s
+; RUN: FileCheck -D#%X,NUMVAL1=8 -D#NUMVAL2='NUMVAL1+6' -check-prefixes NUMNOT -input-file %s %s
 
-Numeric value #2 = 12
+Numeric value #2 = C
 ; CHECKNUM: Numeric value #2 = [[#NUMVAL2]]
 ; NUMNOT-NOT: Numeric value #2 = [[#NUMVAL2]]
 
 ; NUMERRMSG: defines.txt:[[#@LINE-3]]:13: error: CHECKNUM: expected string not found in input
 ; NUMERRMSG: defines.txt:1:1: note: scanning from here
-; NUMERRMSG: defines.txt:1:1: note: with numeric expression "NUMVAL2" equal to "8"
+; NUMERRMSG: defines.txt:1:1: note: with numeric expression "NUMVAL2" equal to "E"
 ; NUMERRMSG: defines.txt:[[#@LINE-7]]:1: note: possible intended match here
 
 ; NOT-NUMERRMSG: defines.txt:[[#@LINE-7]]:15: error: {{NUMNOT}}-NOT: excluded string found in input
-; NOT-NUMERRMSG: defines.txt:[[#@LINE-10]]:1: note: found here
-; NOT-NUMERRMSG: defines.txt:[[#@LINE-11]]:1: note: with numeric expression "NUMVAL2" equal to "12"
+; NOT-NUMERRMSG: defines.txt:[[#NUMVALLINE:@LINE-10]]:1: note: found here
+; NOT-NUMERRMSG: defines.txt:[[#NUMVALLINE]]:1: note: with numeric expression "NUMVAL2" equal to "C"
 
 ; RUN: not FileCheck -D#10VALUE=10 -input-file %s %s 2>&1 \
-; RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRCLIFMT
+; RUN:   | FileCheck %s --strict-whitespace -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: {{^                                             \^$}}
 
 ; RUN: not FileCheck -D#@VALUE=10 -input-file %s %s 2>&1 \
 ; RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRCLIPSEUDO
 
 ; NUMERRCLIPSEUDO: Global defines:1:45: error: invalid pseudo numeric variable
 ; NUMERRCLIPSEUDO-NEXT: Global define #1: #@VALUE=10 (parsed as: {{\[\[#@VALUE:10\]\]}})
 ; NUMERRCLIPSEUDO-NEXT: {{^                                            \^$}}
 
 ; RUN: not FileCheck -D#'VALUE + 2=10' -input-file %s %s 2>&1 \
 : RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRCLITRAIL
 
 ; NUMERRCLITRAIL: Global defines:1:54: error: invalid numeric variable definition
 ; NUMERRCLITRAIL-NEXT: Global define #1: #VALUE + 2=10 (parsed as: {{\[\[#VALUE \+ 2:10\]\]}})
 ; NUMERRCLITRAIL-NEXT: {{^                                                     \^$}}
+
+; RUN: not FileCheck -D#,VALUE=10 -input-file %s %s 2>&1 \
+; RUN:   | FileCheck %s --strict-whitespace -check-prefix NUMERRCLIFMT
+
+; NUMERRCLIFMT: Global defines:1:45: error: invalid matching format specification in numeric expression
+; NUMERRCLIFMT-NEXT: Global define #1: #,VALUE=10 (parsed as: {{\[\[#,VALUE:10\]\]}})
+; NUMERRCLIFMT-NEXT: {{^                                            \^$}}

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
+DEF DEFAULT FMT
 11
-; CHECK-LABEL: DEF NO SPC
+; CHECK-LABEL: DEF DEFAULT FMT
 ; CHECK-NEXT: [[#VAR1:]]
 
-; Numeric variable definition in alternate spacing
-DEF ALT SPC
+;; Numeric variable definition with default matching format in alternate spacing
+DEF DEFAULT FMT ALT SPC
 11
 11
 11
-; CHECK-LABEL: DEF ALT SPC
+; CHECK-LABEL: DEF DEFAULT FMT ALT SPC
 ; CHECK-NEXT: [[# VAR1a:]]
 ; CHECK-NEXT: [[# VAR1b :]]
 ; CHECK-NEXT: [[# VAR1c : ]]
 
-; 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 in alternate spacing
+DEF FMT ALT SPC
+c
+c
+c
+c
+c
+; CHECK-LABEL: DEF FMT ALT SPC
+; CHECK-NEXT: [[#%x, VAR2a:]]
+; CHECK-NEXT: [[# %x, VAR2b:]]
+; CHECK-NEXT: [[# %x , VAR2c:]]
+; CHECK-NEXT: [[# %x , VAR2d :]]
+; CHECK-NEXT: [[# %x , VAR2e : ]]
+
+; Numeric expressions in explicit matching format and default matching rule using
+; variables defined on other lines
+USE DEF FMT IMPL MATCH
 11
 12
 10
-; CHECK-LABEL: USE
-; CHECK-NEXT: [[#VAR1]]
-; CHECK-NEXT: [[#VAR1+1]]
-; CHECK-NEXT: [[#VAR1-1]]
-
-; Numeric expressions using variables defined on other lines in alternate
-; spacing
-USE ALT SPC
+c
+d
+b
+1a
+D
+E
+C
+1B
+; 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]]
+
+; Numeric expressions in explicit matching format and default matching rule using
+; variables defined on other lines in alternate spacing
+USE EXPL FMT IMPL MATCH ALT SPC
+11
 11
 11
 12
 12
 12
 12
+12
+12
 10
 10
 10
 10
-; CHECK-LABEL: USE ALT 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 ALT 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]]
+
+; Explicit format override implicit format conflicts
+VAR USE IMPL OVERRIDE FMT CONFLICT
+23
+; CHECK-LABEL: VAR USE IMPL OVERRIDE FMT CONFLICT
+; CHECK-NEXT: [[# %u, VAR1 + VAR2]]
 
 ; Numeric expressions using variables defined on the command-line 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 conversion matching format and implicit matching rule
+; using 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]]
+
+; 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 %s
+; RUN: not FileCheck -check-prefixes ERR,INVALID-FMT-SPEC2 -input-file %s %s 2>&1 \
+; RUN:   | FileCheck -check-prefix INVALID-FMT-SPEC-MSG2 %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]]:39: error: invalid format specifier in numeric 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]]:39: error: invalid format specifier in numeric expression
+; INVALID-FMT-SPEC-MSG2-NEXT: ; {{I}}NVALID-FMT-SPEC2-NEXT: INVVAR2={{\[\[#%hhd,INVVAR2:\]\]}}
+; INVALID-FMT-SPEC-MSG2-NEXT: {{^                         \^$}}
 
 ; Numeric expression using a variable defined from a numeric expression
 DEF EXPR GOOD MATCH
 42
 41 43
 ; CHECK-LABEL: DEF EXPR GOOD MATCH
 ; CHECK-NEXT: [[# VAR42:VAR1+31]]
 ; CHECK-NEXT: [[# VAR41: VAR42-1]] [[# VAR41 + 2]]

 ; checked
 ; RUN: not FileCheck -check-prefix DEF-EXPR-FAIL -input-file %s %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]]
+
+; 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]]:25: error: variables with conflicting format specifier: need an explicit one
+; FMT-CONFLICT-MSG-NEXT: {{F}}MT-CONFLICT-NEXT: {{\[\[#VAR1 \+ VAR2\]\]}}
+; FMT-CONFLICT-MSG-NEXT: {{^                        \^$}}

llvm/test/FileCheck/pattern-defines.txt

 ; ERRCLIVAR2: Missing pattern variable name in command-line definition '-D='
 
 ; RUN: FileCheck -DVALUE= -check-prefix EMPTY -input-file %s %s 2>&1
 
 Empty value = @@
 ; EMPTY: Empty value = @[[VALUE]]@
 
 ; RUN: not FileCheck -D10VALUE=10 -input-file %s %s 2>&1 \
-; RUN:   | FileCheck %s --strict-whitespace -check-prefix ERRCLIFMT
+; RUN:   | FileCheck %s --strict-whitespace -check-prefix ERRCLINAME
 
-; ERRCLIFMT: Global defines:1:19: error: invalid name in pattern variable definition '10VALUE'
-; ERRCLIFMT-NEXT: Global define #1: 10VALUE=10
-; ERRCLIFMT-NEXT: {{^                  \^$}}
+; ERRCLINAME: Global defines:1:19: error: invalid name in pattern variable definition '10VALUE'
+; ERRCLINAME-NEXT: Global define #1: 10VALUE=10
+; ERRCLINAME-NEXT: {{^                  \^$}}
 
 ; RUN: not FileCheck -D@VALUE=10 -input-file %s %s 2>&1 \
 ; RUN:   | FileCheck %s --strict-whitespace -check-prefix ERRCLIPSEUDO
 
 ; ERRCLIPSEUDO: Global defines:1:19: error: invalid name in pattern variable definition '@VALUE'
 ; ERRCLIPSEUDO-NEXT: Global define #1: @VALUE=10
 ; ERRCLIPSEUDO-NEXT: {{^                  \^$}}
 
 ; RUN: not FileCheck -D'VALUE + 2=10' -input-file %s %s 2>&1 \
 ; RUN:   | FileCheck %s --strict-whitespace -check-prefix ERRCLITRAIL
 
 ; ERRCLITRAIL: Global defines:1:19: error: invalid name in pattern variable definition 'VALUE + 2'
 ; ERRCLITRAIL-NEXT: Global define #1: VALUE + 2=10
 ; ERRCLITRAIL-NEXT: {{^                  \^$}}

llvm/unittests/Support/FileCheckTest.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 namespace {
 
 class FileCheckTest : public ::testing::Test {};
 
 TEST_F(FileCheckTest, NumericVariableValueGetClearSet) {
-  auto NumVarExpr = FileCheckNumExpr(nullptr);
+  auto NumVarExpr = FileCheckNumExpr(nullptr, FmtUnsigned);
   FileCheckNumericVariable FooVar =
       FileCheckNumericVariable("FOO", &NumVarExpr, 1);
   FooVar.setValue((uint64_t)42);
 
   // Defined variable: getValue returns a value, setValue fails.
   llvm::Optional<uint64_t> Value = FooVar.eval();
   EXPECT_TRUE(Value);
   EXPECT_EQ((uint64_t)42, *Value);
   EXPECT_TRUE(FooVar.setValue((uint64_t)43));
 
   // Clearing variable: getValue fails, clearValue again fails.
   EXPECT_FALSE(FooVar.clearValue());
   Value = FooVar.eval();
   EXPECT_FALSE(Value);
   EXPECT_TRUE(FooVar.clearValue());
 
   // Undefined variable: setValue works, getValue returns value set.
   EXPECT_FALSE(FooVar.setValue((uint64_t)43));
   Value = FooVar.eval();
   EXPECT_TRUE(Value);
   EXPECT_EQ((uint64_t)43, *Value);
 }
 
 uint64_t doAdd(uint64_t OpL, uint64_t OpR) { return OpL + OpR; }
 
 TEST_F(FileCheckTest, BinopEvalUndef) {
-  auto FooNumExpr = FileCheckNumExpr(nullptr);
+  auto FooNumExpr = FileCheckNumExpr(nullptr, FmtUnsigned);
   auto FooVar =
       std::make_shared<FileCheckNumericVariable>("FOO", &FooNumExpr, 1);
   FooVar->setValue((uint64_t)42);
-  auto BarNumExpr = FileCheckNumExpr(nullptr);
+  auto BarNumExpr = FileCheckNumExpr(nullptr, FmtUnsigned);
   auto BarVar =
       std::make_shared<FileCheckNumericVariable>("BAR", &BarNumExpr, 2);
   BarVar->setValue((uint64_t)18);
   auto Binop = new FileCheckASTBinop(doAdd, FooVar, BarVar);
 
   // Defined variable: eval returns right value, no undef variable returned.
   llvm::Optional<uint64_t> Value = Binop->eval();
   EXPECT_TRUE(Value);
   EXPECT_EQ((uint64_t)60, *Value);
   std::vector<StringRef> UndefVarNames;
   Binop->appendUndefVarNames(UndefVarNames);
   EXPECT_TRUE(UndefVarNames.empty());
 
   // 1 undefined variable: eval fails, undef variable returned.
   FooVar->clearValue();
   Value = Binop->eval();
   EXPECT_FALSE(Value);
   Binop->appendUndefVarNames(UndefVarNames);
   EXPECT_EQ(1U, UndefVarNames.size());
   EXPECT_EQ("FOO", UndefVarNames[0]);
 
   // 2 undefined variables: eval fails, undef variables returned.
   BarVar->clearValue();
   Value = Binop->eval();
   EXPECT_FALSE(Value);
   UndefVarNames.clear();
   Binop->appendUndefVarNames(UndefVarNames);
   EXPECT_EQ(2U, UndefVarNames.size());
   EXPECT_EQ("FOO", UndefVarNames[0]);
   EXPECT_EQ("BAR", UndefVarNames[1]);
 }
 
 TEST_F(FileCheckTest, ValidVarNameStart) {
   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('a'));
   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('G'));
   EXPECT_TRUE(FileCheckPattern::isValidVarNameStart('_'));
   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('2'));
   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('$'));
   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('@'));
   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('+'));
   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart('-'));
   EXPECT_FALSE(FileCheckPattern::isValidVarNameStart(':'));
 }
 
 TEST_F(FileCheckTest, ParseVar) {
   StringRef VarName = "GoodVar42";
   bool IsPseudo = true;
   unsigned TrailIdx = 0;
   EXPECT_FALSE(FileCheckPattern::parseVariable(VarName, IsPseudo, TrailIdx));
   EXPECT_FALSE(IsPseudo);
   EXPECT_EQ(TrailIdx, VarName.size());
 
   VarName = "$GoodGlobalVar";
   IsPseudo = true;
   TrailIdx = 0;
   EXPECT_FALSE(FileCheckPattern::parseVariable(VarName, IsPseudo, TrailIdx));
   EXPECT_FALSE(IsPseudo);
   EXPECT_EQ(TrailIdx, VarName.size());
TEST_F(FileCheckTest, ParseVar) {
   EXPECT_FALSE(FileCheckPattern::parseVariable(VarName, IsPseudo, TrailIdx));
   EXPECT_FALSE(IsPseudo);
   EXPECT_EQ(TrailIdx, 1U);
 
   VarName = "BadVar+";
   IsPseudo = true;
   TrailIdx = 0;
   EXPECT_FALSE(FileCheckPattern::parseVariable(VarName, IsPseudo, TrailIdx));
   EXPECT_FALSE(IsPseudo);
   EXPECT_EQ(TrailIdx, VarName.size() - 1);
 
   VarName = "BadVar-";
   IsPseudo = true;
   TrailIdx = 0;
   EXPECT_FALSE(FileCheckPattern::parseVariable(VarName, IsPseudo, TrailIdx));
   EXPECT_FALSE(IsPseudo);
   EXPECT_EQ(TrailIdx, VarName.size() - 1);
 
   VarName = "BadVar:";
   IsPseudo = true;
   TrailIdx = 0;
   EXPECT_FALSE(FileCheckPattern::parseVariable(VarName, IsPseudo, TrailIdx));
   EXPECT_FALSE(IsPseudo);
   EXPECT_EQ(TrailIdx, VarName.size() - 1);
 }
 
 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;
 }
 
 class PatternTester {
 private:
   unsigned LineNumber = 1;
   SourceMgr SM;
   struct FileCheckRequest Req;
   FileCheckPatternContext Context;
   FileCheckPattern P =
       FileCheckPattern(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"));
     Context.defineCmdlineVariables(GlobalDefines, SM);
     // Call ParsePattern to have @LINE defined.
     P.ParsePattern("N/A", "CHECK", SM, Req);
     // ParsePattern does not expect to be called twice for the same line and
     // will set FixedStr and RegExStr incorrectly if it is. Therefore prepare
     // a pattern for a different line.
     initNextPattern();
   }
 
   void initNextPattern() {
     P = FileCheckPattern(Check::CheckPlain, &Context, LineNumber++);
   }
TEST_F(FileCheckTest, ParseExpr) {
 
   // Cannot parse offset operand.
   EXPECT_TRUE(Tester.parseExprExpect("@LINE+x"));
 
   // Unexpected string at end of numeric expression.
   EXPECT_TRUE(Tester.parseExprExpect("@LINE+5x"));
 
   // Valid expression.
   EXPECT_FALSE(Tester.parseExprExpect("@LINE+5"));
   EXPECT_FALSE(Tester.parseExprExpect("FOO+4"));
 }
 
 TEST_F(FileCheckTest, ParsePattern) {
   PatternTester Tester;
 
   // Space in pattern variable expression.
   EXPECT_TRUE(Tester.parsePatternExpect("[[ BAR]]"));
 
   // Invalid variable name.
   EXPECT_TRUE(Tester.parsePatternExpect("[[42INVALID]]"));
 
   // Invalid pattern variable definition.
TEST_F(FileCheckTest, ParsePattern) {
   EXPECT_FALSE(Tester.parsePatternExpect("[[PAT:[0-9]+]]"));
 
   // Invalid numeric expressions.
   EXPECT_TRUE(Tester.parsePatternExpect("[[#42INVALID]]"));
   EXPECT_TRUE(Tester.parsePatternExpect("[[#@FOO]]"));
   EXPECT_TRUE(Tester.parsePatternExpect("[[#@LINE/2]]"));
 
   // Valid numeric expressions and numeric variable definition.
   EXPECT_FALSE(Tester.parsePatternExpect("[[#FOO]]"));
   EXPECT_FALSE(Tester.parsePatternExpect("[[#@LINE+2]]"));
   EXPECT_FALSE(Tester.parsePatternExpect("[[#NUMVAR:]]"));
 }
 
 TEST_F(FileCheckTest, Match) {
   PatternTester Tester;
 
   // Check matching a definition only matches a number.
   Tester.parsePatternExpect("[[#NUMVAR:]]");
   EXPECT_TRUE(Tester.matchExpect("FAIL"));
   EXPECT_FALSE(Tester.matchExpect("18"));
 
   // Check matching the variable defined matches the correct number only
   Tester.initNextPattern();
   Tester.parsePatternExpect("[[#NUMVAR]] [[#NUMVAR+2]]");
   EXPECT_TRUE(Tester.matchExpect("19 21"));
   EXPECT_TRUE(Tester.matchExpect("18 21"));
   EXPECT_FALSE(Tester.matchExpect("18 20"));
 }
 
 TEST_F(FileCheckTest, Substitution) {
   SourceMgr SM;
   FileCheckPatternContext Context;
   std::vector<std::string> GlobalDefines;
   GlobalDefines.emplace_back(std::string("FOO=BAR"));
   Context.defineCmdlineVariables(GlobalDefines, SM);
 
   // Substitution of undefined pattern variable fails.
   FileCheckPatternSubstitution Substitution =
       FileCheckPatternSubstitution(&Context, "VAR404", 42);
   EXPECT_FALSE(Substitution.getResult());
 
   // Substitution of defined numeric variable returns the right value.
-  auto NumVarExpr = FileCheckNumExpr(nullptr);
+  auto NumVarExpr = FileCheckNumExpr(nullptr, FmtUnsigned);
   auto NumVar = std::make_shared<FileCheckNumericVariable>("N", &NumVarExpr, 1);
   NumVar->setValue(42);
-  FileCheckNumExpr NumExpr = FileCheckNumExpr(NumVar);
+  FileCheckNumExpr NumExpr = FileCheckNumExpr(NumVar, FmtUnsigned);
   Substitution = FileCheckPatternSubstitution(&Context, "N", &NumExpr, 12);
   llvm::Optional<std::string> Value = Substitution.getResult();
   EXPECT_TRUE(Value);
   EXPECT_EQ("42", *Value);
 
   // Substitution of undefined numeric variable fails.
   NumVar->clearValue();
   EXPECT_FALSE(Substitution.getResult());
TEST_F(FileCheckTest, UndefVars) {
   EXPECT_TRUE(UndefVarNames.empty());
 
   // Undef var in numeric expression substitution with defined variable is
   // empty.
   auto LineVar =
       std::make_shared<FileCheckNumericVariable>("@LINE", (uint64_t)42);
   auto Zero = std::make_shared<FileCheckNumExprLiteral>(0);
   auto Binop = std::make_shared<FileCheckASTBinop>(doAdd, LineVar, Zero);
-  FileCheckNumExpr NumExpr = FileCheckNumExpr(Binop);
+  FileCheckNumExpr NumExpr = FileCheckNumExpr(Binop, FmtUnsigned);
   Substitution = FileCheckPatternSubstitution(&Context, "@LINE", &NumExpr, 12);
   UndefVarNames.clear();
   Substitution.getUndefVarNames(UndefVarNames);
   EXPECT_TRUE(UndefVarNames.empty());
 
   // Undef var in valid numeric expression substitution is empty.
   // Undef var in numeric expression substitution with undefined variable
   // returns the variable.
TEST_F(FileCheckTest, FileCheckContext) {
   llvm::Optional<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   llvm::Optional<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
   EXPECT_TRUE(LocalVar);
   EXPECT_EQ(*LocalVar, "FOO");
   EXPECT_TRUE(NumExpr);
   llvm::Optional<uint64_t> NumExprVal = NumExpr->getAST()->eval();
   EXPECT_TRUE(NumExprVal);
   EXPECT_EQ(*NumExprVal, 18U);
   EXPECT_TRUE(EmptyVar);
   EXPECT_EQ(*EmptyVar, "");
   EXPECT_FALSE(UnknownVar);
 
   // Clear local variables and check they become absent.
   Cxt.clearLocalVars();
   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   EXPECT_FALSE(LocalVar);
   // Check eval fails even if we kept a pointer to the numeric expression.
   EXPECT_FALSE(NumExpr->getAST()->eval());
   P = FileCheckPattern(Check::CheckPlain, &Cxt, 2);
   NumExpr = P.parseNumericExpression(LocalNumVarRef, DefinedNumericVariable,
                                      false /*Legacy*/, SM);
   EXPECT_FALSE(NumExpr);
   EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
   EXPECT_FALSE(EmptyVar);
 
   // Redefine global variables and check variables are defined again.
   GlobalDefines.emplace_back(std::string("$GlobalVar=BAR"));
   GlobalDefines.emplace_back(std::string("#$GlobalNumVar=36"));
   GotError = Cxt.defineCmdlineVariables(GlobalDefines, SM);
   EXPECT_FALSE(GotError);
   StringRef GlobalVarStr = "$GlobalVar";
   StringRef GlobalNumVarRef = bufferize(SM, "$GlobalNumVar");