[MC][AsmParser] Add `MCTargetAsmParser::isStartOfInstruction` hook

[barannikov88]

Summary

This allows targets to indicate which tokens are valid at the start of
instructions. This is especially useful for targets with non-standard
assembly language syntax, e.g. BPF and Hexagon.

[barannikov88]

Rebase

llvm/include/llvm/MC/MCParser/MCTargetAsmParser.h

virtual bool areEqualRegs(const MCParsedAsmOperand &Op1,
                             const MCParsedAsmOperand &Op2) const {
     return Op1.isReg() && Op2.isReg() && Op1.getReg() == Op2.getReg();
   }
 
   // Return whether this parser uses assignment statements with equals tokens
   virtual bool equalIsAsmAssignment() { return true; };
   // Return whether this start of statement identifier is a label
   virtual bool isLabel(AsmToken &Token) { return true; };
-  // Return whether this parser accept star as start of statement
-  virtual bool starIsStartOfStatement() { return false; };
+  /// Returns whether this non-identifier token is valid at the start of an
+  /// instruction. Identifier tokens are always considered valid.
+  virtual bool isStartOfInstruction(const AsmToken &Token) { return false; }
 
   virtual const MCExpr *applyModifierToExpr(const MCExpr *E,
                                             MCSymbolRefExpr::VariantKind,
                                             MCContext &Ctx) {
     return nullptr;
   }
 
   // For actions that have to be performed before a label is emitted

llvm/lib/MC/MCParser/AsmParser.cpp

