[FileCheck] Add support for hex alternate form in FileCheck

[thopre]

Summary

Add printf-style alternate form flag to prefix hex number with 0x when
present. This works on both empty numeric expression (e.g. variable
definition from input) and when matching a numeric expression. The
syntax is as follows:

[[#%#<precision specifier><format specifier>, ...]

where <precision specifier> and <format specifier> are optional and ...
can be a variable definition or not with an empty expression or not.

This feature was requested in https://reviews.llvm.org/D81144#2075532
for llvm/test/MC/ELF/gen-dwarf64.s

[jdenny]

llvm/lib/FileCheck/FileCheck.cpp

152

Is there a test for this diagnostic?

[jdenny]

llvm/lib/FileCheck/FileCheck.cpp

118–119

AlternateFormPrefix and SignPrefix are reversed relative to the version without leading zeroes below. Can it actually matter for hex? Regardless, it should probably be consistent.

llvm/lib/FileCheck/FileCheckImpl.h

57

Can we have a more exact name than AlternateForm? Maybe HexPrefix. If generality is better, then maybe TypePrefix.

[thopre]

Address comments

llvm/lib/FileCheck/FileCheck.cpp

118–119

It does not matter because the 0x prefix is only for hex format but I agree better to be consistent.

llvm/lib/FileCheck/FileCheckImpl.h

57

That is taken from printf's manual:

The character % is followed by zero or more of the following flags:

#      The value should be converted to an "alternate form".

For now it only applies to hex values but if we ever support one of the other format e.g. float format) then it would make sense to make it generic. I could rename it for now, we'll need to remember to rename it if a floating-point format gets supported at some point

[jhenderson]

I've not got the time at the moment to review this or the other recent FileCheck patches. Just wanted to say though that the idea looks good to me.

[jdenny]

llvm/docs/CommandGuide/FileCheck.rst

779

The subject is "flag" not "values".

llvm/lib/FileCheck/FileCheck.cpp

131

Based on the comments below, it seems the name OverflowErrorStr is misleading. It's a general integer parse error.

148–150

Does this edit say what you mean?

152

Thanks for the unit test.

Is this error possible within the normal FileCheck utility? That is, if the regex matched, then the match must have the prefix, right?

llvm/lib/FileCheck/FileCheckImpl.h

57

Ah, thanks, seems like the right name then. Maybe we can have a comment, such as:

/// Is a printf-like "alternate form" specified?

llvm/unittests/FileCheck/FileCheckTest.cpp

263

266

1095

How do you decide what cases to test here for the FileCheck library but not for the FileCheck utility? For example, I didn't find these cases tested for the utility. I'm not saying that's wrong. I'm just trying to figure out what the right approach is. I feel like we've discussed this before, but I've forgotten.

[thopre]

Address comments

llvm/lib/FileCheck/FileCheck.cpp

131

Fixed in D98342

152

Assuming there's no bug in the wildcard regex that indeed should not happen.

llvm/unittests/FileCheck/FileCheckTest.cpp

263

It's the addBasePrefix that should be removed because the goal is to check that every characters passed to checkWildcardRegexCharMatchFailure are rejected so the addBasePrefix is done inside the function for each of the characters. In retrospect checkWildcardRegexCharMatchFailure ought to take a vector instead of a string. I've fixed it in a separate patch.

266

Likewise.

1095

I'm using llvm/test/FileCheck are for user-level functionality and llvm/unittests/FileCheck for getting code coverage for individual functions. Obviously that creates some overlap (e.g. where to test error messages?) which I try to avoid by keeping details only in the unittesting. Any error that is important from a user point of view is likely to be tested twice though.

There might be some inconsistencies to that rule because I used to test function-level interface in unittest rather than focus on code coverage. I've tried to solve all of those in https://reviews.llvm.org/D72912 but I might have missed some.

For this specific error I probably should test it in numeric-expressions.txt as well (hence now done). Let me know if you disagree.

[jdenny]

LGTM. Thanks!

llvm/test/FileCheck/numeric-expression.txt

64–65

The above two lines are dead code, right?

llvm/unittests/FileCheck/FileCheckTest.cpp

1095

I'm not familiar enough with the users of the FileCheck library to know what the appropriate level of testing is in the unit tests. However, I think it's important to be sure that the FileCheck utility behaves correctly (end-to-end) for all its use cases, and that's hard to guarantee when only testing the library directly. So, thanks for the new tests.

[thopre]

llvm/test/FileCheck/numeric-expression.txt

64–65

Kind of but I want to have an otherwise valid input for an invalid check file.

llvm/docs/CommandGuide/FileCheck.rst

 ``[[#%<fmtspec>,<NUMVAR>:]]`` where:
 
 * ``%<fmtspec>,`` is an optional format specifier to indicate what number
   format to match and the minimum number of digits to expect.
 
 * ``<NUMVAR>:`` is an optional definition of variable ``<NUMVAR>`` from the
   captured value.
 
-The syntax of ``<fmtspec>`` is: ``.<precision><conversion specifier>`` where:
+The syntax of ``<fmtspec>`` is: ``#.<precision><conversion specifier>`` where:
 
+* ``#`` is an optional flag available for hex values (see
+  ``<conversion specifier>`` below) which require the value matched to be
+  prefixed by ``0x``.
 * ``.<precision>`` is an optional printf-style precision specifier in which
   ``<precision>`` indicates the minimum number of digits that the value matched
   must have, expecting leading zeros if needed.
 
 * ``<conversion specifier>`` is an optional scanf-style conversion specifier
   to indicate what number format to match (e.g. hex number).  Currently
   accepted format specifiers are ``%u``, ``%d``, ``%x`` and ``%X``.  If absent,
   the format specifier defaults to ``%u``.

llvm/lib/FileCheck/FileCheck.cpp

case Kind::HexUpper:
     return StringRef("%X");
   case Kind::HexLower:
     return StringRef("%x");
   }
   llvm_unreachable("unknown expression format");
 }
 
 Expected<std::string> ExpressionFormat::getWildcardRegex() const {
-  auto CreatePrecisionRegex = [this](StringRef S) {
-    return (S + Twine('{') + Twine(Precision) + "}").str();
+  StringRef AlternateFormPrefix = AlternateForm ? StringRef("0x") : StringRef();
+
+  auto CreatePrecisionRegex = [&](StringRef S) {
+    return (Twine(AlternateFormPrefix) + S + Twine('{') + Twine(Precision) +
+            "}")
+        .str();
   };
 
   switch (Value) {
   case Kind::Unsigned:
     if (Precision)
       return CreatePrecisionRegex("([1-9][0-9]*)?[0-9]");
     return std::string("[0-9]+");
   case Kind::Signed:
     if (Precision)
       return CreatePrecisionRegex("-?([1-9][0-9]*)?[0-9]");
     return std::string("-?[0-9]+");
   case Kind::HexUpper:
     if (Precision)
       return CreatePrecisionRegex("([1-9A-F][0-9A-F]*)?[0-9A-F]");
-    return std::string("[0-9A-F]+");
+    return (Twine(AlternateFormPrefix) + Twine("[0-9A-F]+")).str();
   case Kind::HexLower:
     if (Precision)
       return CreatePrecisionRegex("([1-9a-f][0-9a-f]*)?[0-9a-f]");
-    return std::string("[0-9a-f]+");
+    return (Twine(AlternateFormPrefix) + Twine("[0-9a-f]+")).str();
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 }
 
 Expected<std::string>
 ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const {
ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const {
   case Kind::HexLower:
     AbsoluteValueStr = utohexstr(AbsoluteValue, Value == Kind::HexLower);
     break;
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 
+  StringRef AlternateFormPrefix = AlternateForm ? StringRef("0x") : StringRef();
+
   if (Precision > AbsoluteValueStr.size()) {
     unsigned LeadingZeros = Precision - AbsoluteValueStr.size();
-    return (Twine(SignPrefix) + std::string(LeadingZeros, '0') +
-            AbsoluteValueStr)
+    return (Twine(SignPrefix) + Twine(AlternateFormPrefix) +
+            std::string(LeadingZeros, '0') + AbsoluteValueStr)
         .str();
   }
 
-  return (Twine(SignPrefix) + AbsoluteValueStr).str();
+  return (Twine(SignPrefix) + Twine(AlternateFormPrefix) + AbsoluteValueStr)
+      .str();
 }
 
 Expected<ExpressionValue>
 ExpressionFormat::valueFromStringRepr(StringRef StrVal,
                                       const SourceMgr &SM) const {
   bool ValueIsSigned = Value == Kind::Signed;
   StringRef OverflowErrorStr = "unable to represent numeric value";
+
   if (ValueIsSigned) {
     int64_t SignedValue;
 
     if (StrVal.getAsInteger(10, SignedValue))
       return ErrorDiagnostic::get(SM, StrVal, OverflowErrorStr);
 
     return ExpressionValue(SignedValue);
   }
 
   bool Hex = Value == Kind::HexUpper || Value == Kind::HexLower;
   uint64_t UnsignedValue;
+  bool MissingFormPrefix = AlternateForm && !StrVal.consume_front("0x");
   if (StrVal.getAsInteger(Hex ? 16 : 10, UnsignedValue))
     return ErrorDiagnostic::get(SM, StrVal, OverflowErrorStr);
 
+  // Error out for prefix only if failing to parse integer because that
+  // indicates a more serious issue with the input. It also avoid giving a
+  // prefix error for e.g. -0x18.
+  if (MissingFormPrefix)
+    return ErrorDiagnostic::get(SM, StrVal, "missing alternate form prefix");
+
   return ExpressionValue(UnsignedValue);
 }
 
 static int64_t getAsSigned(uint64_t UnsignedValue) {
   // Use memcpy to reinterpret the bitpattern in Value since casting to
   // signed is implementation-defined if the unsigned value is too big to be
   // represented in the signed type and using an union violates type aliasing
   // rules.
if (FormatSpecEnd != StringRef::npos && FormatSpecEnd < FunctionStart) {
     StringRef FormatExpr = Expr.take_front(FormatSpecEnd);
     Expr = Expr.drop_front(FormatSpecEnd + 1);
     FormatExpr = FormatExpr.trim(SpaceChars);
     if (!FormatExpr.consume_front("%"))
       return ErrorDiagnostic::get(
           SM, FormatExpr,
           "invalid matching format specification in expression");
 
+    // Parse alternate form flag.
+    SMLoc AlternateFormFlagLoc = SMLoc::getFromPointer(FormatExpr.data());
+    bool AlternateForm = FormatExpr.consume_front("#");
+
     // Parse precision.
     if (FormatExpr.consume_front(".")) {
       if (FormatExpr.consumeInteger(10, Precision))
         return ErrorDiagnostic::get(SM, FormatExpr,
                                     "invalid precision in format specifier");
     }
 
     if (!FormatExpr.empty()) {
       // Check for unknown matching format specifier and set matching format in
       // class instance representing this expression.
       SMLoc FmtLoc = SMLoc::getFromPointer(FormatExpr.data());
       switch (popFront(FormatExpr)) {
       case 'u':
         ExplicitFormat =
             ExpressionFormat(ExpressionFormat::Kind::Unsigned, Precision);
         break;
       case 'd':
         ExplicitFormat =
             ExpressionFormat(ExpressionFormat::Kind::Signed, Precision);
         break;
       case 'x':
-        ExplicitFormat =
-            ExpressionFormat(ExpressionFormat::Kind::HexLower, Precision);
+        ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::HexLower,
+                                          Precision, AlternateForm);
         break;
       case 'X':
-        ExplicitFormat =
-            ExpressionFormat(ExpressionFormat::Kind::HexUpper, Precision);
+        ExplicitFormat = ExpressionFormat(ExpressionFormat::Kind::HexUpper,
+                                          Precision, AlternateForm);
         break;
       default:
         return ErrorDiagnostic::get(SM, FmtLoc,
                                     "invalid format specifier in expression");
       }
     }
 
+    if (AlternateForm && ExplicitFormat != ExpressionFormat::Kind::HexLower &&
+        ExplicitFormat != ExpressionFormat::Kind::HexUpper)
+      return ErrorDiagnostic::get(
+          SM, AlternateFormFlagLoc,
+          "alternate form only supported for hex values");
+
     FormatExpr = FormatExpr.ltrim(SpaceChars);
     if (!FormatExpr.empty())
       return ErrorDiagnostic::get(
           SM, FormatExpr,
           "invalid matching format specification in expression");
   }
 
   // Save variable definition expression if any.

llvm/lib/FileCheck/FileCheckImpl.h

enum class Kind {
     HexUpper,
     /// Value should be printed as a lowercase hex number.
     HexLower
   };
 
 private:
   Kind Value;
   unsigned Precision = 0;
+  bool AlternateForm = false;
 
 public:
   /// Evaluates a format to true if it can be used in a match.
   explicit operator bool() const { return Value != Kind::NoFormat; }
 
   /// Define format equality: formats are equal if neither is NoFormat and
   /// their kinds and precision are the same.
   bool operator==(const ExpressionFormat &Other) const {
     return Value != Kind::NoFormat && Value == Other.Value &&
-           Precision == Other.Precision;
+           Precision == Other.Precision && AlternateForm == Other.AlternateForm;
   }
 
   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); }
 
   /// \returns the format specifier corresponding to this format as a string.
   StringRef toString() const;
 
   ExpressionFormat() : Value(Kind::NoFormat){};
   explicit ExpressionFormat(Kind Value) : Value(Value), Precision(0){};
   explicit ExpressionFormat(Kind Value, unsigned Precision)
       : Value(Value), Precision(Precision){};
+  explicit ExpressionFormat(Kind Value, unsigned Precision, bool AlternateForm)
+      : Value(Value), Precision(Precision), AlternateForm(AlternateForm){};
 
   /// \returns a wildcard regular expression string that matches any value in
   /// the format represented by this instance and no other value, or an error
   /// if the format is NoFormat.
   Expected<std::string> getWildcardRegex() const;
 
   /// \returns the string representation of \p Value in the format represented
   /// by this instance, or an error if conversion to this format failed or the

llvm/test/FileCheck/numeric-expression.txt

 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 variable definition of hex value with 0x prefix.
+DEF ALT FORM  // CHECK-LABEL: DEF ALT FORM
+0xf  // CHECK-NEXT: {{^}}[[#%#x,PREFIXED_LHEX:]]
+0xE  // CHECK-NEXT: {{^}}[[#%#X,PREFIXED_UHEX:]]
+
+; Numeric variable definition of hex value with missing 0x prefix.
+RUN: FileCheck --check-prefix INVALID-HEX-PREFIX-DEF --input-file %s %s
+
+FAIL DEF ALT FORM  // INVALID-HEX-PREFIX-DEF-LABEL: FAIL DEF ALT FORM
+INVALID_PREFIXED_LHEX: xf   // INVALID-HEX-PREFIX-DEF-NOT: {{^}}INVALID_PREFIXED_LHEX: [[#%#x,INVALID_PREFIXED_LHEX:]]
+INVALID_PREFIXED_UHEX: 0E   // INVALID-HEX-PREFIX-DEF-NOT: {{^}}INVALID_PREFIXED_UHEX: [[#%#X,INVALID_PREFIXED_UHEX:]]
+
 ; Numeric variable definition with precision specifier.
 DEF PREC FMT  // CHECK-LABEL: DEF PREC FMT
 00000022    // CHECK-NEXT: {{^}}[[#%.8,PADDED_UNSI:]]
 323232323   // CHECK-NEXT: {{^}}[[#%.8,PADDED_UNSI2:]]
 00000018    // CHECK-NEXT: {{^}}[[#%.8u,PADDED_UNSI3:]]
 181818181   // CHECK-NEXT: {{^}}[[#%.8u,PADDED_UNSI4:]]
 0000000f    // CHECK-NEXT: {{^}}[[#%.8x,PADDED_LHEX:]]
 fffffffff   // CHECK-NEXT: {{^}}[[#%.8x,PADDED_LHEX2:]]
 0000000E    // CHECK-NEXT: {{^}}[[#%.8X,PADDED_UHEX:]]
 EEEEEEEEE   // CHECK-NEXT: {{^}}[[#%.8X,PADDED_UHEX2:]]

 13  // CHECK-NEXT: {{^}}[[# %u , add(UNSI,2)]]
 13  // CHECK-NEXT: {{^}}[[# %u , add(UNSI, 2)]]
 13  // CHECK-NEXT: {{^}}[[# %u , add( UNSI, 2)]]
 13  // CHECK-NEXT: {{^}}[[# %u , add( UNSI,2)]]
 13  // CHECK-NEXT: {{^}}[[# %u , add(UNSI,2) ]]
 13  // CHECK-NEXT: {{^}}[[# %u , add (UNSI,2)]]
 104 // CHECK-NEXT: {{^}}[[# %u , UNSI + sub( add (100 , UNSI+ 1 ), 20) +1 ]]
 
-; Numeric expressions with explicit matching format, precision, and default
-; matching rule using variables defined on other lines without spaces.
+; Numeric expressions with explicit matching format, precision, form and
+; default matching rule using variables defined on other lines without spaces.
 USE EXPL FMT WITH PREC IMPL MATCH  // CHECK-LABEL: USE EXPL FMT WITH PREC IMPL MATCH
-11         // CHECK-NEXT: {{^}}[[#%.1u,UNSI]]
-00000011   // CHECK-NEXT: {{^}}[[#%.8u,UNSI]]
-1c         // CHECK-NEXT: {{^}}[[#%.1x,LHEX+16]]
-0000000c   // CHECK-NEXT: {{^}}[[#%.8x,LHEX]]
-1D         // CHECK-NEXT: {{^}}[[#%.1X,UHEX+16]]
-0000000D   // CHECK-NEXT: {{^}}[[#%.8X,UHEX]]
--30        // CHECK-NEXT: {{^}}[[#%.1d,SIGN]]
--00000030  // CHECK-NEXT: {{^}}[[#%.8d,SIGN]]
+11          // CHECK-NEXT: {{^}}[[#%.1u,UNSI]]
+00000011    // CHECK-NEXT: {{^}}[[#%.8u,UNSI]]
+1c          // CHECK-NEXT: {{^}}[[#%.1x,LHEX+16]]
+0x1c        // CHECK-NEXT: {{^}}[[#%#.1x,LHEX+16]]
+0000000c    // CHECK-NEXT: {{^}}[[#%.8x,LHEX]]
+0x0000000c  // CHECK-NEXT: {{^}}[[#%#.8x,LHEX]]
+1D          // CHECK-NEXT: {{^}}[[#%.1X,UHEX+16]]
+0x1D        // CHECK-NEXT: {{^}}[[#%#.1X,UHEX+16]]
+0000000D    // CHECK-NEXT: {{^}}[[#%.8X,UHEX]]
+0x0000000D  // CHECK-NEXT: {{^}}[[#%#.8X,UHEX]]
+-30         // CHECK-NEXT: {{^}}[[#%.1d,SIGN]]
+-00000030   // CHECK-NEXT: {{^}}[[#%.8d,SIGN]]
 
 ; Numeric expressions with explicit matching format, precision and wrong
 ; padding, and default matching rule using variables defined on other lines
 ; without spaces.
 RUN: FileCheck --check-prefixes CHECK,INVALID-PADDING-EXPL-USE --input-file %s %s
 
 FAIL USE IMPL FMT WITH PREC EXPL MATCH  // INVALID-PADDING-EXPL-USE-LABEL: FAIL USE IMPL FMT WITH PREC IMPL MATCH
 INVALID UNSI+1: 0000012     // INVALID-PADDING-EXPL-USE-NOT: {{^}}INVALID UNSI+1: [[#%.8u,UNSI+1]]

llvm/unittests/FileCheck/FileCheckTest.cpp

 constexpr int64_t MaxInt64 = std::numeric_limits<int64_t>::max();
 constexpr int64_t MinInt64 = std::numeric_limits<int64_t>::min();
 constexpr uint64_t AbsoluteMinInt64 =
     static_cast<uint64_t>(-(MinInt64 + 1)) + 1;
 constexpr uint64_t AbsoluteMaxInt64 = static_cast<uint64_t>(MaxInt64);
 
 struct ExpressionFormatParameterisedFixture
     : public ::testing::TestWithParam<
-          std::pair<ExpressionFormat::Kind, unsigned>> {
+          std::tuple<ExpressionFormat::Kind, unsigned, bool>> {
+  bool AlternateForm;
   unsigned Precision;
   bool Signed;
   bool AllowHex;
   bool AllowUpperHex;
   ExpressionFormat Format;
   Regex WildcardRegex;
 
   StringRef TenStr;
   StringRef FifteenStr;
   std::string MaxUint64Str;
   std::string MaxInt64Str;
   std::string MinInt64Str;
   StringRef FirstInvalidCharDigits;
   StringRef AcceptedHexOnlyDigits;
   StringRef RefusedHexOnlyDigits;
 
   SourceMgr SM;
 
   void SetUp() override {
     ExpressionFormat::Kind Kind;
-    std::tie(Kind, Precision) = GetParam();
+    std::tie(Kind, Precision, AlternateForm) = GetParam();
     AllowHex = Kind == ExpressionFormat::Kind::HexLower ||
                Kind == ExpressionFormat::Kind::HexUpper;
     AllowUpperHex = Kind == ExpressionFormat::Kind::HexUpper;
     Signed = Kind == ExpressionFormat::Kind::Signed;
-    Format = ExpressionFormat(Kind, Precision);
+    Format = ExpressionFormat(Kind, Precision, AlternateForm);
 
     if (!AllowHex) {
       MaxUint64Str = std::to_string(MaxUint64);
       MaxInt64Str = std::to_string(MaxInt64);
       MinInt64Str = std::to_string(MinInt64);
       TenStr = "10";
       FifteenStr = "15";
       FirstInvalidCharDigits = "aA";
       AcceptedHexOnlyDigits = RefusedHexOnlyDigits = "N/A";
       return;
     }
 
     MaxUint64Str = AllowUpperHex ? "FFFFFFFFFFFFFFFF" : "ffffffffffffffff";
     MaxInt64Str = AllowUpperHex ? "7FFFFFFFFFFFFFFF" : "7fffffffffffffff";
     TenStr = AllowUpperHex ? "A" : "a";
     FifteenStr = AllowUpperHex ? "F" : "f";
     AcceptedHexOnlyDigits = AllowUpperHex ? "ABCDEF" : "abcdef";
     RefusedHexOnlyDigits = AllowUpperHex ? "abcdef" : "ABCDEF";
     MinInt64Str = "N/A";
     FirstInvalidCharDigits = "gG";
   }
 
   void checkWildcardRegexMatch(StringRef Input,
                                unsigned TrailExtendTo = 0) const {
+    ASSERT_TRUE(TrailExtendTo == 0 || AllowHex);
     SmallVector<StringRef, 4> Matches;
     std::string ExtendedInput = Input.str();
-    if (TrailExtendTo > Input.size()) {
-      ExtendedInput.append(TrailExtendTo - Input.size(), Input[0]);
+    size_t PrefixSize = AlternateForm ? 2 : 0;
+    if (TrailExtendTo > Input.size() - PrefixSize) {
+      size_t ExtensionSize = PrefixSize + TrailExtendTo - Input.size();
+      ExtendedInput.append(ExtensionSize, Input[PrefixSize]);
     }
     ASSERT_TRUE(WildcardRegex.match(ExtendedInput, &Matches))
         << "Wildcard regex does not match " << ExtendedInput;
     EXPECT_EQ(Matches[0], ExtendedInput);
   }
 
   void checkWildcardRegexMatchFailure(StringRef Input) const {
     EXPECT_FALSE(WildcardRegex.match(Input));
   }
 
+  std::string addBasePrefix(StringRef Num) const {
+    StringRef Prefix = AlternateForm ? "0x" : "";
+    return (Twine(Prefix) + Twine(Num)).str();
+  }
+
   void checkWildcardRegexCharMatchFailure(StringRef Chars) const {
-    for (auto C : Chars)
-      EXPECT_FALSE(WildcardRegex.match(StringRef(&C, 1)));
+    for (auto C : Chars) {
+      std::string Str = addBasePrefix(StringRef(&C, 1));
+      EXPECT_FALSE(WildcardRegex.match(Str));
+    }
   }
 
   std::string padWithLeadingZeros(StringRef NumStr) const {
     bool Negative = NumStr.startswith("-");
     if (NumStr.size() - unsigned(Negative) >= Precision)
       return NumStr.str();
 
     std::string PaddedStr;
void checkValueFromStringRepr(StringRef Str, T ExpectedVal) {
     if (ResultValue->isNegative())
       EXPECT_EQ(cantFail(ResultValue->getSignedValue()),
                 static_cast<int64_t>(ExpectedVal));
     else
       EXPECT_EQ(cantFail(ResultValue->getUnsignedValue()),
                 static_cast<uint64_t>(ExpectedVal));
   }
 
-  void checkValueFromStringReprFailure(StringRef Str) {
-    StringRef OverflowErrorStr = "unable to represent numeric value";
+  void checkValueFromStringReprFailure(
+      StringRef Str, StringRef ErrorStr = "unable to represent numeric value") {
     Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
-    expectDiagnosticError(OverflowErrorStr, ResultValue.takeError());
+    expectDiagnosticError(ErrorStr, ResultValue.takeError());
   }
 };
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) {
   // Wildcard regex is valid.
   Expected<std::string> WildcardPattern = Format.getWildcardRegex();
   ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded());
   WildcardRegex = Regex((Twine("^") + *WildcardPattern + "$").str());
   ASSERT_TRUE(WildcardRegex.isValid());
 
   // Does not match empty string.
   checkWildcardRegexMatchFailure("");
 
-  // Matches all decimal digits and matches several of them.
+  // Matches all decimal digits, matches several of them and match 0x prefix
+  // if and only if AlternateForm is true.
   StringRef LongNumber = "12345678901234567890";
+  StringRef PrefixedLongNumber = "0x12345678901234567890";
+  if (AlternateForm) {
+    checkWildcardRegexMatch(PrefixedLongNumber);
+    checkWildcardRegexMatchFailure(LongNumber);
+  } else {
     checkWildcardRegexMatch(LongNumber);
+    checkWildcardRegexMatchFailure(PrefixedLongNumber);
+  }
 
   // Matches negative digits.
   LongNumber = "-12345678901234567890";
   if (Signed)
     checkWildcardRegexMatch(LongNumber);
   else
     checkWildcardRegexMatchFailure(LongNumber);
 
   // Check non digits or digits with wrong casing are not matched.
+  std::string LongNumberStr;
   if (AllowHex) {
-    checkWildcardRegexMatch(AcceptedHexOnlyDigits, 16);
+    LongNumberStr = addBasePrefix(AcceptedHexOnlyDigits);
+    checkWildcardRegexMatch(LongNumberStr, 16);
+    LongNumberStr = addBasePrefix(RefusedHexOnlyDigits);
     checkWildcardRegexCharMatchFailure(RefusedHexOnlyDigits);
   }
+  LongNumberStr = addBasePrefix(FirstInvalidCharDigits);
   checkWildcardRegexCharMatchFailure(FirstInvalidCharDigits);
 
   // Check leading zeros are only accepted if number of digits is less than the
   // precision.
   LongNumber = "01234567890123456789";
   if (Precision) {
-    checkWildcardRegexMatch(LongNumber.take_front(Precision));
-    checkWildcardRegexMatchFailure(LongNumber.take_front(Precision - 1));
-    if (Precision < LongNumber.size())
-      checkWildcardRegexMatchFailure(LongNumber.take_front(Precision + 1));
-  } else
-    checkWildcardRegexMatch(LongNumber);
+    LongNumberStr = addBasePrefix(LongNumber.take_front(Precision));
+    checkWildcardRegexMatch(LongNumberStr);
+    LongNumberStr = addBasePrefix(LongNumber.take_front(Precision - 1));
+    checkWildcardRegexMatchFailure(LongNumberStr);
+    if (Precision < LongNumber.size()) {
+      LongNumberStr = addBasePrefix(LongNumber.take_front(Precision + 1));
+      checkWildcardRegexMatchFailure(LongNumberStr);
+    }
+  } else {
+    LongNumberStr = addBasePrefix(LongNumber);
+    checkWildcardRegexMatch(LongNumberStr);
+  }
 }
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatGetMatchingString) {
-  checkMatchingString(0, padWithLeadingZeros("0"));
-  checkMatchingString(9, padWithLeadingZeros("9"));
+  checkMatchingString(0, addBasePrefix(padWithLeadingZeros("0")));
+  checkMatchingString(9, addBasePrefix(padWithLeadingZeros("9")));
 
   if (Signed) {
     checkMatchingString(-5, padWithLeadingZeros("-5"));
     checkMatchingStringFailure(MaxUint64);
     checkMatchingString(MaxInt64, padWithLeadingZeros(MaxInt64Str));
     checkMatchingString(MinInt64, padWithLeadingZeros(MinInt64Str));
   } else {
     checkMatchingStringFailure(-5);
-    checkMatchingString(MaxUint64, padWithLeadingZeros(MaxUint64Str));
-    checkMatchingString(MaxInt64, padWithLeadingZeros(MaxInt64Str));
+    checkMatchingString(MaxUint64,
+                        addBasePrefix(padWithLeadingZeros(MaxUint64Str)));
+    checkMatchingString(MaxInt64,
+                        addBasePrefix(padWithLeadingZeros(MaxInt64Str)));
     checkMatchingStringFailure(MinInt64);
   }
 
-  checkMatchingString(10, padWithLeadingZeros(TenStr));
-  checkMatchingString(15, padWithLeadingZeros(FifteenStr));
+  checkMatchingString(10, addBasePrefix(padWithLeadingZeros(TenStr)));
+  checkMatchingString(15, addBasePrefix(padWithLeadingZeros(FifteenStr)));
 }
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatValueFromStringRepr) {
-  checkValueFromStringRepr("0", 0);
-  checkValueFromStringRepr("9", 9);
+  checkValueFromStringRepr(addBasePrefix("0"), 0);
+  checkValueFromStringRepr(addBasePrefix("9"), 9);
 
   if (Signed) {
     checkValueFromStringRepr("-5", -5);
     checkValueFromStringReprFailure(MaxUint64Str);
   } else {
-    checkValueFromStringReprFailure("-5");
-    checkValueFromStringRepr(MaxUint64Str, MaxUint64);
+    checkValueFromStringReprFailure("-" + addBasePrefix("5"));
+    checkValueFromStringRepr(addBasePrefix(MaxUint64Str), MaxUint64);
   }
 
-  checkValueFromStringRepr(TenStr, 10);
-  checkValueFromStringRepr(FifteenStr, 15);
+  checkValueFromStringRepr(addBasePrefix(TenStr), 10);
+  checkValueFromStringRepr(addBasePrefix(FifteenStr), 15);
 
   // Wrong casing is not tested because valueFromStringRepr() relies on
   // StringRef's getAsInteger() which does not allow to restrict casing.
-  checkValueFromStringReprFailure("G");
+  checkValueFromStringReprFailure(addBasePrefix("G"));
+
+  if (AlternateForm)
+    checkValueFromStringReprFailure("9", "missing alternate form prefix");
 }
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatBoolOperator) {
   EXPECT_TRUE(bool(Format));
 }
 
 INSTANTIATE_TEST_CASE_P(
     AllowedExplicitExpressionFormat, ExpressionFormatParameterisedFixture,
-    ::testing::Values(std::make_pair(ExpressionFormat::Kind::Unsigned, 0),
-                      std::make_pair(ExpressionFormat::Kind::Signed, 0),
-                      std::make_pair(ExpressionFormat::Kind::HexLower, 0),
-                      std::make_pair(ExpressionFormat::Kind::HexUpper, 0),
-
-                      std::make_pair(ExpressionFormat::Kind::Unsigned, 1),
-                      std::make_pair(ExpressionFormat::Kind::Signed, 1),
-                      std::make_pair(ExpressionFormat::Kind::HexLower, 1),
-                      std::make_pair(ExpressionFormat::Kind::HexUpper, 1),
-
-                      std::make_pair(ExpressionFormat::Kind::Unsigned, 16),
-                      std::make_pair(ExpressionFormat::Kind::Signed, 16),
-                      std::make_pair(ExpressionFormat::Kind::HexLower, 16),
-                      std::make_pair(ExpressionFormat::Kind::HexUpper, 16),
+    ::testing::Values(
+        std::make_tuple(ExpressionFormat::Kind::Unsigned, 0, false),
+        std::make_tuple(ExpressionFormat::Kind::Signed, 0, false),
+        std::make_tuple(ExpressionFormat::Kind::HexLower, 0, false),
+        std::make_tuple(ExpressionFormat::Kind::HexLower, 0, true),
+        std::make_tuple(ExpressionFormat::Kind::HexUpper, 0, false),
+        std::make_tuple(ExpressionFormat::Kind::HexUpper, 0, true),
+
+        std::make_tuple(ExpressionFormat::Kind::Unsigned, 1, false),
+        std::make_tuple(ExpressionFormat::Kind::Signed, 1, false),
+        std::make_tuple(ExpressionFormat::Kind::HexLower, 1, false),
+        std::make_tuple(ExpressionFormat::Kind::HexLower, 1, true),
+        std::make_tuple(ExpressionFormat::Kind::HexUpper, 1, false),
+        std::make_tuple(ExpressionFormat::Kind::HexUpper, 1, true),
+
+        std::make_tuple(ExpressionFormat::Kind::Unsigned, 16, false),
+        std::make_tuple(ExpressionFormat::Kind::Signed, 16, false),
+        std::make_tuple(ExpressionFormat::Kind::HexLower, 16, false),
+        std::make_tuple(ExpressionFormat::Kind::HexLower, 16, true),
+        std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, false),
+        std::make_tuple(ExpressionFormat::Kind::HexUpper, 16, true),
 
-                      std::make_pair(ExpressionFormat::Kind::Unsigned, 20),
-                      std::make_pair(ExpressionFormat::Kind::Signed, 20)), );
+        std::make_tuple(ExpressionFormat::Kind::Unsigned, 20, false),
+        std::make_tuple(ExpressionFormat::Kind::Signed, 20, false)), );
 
 TEST_F(FileCheckTest, NoFormatProperties) {
   ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
   expectError<StringError>("trying to match value with invalid format",
                            NoFormat.getWildcardRegex().takeError());
   expectError<StringError>(
       "trying to match value with invalid format",
       NoFormat.getMatchingString(ExpressionValue(18u)).takeError());
TEST_F(FileCheckTest, ParseNumericSubstitutionBlock) {
   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 with precision specifier.
   EXPECT_FALSE(Tester.parsePattern("[[#%.8X, PADDED_ADDR:]]"));
   EXPECT_FALSE(Tester.parsePattern("[[#%.8, PADDED_NUM:]]"));
 
+  // Acceptable variable definition in alternate form.
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("%#x, PREFIXED_ADDR:"), Succeeded());
+  EXPECT_THAT_EXPECTED(Tester.parseSubst("%#X, PREFIXED_ADDR:"), Succeeded());
+
+  // Acceptable variable definition in alternate form.
+  expectDiagnosticError("alternate form only supported for hex values",
+                        Tester.parseSubst("%#u, PREFIXED_UNSI:").takeError());
+  expectDiagnosticError("alternate form only supported for hex values",
+                        Tester.parseSubst("%#d, PREFIXED_UNSI:").takeError());
+
   // Acceptable variable definition from a numeric expression.
   EXPECT_THAT_EXPECTED(Tester.parseSubst("FOOBAR: FOO+1"), Succeeded());
 
   // Numeric expression. Switch to next line to make above valid definition
   // available in expressions.
   Tester.initNextPattern();
 
   // Invalid variable name.