[MIRParser] Parse lane masks in block liveins

[kparzysz]

Summary

Add a token HexLiteral that contains uninterpreted hexadecimal string that could be either an integer, or a floating-point representation. When parsing block liveins, if a register name is followed by :, expect a lane mask value (either decimal or hexadecimal with 0x).

As it is now (even before this patch), there is no way to tell whether a hex value corresponds to an integer, or a floating-point. If floating-point literals were required to have a special prefix (which would be really, really nice), one could disambiguate between integers and floating-point values by just looking at the literal (which would be even nicer). This would remove the need for HexLiteral, which now needs to be interpreted further based on what is expected (which is not quite as nice as it could be).

May I suggest that floating-point hexadecimal values are required to have such a prefix? Because that would be really nice. :)

[MatzeB]

Have you seen https://reviews.llvm.org/D24208? This here is a good solution for that problem, LGTM.

lib/CodeGen/MIRParser/MILexer.cpp

449–452 ↗

(On Diff #74421)

If we find one of those hex prefixes we could go to FloatingPointLiteral immediately.

lib/CodeGen/MIRParser/MIParser.cpp

1150–1152 ↗

(On Diff #74421)

I don't like relying on numeric_limits<unsigned> here and would rather hardcode 32 to get consistent behaviour even if a platform has bigger unsigned numbers. But I realize this is in line with the existing code so we can fix that in a separate commit.

llvm/trunk/lib/CodeGen/MIRParser/MILexer.h

enum TokenKind {
     FixedStackObject,
     NamedGlobalValue,
     GlobalValue,
     ExternalSymbol,
 
     // Other tokens
     IntegerLiteral,
     FloatingPointLiteral,
+    HexLiteral,
     VirtualRegister,
     ConstantPoolItem,
     JumpTableIndex,
     NamedIRBlock,
     IRBlock,
     NamedIRValue,
     IRValue,
     QuotedIRValue, // `<constant value>`

llvm/trunk/lib/CodeGen/MIRParser/MILexer.cpp

static Cursor maybeLexExternalSymbol(Cursor C, MIToken &Token,
   return lexName(C, Token, MIToken::ExternalSymbol, /*PrefixLength=*/1,
                  ErrorCallback);
 }
 
 static bool isValidHexFloatingPointPrefix(char C) {
   return C == 'H' || C == 'K' || C == 'L' || C == 'M';
 }
 
-static Cursor maybeLexHexFloatingPointLiteral(Cursor C, MIToken &Token) {
-  if (C.peek() != '0' || C.peek(1) != 'x')
-    return None;
-  Cursor Range = C;
-  C.advance(2); // Skip '0x'
-  if (isValidHexFloatingPointPrefix(C.peek()))
-    C.advance();
-  while (isxdigit(C.peek()))
-    C.advance();
-  Token.reset(MIToken::FloatingPointLiteral, Range.upto(C));
-  return C;
-}
-
 static Cursor lexFloatingPointLiteral(Cursor Range, Cursor C, MIToken &Token) {
   C.advance();
   // Skip over [0-9]*([eE][-+]?[0-9]+)?
   while (isdigit(C.peek()))
     C.advance();
   if ((C.peek() == 'e' || C.peek() == 'E') &&
       (isdigit(C.peek(1)) ||
        ((C.peek(1) == '-' || C.peek(1) == '+') && isdigit(C.peek(2))))) {
     C.advance(2);
     while (isdigit(C.peek()))
       C.advance();
   }
   Token.reset(MIToken::FloatingPointLiteral, Range.upto(C));
   return C;
 }
 
+static Cursor maybeLexHexadecimalLiteral(Cursor C, MIToken &Token) {
+  if (C.peek() != '0' || (C.peek(1) != 'x' && C.peek(1) != 'X'))
+    return None;
+  Cursor Range = C;
+  C.advance(2);
+  unsigned PrefLen = 2;
+  if (isValidHexFloatingPointPrefix(C.peek())) {
+    C.advance();
+    PrefLen++;
+  }
+  while (isxdigit(C.peek()))
+    C.advance();
+  StringRef StrVal = Range.upto(C);
+  if (StrVal.size() <= PrefLen)
+    return None;
+  if (PrefLen == 2)
+    Token.reset(MIToken::HexLiteral, Range.upto(C));
+  else // It must be 3, which means that there was a floating-point prefix.
+    Token.reset(MIToken::FloatingPointLiteral, Range.upto(C));
+  return C;
+}
+
 static Cursor maybeLexNumericalLiteral(Cursor C, MIToken &Token) {
   if (!isdigit(C.peek()) && (C.peek() != '-' || !isdigit(C.peek(1))))
     return None;
   auto Range = C;
   C.advance();
   while (isdigit(C.peek()))
     C.advance();
   if (C.peek() == '.')
StringRef llvm::lexMIToken(StringRef Source, MIToken &Token,
   if (Cursor R = maybeLexIRValue(C, Token, ErrorCallback))
     return R.remaining();
   if (Cursor R = maybeLexRegister(C, Token))
     return R.remaining();
   if (Cursor R = maybeLexGlobalValue(C, Token, ErrorCallback))
     return R.remaining();
   if (Cursor R = maybeLexExternalSymbol(C, Token, ErrorCallback))
     return R.remaining();
-  if (Cursor R = maybeLexHexFloatingPointLiteral(C, Token))
+  if (Cursor R = maybeLexHexadecimalLiteral(C, Token))
     return R.remaining();
   if (Cursor R = maybeLexNumericalLiteral(C, Token))
     return R.remaining();
   if (Cursor R = maybeLexExlaim(C, Token, ErrorCallback))
     return R.remaining();
   if (Cursor R = maybeLexSymbol(C, Token))
     return R.remaining();
   if (Cursor R = maybeLexNewline(C, Token))

llvm/trunk/lib/CodeGen/MIRParser/MIParser.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/ModuleSlotTracker.h"
 #include "llvm/IR/ValueSymbolTable.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetIntrinsicInfo.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
+#include <cctype>
 
 using namespace llvm;
 
 PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
     SourceMgr &SM, const SlotMapping &IRSlots)
   : MF(MF), SM(&SM), IRSlots(IRSlots) {
 }
 
bool MIParser::parseBasicBlockLiveins(MachineBasicBlock &MBB) {
   if (Token.isNewlineOrEOF()) // Allow an empty list of liveins.
     return false;
   do {
     if (Token.isNot(MIToken::NamedRegister))
       return error("expected a named register");
     unsigned Reg = 0;
     if (parseNamedRegister(Reg))
       return true;
-    MBB.addLiveIn(Reg);
     lex();
+    LaneBitmask Mask = ~LaneBitmask(0);
+    if (consumeIfPresent(MIToken::colon)) {
+      // Parse lane mask.
+      if (Token.isNot(MIToken::IntegerLiteral) &&
+          Token.isNot(MIToken::HexLiteral))
+        return error("expected a lane mask");
+      static_assert(sizeof(LaneBitmask) == sizeof(unsigned), "");
+      if (getUnsigned(Mask))
+        return error("invalid lane mask value");
+      lex();
+    }
+    MBB.addLiveIn(Reg, Mask);
   } while (consumeIfPresent(MIToken::comma));
   return false;
 }
 
 bool MIParser::parseBasicBlockSuccessors(MachineBasicBlock &MBB) {
   assert(Token.is(MIToken::kw_successors));
   lex();
   if (expectAndConsume(MIToken::colon))
if (parseIRConstant(Loc, C))
     return true;
   Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
   return false;
 }
 
 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
   auto Loc = Token.location();
   lex();
-  if (Token.isNot(MIToken::FloatingPointLiteral))
+  if (Token.isNot(MIToken::FloatingPointLiteral) &&
+      Token.isNot(MIToken::HexLiteral))
     return error("expected a floating point literal");
   const Constant *C = nullptr;
   if (parseIRConstant(Loc, C))
     return true;
   Dest = MachineOperand::CreateFPImm(cast<ConstantFP>(C));
   return false;
 }
 
 bool MIParser::getUnsigned(unsigned &Result) {
-  assert(Token.hasIntegerValue() && "Expected a token with an integer value");
+  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]))
+      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))
+      return error("expected 32-bit integer (too large)");
+    Result = A.getZExtValue();
+    return false;
+  }
+  return true;
+}
 
 bool MIParser::parseMBBReference(MachineBasicBlock *&MBB) {
   assert(Token.is(MIToken::MachineBasicBlock) ||
          Token.is(MIToken::MachineBasicBlockLabel));
   unsigned Number;
   if (getUnsigned(Number))
     return true;
   auto MBBInfo = PFS.MBBSlots.find(Number);

llvm/trunk/lib/CodeGen/MIRPrinter.cpp

if (!MBB.livein_empty()) {
     OS.indent(2) << "liveins: ";
     bool First = true;
     for (const auto &LI : MBB.liveins()) {
       if (!First)
         OS << ", ";
       First = false;
       printReg(LI.PhysReg, OS, TRI);
       if (LI.LaneMask != ~0u)
-        OS << ':' << PrintLaneMask(LI.LaneMask);
+        OS << ":0x" << PrintLaneMask(LI.LaneMask);
     }
     OS << "\n";
     HasLineAttributes = true;
   }
 
   if (HasLineAttributes)
     OS << "\n";
   bool IsInBundle = false;

llvm/trunk/test/CodeGen/MIR/Hexagon/parse-lane-masks.mir

+# RUN: llc -march=hexagon -run-pass none -o - %s | FileCheck %s
+# Check that the MIR parser can parse lane masks in block liveins.
+
+# CHECK-LABEL: name: foo
+# CHECK: bb.0:
+# CHECK: liveins: %d0:0x00000002, %d1, %d2:0x00000010
+
+--- |
+  define void @foo() {
+    ret void
+  }
+...
+
+---
+name: foo
+tracksRegLiveness: true
+
+body: |
+  bb.0:
+    liveins: %d0:0x00002, %d1, %d2:16
+    A2_nop
+...
+