[MIRParser] Add parsing hex literals of arbitrary size as unsigned integers

[kparzysz]

Summary

The current code does not parse hex literals larger than 32-bit. Add a function that will parse a HexLiteral as APInt.

[kparzysz]

This came up when I changed the LaneBitmask type to uint64_t (for testing).

[MatzeB]

LGTM.

[kparzysz]

Committed in r289943.

lib/CodeGen/MIRParser/MIParser.cpp

private:
   /// Return true if an error occurred.
   bool getUnsigned(unsigned &Result);
 
   /// Convert the integer literal in the current token into an uint64.
   ///
   /// Return true if an error occurred.
   bool getUint64(uint64_t &Result);
 
+  /// Convert the hexadecimal literal in the current token into an unsigned
+  ///  APInt with a minimum bitwidth required to represent the value.
+  ///
+  /// Return true if the literal does not represent an integer value.
+  bool getHexUint(APInt &Result);
+
   /// If the current token is of the given kind, consume it and return false.
   /// Otherwise report an error and return true.
   bool expectAndConsume(MIToken::TokenKind TokenKind);
 
   /// If the current token is of the given kind, consume it and return true.
   /// Otherwise return false.
   bool consumeIfPresent(MIToken::TokenKind TokenKind);
 
if (Token.hasIntegerValue()) {
     const uint64_t Limit = uint64_t(std::numeric_limits<unsigned>::max()) + 1;
     uint64_t Val64 = Token.integerValue().getLimitedValue(Limit);
     if (Val64 == Limit)
       return error("expected 32-bit integer (too large)");
     Result = Val64;
     return false;
   }
   if (Token.is(MIToken::HexLiteral)) {
-    StringRef S = Token.range();
-    assert(S[0] == '0' && tolower(S[1]) == 'x');
-    // This could be a floating point literal with a special prefix.
-    if (!isxdigit(S[2]))
+    APInt A;
+    if (getHexUint(A))
       return true;
-    StringRef V = S.substr(2);
-    unsigned BW = std::min<unsigned>(V.size()*4, 32);
-    APInt A(BW, V, 16);
-    APInt Limit = APInt(BW, std::numeric_limits<unsigned>::max());
-    if (A.ugt(Limit))
+    if (A.getBitWidth() > 32)
       return error("expected 32-bit integer (too large)");
     Result = A.getZExtValue();
     return false;
   }
   return true;
 }
 
 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
default:
     llvm_unreachable("The current token should be an IR block reference");
   }
   if (!V)
     return error(Twine("use of undefined IR value '") + Token.range() + "'");
   return false;
 }
 
 bool MIParser::getUint64(uint64_t &Result) {
-  assert(Token.hasIntegerValue());
+  if (Token.hasIntegerValue()) {
     if (Token.integerValue().getActiveBits() > 64)
       return error("expected 64-bit integer (too large)");
     Result = Token.integerValue().getZExtValue();
     return false;
   }
+  if (Token.is(MIToken::HexLiteral)) {
+    APInt A;
+    if (getHexUint(A))
+      return true;
+    if (A.getBitWidth() > 64)
+      return error("expected 64-bit integer (too large)");
+    Result = A.getZExtValue();
+    return false;
+  }
+  return true;
+}
+
+bool MIParser::getHexUint(APInt &Result) {
+  assert(Token.is(MIToken::HexLiteral));
+  StringRef S = Token.range();
+  assert(S[0] == '0' && tolower(S[1]) == 'x');
+  // This could be a floating point literal with a special prefix.
+  if (!isxdigit(S[2]))
+    return true;
+  StringRef V = S.substr(2);
+  APInt A(V.size()*4, V, 16);
+  Result = APInt(A.getActiveBits(),
+                 ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
+  return false;
+}
 
 bool MIParser::parseMemoryOperandFlag(MachineMemOperand::Flags &Flags) {
   const auto OldFlags = Flags;
   switch (Token.kind()) {
   case MIToken::kw_volatile:
     Flags |= MachineMemOperand::MOVolatile;
     break;
   case MIToken::kw_non_temporal: