[AsmParser] Provide direct access to mnemonic token. Allow assignment parsing to be hooked by target. Allow target to specify if identifier is a label.

[colinl]

Summary

This allows AsmParsers to directly access the first token of a statement. This was creating an issue for statements that aren't lead by a token other than an identifier.

This also creates target hooks for checking if an identifier is a label and if AsmParser itself should parse assignment expressions.

"r31:30 = r21:20" is a register assignment. This trips up the parser because "r31:" looks like a label and an equals sign tells it to parse this as an assignment expression instead of an instruction.

[chandlerc]

And here is yet another commit that you landed without getting an LGTM from
anyone.

llvm/trunk/include/llvm/MC/MCTargetAsmParser.h

public:
   //
   /// \param Name - The instruction name.
   /// \param NameLoc - The source location of the name.
   /// \param Operands [out] - The list of parsed operands, this returns
   ///        ownership of them to the caller.
   /// \return True on failure.
   virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                 SMLoc NameLoc, OperandVector &Operands) = 0;
+  virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
+                                AsmToken Token, OperandVector &Operands) {
+    return ParseInstruction(Info, Name, Token.getLoc(), Operands);
+  }
 
   /// ParseDirective - Parse a target specific assembler directive
   ///
   /// The parser is positioned following the directive name.  The target
   /// specific directive parser should parse the entire directive doing or
   /// recording any target specific work, or return true and do nothing if the
   /// directive is not target specific. If the directive is specific for
   /// the target, the entire line is parsed up to and including the
public:
   /// any complex target predicates not expressible via match classes.
   virtual unsigned checkTargetMatchPredicate(MCInst &Inst) {
     return Match_Success;
   }
 
   virtual void convertToMapAndConstraints(unsigned Kind,
                                           const OperandVector &Operands) = 0;
 
+  // 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; };
+
   virtual const MCExpr *applyModifierToExpr(const MCExpr *E,
                                             MCSymbolRefExpr::VariantKind,
                                             MCContext &Ctx) {
     return nullptr;
   }
 
   virtual void onLabelParsed(MCSymbol *Symbol) { }
 };
 
 } // End llvm namespace
 
 #endif

llvm/trunk/lib/MC/MCParser/AsmParser.cpp

if (TheCondState.Ignore) {
     return false;
   }
 
   // FIXME: Recurse on local labels?
 
   // See what kind of statement we have.
   switch (Lexer.getKind()) {
   case AsmToken::Colon: {
+    if (!getTargetParser().isLabel(ID))
+      break;
     checkForValidSection();
 
     // identifier ':'   -> Label.
     Lex();
 
     // Diagnose attempt to use '.' as a label.
     if (IDVal == ".")
       return Error(IDLoc, "invalid use of pseudo-symbol '.' as a label");
if (Lexer.is(AsmToken::EndOfStatement)) {
       if (Lexer.is(AsmToken::Eof))
         return false;
     }
 
     return false;
   }
 
   case AsmToken::Equal:
+    if (!getTargetParser().equalIsAsmAssignment())
+      break;
     // identifier '=' ... -> assignment statement
     Lex();
 
     return parseAssignment(IDVal, true);
 
   default: // Normal instruction or directive.
     break;
   }
bool AsmParser::parseStatement(ParseStatementInfo &Info,
   if (ParsingInlineAsm && (IDVal == "align" || IDVal == "ALIGN"))
     return parseDirectiveMSAlign(IDLoc, Info);
 
   checkForValidSection();
 
   // Canonicalize the opcode to lower case.
   std::string OpcodeStr = IDVal.lower();
   ParseInstructionInfo IInfo(Info.AsmRewrites);
-  bool HadError = getTargetParser().ParseInstruction(IInfo, OpcodeStr, IDLoc,
+  bool HadError = getTargetParser().ParseInstruction(IInfo, OpcodeStr, ID,
                                                      Info.ParsedOperands);
   Info.ParseError = HadError;
 
   // Dump the parsed representation, if requested.
   if (getShowParsedOperands()) {
     SmallString<256> Str;
     raw_svector_ostream OS(Str);
     OS << "parsed instruction: [";