bool AsmParser::parseStatement(ParseStatementInfo &Info,
   SMLoc IDLoc = ID.getLoc();
   StringRef IDVal;
   int64_t LocalLabelVal = -1;
   StartTokLoc = ID.getLoc();
   if (Lexer.is(AsmToken::HashDirective))
     return parseCppHashLineFilenameComment(IDLoc,
                                            !isInsideMacroInstantiation());
 
-  // Allow an integer followed by a ':' as a directional local label.
-  if (Lexer.is(AsmToken::Integer)) {
-    LocalLabelVal = getTok().getIntVal();
-    if (LocalLabelVal < 0) {
-      if (!TheCondState.Ignore) {
-        Lex(); // always eat a token
-        return Error(IDLoc, "unexpected token at start of statement");
-      }
-      IDVal = "";
-    } else {
-      IDVal = getTok().getString();
-      Lex(); // Consume the integer token to be used as an identifier token.
-      if (Lexer.getKind() != AsmToken::Colon) {
-        if (!TheCondState.Ignore) {
-          Lex(); // always eat a token
-          return Error(IDLoc, "unexpected token at start of statement");
-        }
-      }
-    }
-  } else if (Lexer.is(AsmToken::Dot)) {
-    // Treat '.' as a valid identifier in this context.
-    Lex();
-    IDVal = ".";
-  } else if (Lexer.is(AsmToken::LCurly)) {
-    // Treat '{' as a valid identifier in this context.
-    Lex();
-    IDVal = "{";
-
-  } else if (Lexer.is(AsmToken::RCurly)) {
-    // Treat '}' as a valid identifier in this context.
-    Lex();
-    IDVal = "}";
-  } else if (Lexer.is(AsmToken::Star) &&
-             getTargetParser().starIsStartOfStatement()) {
-    // Accept '*' as a valid start of statement.
-    Lex();
-    IDVal = "*";
-  } else if (parseIdentifier(IDVal)) {
-    if (!TheCondState.Ignore) {
-      Lex(); // always eat a token
-      return Error(IDLoc, "unexpected token at start of statement");
-    }
-    IDVal = "";
+  // The identifier can be an empty string (""), hence the flag.
+  bool ParsedID = !parseIdentifier(IDVal);
+
+  // Check if this is a known assembler directive.
+  DirectiveKind DirKind = DK_NO_DIRECTIVE;
+  if (ParsedID) {
+    auto DirKindIt = DirectiveKindMap.find(IDVal.lower());
+    if (DirKindIt != DirectiveKindMap.end())
+      DirKind = DirKindIt->getValue();
   }
 
   // Handle conditional assembly here before checking for skipping.  We
   // have to do this so that .endif isn't skipped in a ".if 0" block for
   // example.
-  StringMap<DirectiveKind>::const_iterator DirKindIt =
-      DirectiveKindMap.find(IDVal.lower());
-  DirectiveKind DirKind = (DirKindIt == DirectiveKindMap.end())
-                              ? DK_NO_DIRECTIVE
-                              : DirKindIt->getValue();
   switch (DirKind) {
   default:
     break;
   case DK_IF:
   case DK_IFEQ:
   case DK_IFGE:
   case DK_IFGT:
   case DK_IFLE:
bool AsmParser::parseStatement(ParseStatementInfo &Info,
 
   // Ignore the statement if in the middle of inactive conditional
   // (e.g. ".if 0").
   if (TheCondState.Ignore) {
     eatToEndOfStatement();
     return false;
   }
 
+  // Check for the use of the '.' pseudo-symbol.
+  if (!ParsedID && Lexer.is(AsmToken::Dot)) {
+    // Diagnose attempt to use '.' as a label.
+    if (Lexer.peekTok().is(AsmToken::Colon)) {
+      Lex(); // Eat the '.'.
+      Lex(); // Eat the ':'.
+      return Error(IDLoc, "invalid use of pseudo-symbol '.' as a label");
+    }
+    // '.' followed by '=' is a valid start of an assignment statement.
+    if (Lexer.peekTok().is(AsmToken::Equal) &&
+        getTargetParser().equalIsAsmAssignment()) {
+      Lex(); // Eat the '.'.
+      Lex(); // Eat the '='.
+      return parseAssignment(".", AssignmentKind::Equal);
+    }
+  }
+
+  // Allow an integer followed by a ':' as a directional local label.
+  if (!ParsedID && Lexer.is(AsmToken::Integer)) {
+    LocalLabelVal = getTok().getIntVal();
+    if (LocalLabelVal < 0) {
+      Lex(); // always eat a token
+      return Error(IDLoc, "unexpected token at start of statement");
+    }
+    Lex(); // Consume the integer token.
+    if (Lexer.isNot(AsmToken::Colon)) {
+      Lex(); // always eat a token
+      return Error(IDLoc, "unexpected token at start of statement");
+    }
+  }
+
   // FIXME: Recurse on local labels?
 
   // Check for a label.
   //   ::= identifier ':'
   //   ::= number ':'
-  if (Lexer.is(AsmToken::Colon) && getTargetParser().isLabel(ID)) {
+  if ((ParsedID && Lexer.is(AsmToken::Colon) &&
+       getTargetParser().isLabel(ID)) ||
+      LocalLabelVal != -1) {
     if (checkForValidSection())
       return true;
 
     Lex(); // Consume the ':'.
 
     // Diagnose attempt to use '.' as a label.
     if (IDVal == ".")
       return Error(IDLoc, "invalid use of pseudo-symbol '.' as a label");
if ((ParsedID && Lexer.is(AsmToken::Colon) &&
 
     getTargetParser().onLabelParsed(Sym);
 
     return false;
   }
 
   // Check for an assignment statement.
   //   ::= identifier '='
-  if (Lexer.is(AsmToken::Equal) && getTargetParser().equalIsAsmAssignment()) {
-    Lex();
+  if (ParsedID && Lexer.is(AsmToken::Equal) &&
+      getTargetParser().equalIsAsmAssignment()) {
+    Lex(); // Eat the '='.
     return parseAssignment(IDVal, AssignmentKind::Equal);
   }
 
+  // Other generic assembler statements require an identifier at the start, but
+  // targets can allow other tokens at the beginning of instructions.
+  if (!ParsedID) {
+    if (getTargetParser().isStartOfInstruction(ID)) {
+      IDVal = getTok().getString();
+      Lex();
+      return parseAndMatchAndEmitTargetInstruction(Info, IDVal, ID, IDLoc);
+    }
+    Lex(); // always eat a token
+    return Error(IDLoc, "unexpected token at start of statement");
+  }
+
   // If macros are enabled, check to see if this is a macro instantiation.
   if (areMacrosEnabled())
     if (const MCAsmMacro *M = getContext().lookupMacro(IDVal)) {
       return handleMacroEntry(M, IDLoc);
     }
 
   // Otherwise, we have a normal instruction or directive.
 

llvm/lib/Target/BPF/AsmParser/BPFAsmParser.cpp

class BPFAsmParser : public MCTargetAsmParser {
   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override;
 
   bool ParseDirective(AsmToken DirectiveID) override;
 
   // "=" is used as assignment operator for assembly statment, so can't be used
   // for symbol assignment.
   bool equalIsAsmAssignment() override { return false; }
-  // "*" is used for dereferencing memory that it will be the start of
-  // statement.
-  bool starIsStartOfStatement() override { return true; }
+
+  bool isStartOfInstruction(const AsmToken &Token) override {
+    // "*" is used for dereferencing memory as in '*(u8 *)(r0 + 0) = r7'.
+    return Token.is(AsmToken::Star);
+  }
 
 #define GET_ASSEMBLER_HEADER
 #include "BPFGenAsmMatcher.inc"
 
   OperandMatchResultTy parseImmediate(OperandVector &Operands);
   OperandMatchResultTy parseRegister(OperandVector &Operands);
   OperandMatchResultTy parseOperandAsOperator(OperandVector &Operands);
 

llvm/lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp

MCAssembler *getAssembler() const {
     }
     return Assembler;
   }
 
   MCAsmLexer &getLexer() const { return Parser.getLexer(); }
 
   bool equalIsAsmAssignment() override { return false; }
   bool isLabel(AsmToken &Token) override;
+  bool isStartOfInstruction(const AsmToken &Token) override {
+    // Curly braces denote the start and the end of a packet.
+    return Token.is(AsmToken::LCurly) || Token.is(AsmToken::RCurly);
+  }
 
+private:
   void Warning(SMLoc L, const Twine &Msg) { Parser.Warning(L, Msg); }
   bool Error(SMLoc L, const Twine &Msg) { return Parser.Error(L, Msg); }
   bool ParseDirectiveFalign(unsigned Size, SMLoc L);
 
   bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                      SMLoc &EndLoc) override;
   OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                         SMLoc &EndLoc) override;

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

X86AsmParser(const MCSubtargetInfo &sti, MCAsmParser &Parser,
         Code16GCC(false) {
 
     Parser.addAliasForDirective(".word", ".2byte");
 
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(getSTI().getFeatureBits()));
   }
 
+  bool isStartOfInstruction(const AsmToken &Token) override {
+    // '{' can be used in prefixes, e.g. '{evex} vcvttss2si (%rdx), %r15'.
+    return Token.is(AsmToken::LCurly);
+  }
+
   bool parseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                      SMLoc &EndLoc) override;
   OperandMatchResultTy tryParseRegister(MCRegister &RegNo, SMLoc &StartLoc,
                                         SMLoc &EndLoc) override;
 
   bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
 
   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,