Revert AsmParser changes

[colinl]

Summary

This reverts r256669, r256542, r252440, r252439, r252435, and a number of commits that added assembly tests per request.

X86AsmParser needed to be added to X86.td since instructions were added that have a dot in the mnemonic.

Creating a review for this since the revert is non-trivial.

[craig.topper]

I don't see the removal of the Hexagon AsmParser directory here or the tests.

utils/TableGen/AsmMatcherEmitter.cpp

2577

This should be Operands.size() - 1

2585

This Mnemonic.empty() check wasn't here before

2897

This was MaxNumOperands + 1 before

2908

This isToken check did not exist before your changes

2942

The Mnemonic.empty() check and the SIndex variable did not exist before your changes.

2956

This should go back i = 0

2958

This was i+1 before your changes

2960

As was this

2963

And this

2979

And i+1 here and below

[colinl]

Is there interest in pursuing this revert? The feedback so far has been against a revert due to causing out of tree churn.

My feedback is also against a revert since the modest code size regression has been fixed, the only performance edge case is to targets that don't have mnemonic lead instructions e.g. Hexagon, and the actual performance impact to real world instruction combinations is minimal.

Unless there's opposition I'll close this.

include/llvm/MC/MCTargetAsmParser.h

   /// \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
   ///

   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) {

include/llvm/Target/Target.td

   // written register name matcher
   bit ShouldEmitMatchRegisterName = 1;
 
-  // HasMnemonicFirst - Set to false if target instructions don't always
-  // start with a mnemonic as the first token.
-  bit HasMnemonicFirst = 1;
+  /// Does the instruction mnemonic allow '.'
+  bit MnemonicContainsDot = 0;
 }
 def DefaultAsmParser : AsmParser;
 

   // register tokens as constrained registers, instead of tokens, for the
   // purposes of matching.
   string RegisterPrefix = "";
-
-  // TokenizingCharacters - Characters that are standalone tokens
-  string TokenizingCharacters = "[]*!";
-
-  // SeparatorCharacters - Characters that are not tokens
-  string SeparatorCharacters = " \t,";
-
-  // BreakCharacters - Characters that start new identifiers
-  string BreakCharacters = "";
 }
 def DefaultAsmParserVariant : AsmParserVariant;
 

lib/MC/MCParser/AsmParser.cpp

   // See what kind of statement we have.
   switch (Lexer.getKind()) {
   case AsmToken::Colon: {
-    if (!getTargetParser().isLabel(ID))
-      break;
     checkForValidSection();
 
     // identifier ':'   -> Label.

   }
 
   case AsmToken::Equal:
-    if (!getTargetParser().equalIsAsmAssignment())
-      break;
     // identifier '=' ... -> assignment statement
     Lex();
 

   // Canonicalize the opcode to lower case.
   std::string OpcodeStr = IDVal.lower();
   ParseInstructionInfo IInfo(Info.AsmRewrites);
-  bool HadError = getTargetParser().ParseInstruction(IInfo, OpcodeStr, ID,
+  bool HadError = getTargetParser().ParseInstruction(IInfo, OpcodeStr, IDLoc,
                                                      Info.ParsedOperands);
   Info.ParseError = HadError;
 

lib/Target/AArch64/AArch64.td

 def GenericAsmParserVariant : AsmParserVariant {
   int Variant = 0;
   string Name = "generic";
-  string BreakCharacters = ".";
 }
 
 def AppleAsmParserVariant : AsmParserVariant {
   int Variant = 1;
   string Name = "apple-neon";
-  string BreakCharacters = ".";
 }
 
 //===----------------------------------------------------------------------===//

lib/Target/ARM/ARM.td

   bit isMCAsmWriter = 1;
 }
 
-def ARMAsmParserVariant : AsmParserVariant {
-  int Variant = 0;
-  string Name = "ARM";
-  string BreakCharacters = ".";
-}
-
 def ARM : Target {
   // Pull in Instruction Info:
   let InstructionSet = ARMInstrInfo;
   let AssemblyWriters = [ARMAsmWriter];
-  let AssemblyParserVariants = [ARMAsmParserVariant];
 }

lib/Target/BPF/BPF.td

   bit isMCAsmWriter = 1;
 }
 
-def BPFAsmParserVariant : AsmParserVariant {
-  int Variant = 0;
-  string Name = "BPF";
-  string BreakCharacters = ".";
-}
-
 def BPF : Target {
   let InstructionSet = BPFInstrInfo;
   let AssemblyWriters = [BPFInstPrinter];
-  let AssemblyParserVariants = [BPFAsmParserVariant];
 }

lib/Target/Hexagon/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Hexagon.td)
 
-tablegen(LLVM HexagonGenAsmMatcher.inc -gen-asm-matcher)
 tablegen(LLVM HexagonGenAsmWriter.inc -gen-asm-writer)
 tablegen(LLVM HexagonGenCallingConv.inc -gen-callingconv)
 tablegen(LLVM HexagonGenDAGISel.inc -gen-dag-isel)

   HexagonVLIWPacketizer.cpp
 )
 
-add_subdirectory(AsmParser)
 add_subdirectory(TargetInfo)
 add_subdirectory(MCTargetDesc)
 add_subdirectory(Disassembler)

lib/Target/Hexagon/Hexagon.td

 // Declare the target which we are implementing
 //===----------------------------------------------------------------------===//
 
-def HexagonAsmParser : AsmParser {
-  bit HasMnemonicFirst = 0;
-}
-
 def HexagonAsmParserVariant : AsmParserVariant {
   int Variant = 0;
   string TokenizingCharacters = "#()=:.<>!+*";

 def Hexagon : Target {
   // Pull in Instruction Info:
   let InstructionSet = HexagonInstrInfo;
-  let AssemblyParsers = [HexagonAsmParser];
   let AssemblyParserVariants = [HexagonAsmParserVariant];
 }

lib/Target/Hexagon/LLVMBuild.txt

 ;===------------------------------------------------------------------------===;
 
 [common]
-subdirectories = AsmParser Disassembler MCTargetDesc TargetInfo
+subdirectories = Disassembler MCTargetDesc TargetInfo
 
 [component_0]
 type = TargetGroup

  AsmPrinter
  CodeGen
  Core
- HexagonAsmParser
  HexagonDesc
  HexagonInfo
  MC

lib/Target/Mips/Mips.td

 
 def MipsAsmParser : AsmParser {
   let ShouldEmitMatchRegisterName = 0;
+  let MnemonicContainsDot = 1;
 }
 
 def MipsAsmParserVariant : AsmParserVariant {

lib/Target/PowerPC/PPC.td

   // InstAlias definitions use immediate literals.  Set RegisterPrefix
   // so that those are not misinterpreted as registers.
   string RegisterPrefix = "%";
-  string BreakCharacters = ".";
 }
 
 def PPC : Target {

lib/Target/X86/X86.td

   int Variant = 1;
 }
 
+def X86AsmParser : AsmParser {
+  let MnemonicContainsDot = 1;
+}
+
 def X86 : Target {
   // Information about the instructions...
   let InstructionSet = X86InstrInfo;
+  let AssemblyParsers = [X86AsmParser];
   let AssemblyParserVariants = [ATTAsmParserVariant, IntelAsmParserVariant];
   let AssemblyWriters = [ATTAsmWriter, IntelAsmWriter];
 }

utils/TableGen/AsmMatcherEmitter.cpp

 class AsmVariantInfo {
 public:
   std::string RegisterPrefix;
-  std::string TokenizingCharacters;
-  std::string SeparatorCharacters;
-  std::string BreakCharacters;
   int AsmVariantNo;
 };
 

 
   void initialize(const AsmMatcherInfo &Info,
                   SmallPtrSetImpl<Record*> &SingletonRegisters,
-                  AsmVariantInfo const &Variant,
-                  bool HasMnemonicFirst);
+                  AsmVariantInfo const &Variant);
 
   /// validate - Return true if this matchable is a valid thing to match against
   /// and perform a bunch of validity checking.

 
 void MatchableInfo::initialize(const AsmMatcherInfo &Info,
                                SmallPtrSetImpl<Record*> &SingletonRegisters,
-                               AsmVariantInfo const &Variant,
-                               bool HasMnemonicFirst) {
+                               AsmVariantInfo const &Variant) {
   AsmVariantID = Variant.AsmVariantNo;
   AsmString =
     CodeGenInstruction::FlattenAsmStringVariants(AsmString,

 
   tokenizeAsmString(Info, Variant);
 
-  // The first token of the instruction is the mnemonic, which must be a
-  // simple string, not a $foo variable or a singleton register.
-  if (AsmOperands.empty())
-    PrintFatalError(TheDef->getLoc(),
-                  "Instruction '" + TheDef->getName() + "' has no tokens");
-
-  assert(!AsmOperands[0].Token.empty());
-  if (HasMnemonicFirst) {
-    Mnemonic = AsmOperands[0].Token;
-    if (Mnemonic[0] == '$')
-      PrintFatalError(TheDef->getLoc(),
-                      "Invalid instruction mnemonic '" + Mnemonic + "'!");
-
-    // Remove the first operand, it is tracked in the mnemonic field.
-    AsmOperands.erase(AsmOperands.begin());
-  } else if (AsmOperands[0].Token[0] != '$')
-    Mnemonic = AsmOperands[0].Token;
-
   // Compute the require features.
   for (Record *Predicate : TheDef->getValueAsListOfDefs("Predicates"))
     if (const SubtargetFeatureInfo *Feature =

                                       AsmVariantInfo const &Variant) {
   StringRef String = AsmString;
   size_t Prev = 0;
-  bool InTok = false;
+  bool InTok = true;
   bool IsIsolatedToken = true;
   for (size_t i = 0, e = String.size(); i != e; ++i) {
     char Char = String[i];
-    if (Variant.BreakCharacters.find(Char) != std::string::npos) {
+    switch(Char) {
+    case '[':
+    case ']':
+    case '*':
+    case '!':
       if (InTok) {
-        addAsmOperand(String.slice(Prev, i), false);
-        Prev = i;
-        IsIsolatedToken = false;
-      }
-      InTok = true;
-      continue;
-    }
-    if (Variant.TokenizingCharacters.find(Char) != std::string::npos) {
-      if (InTok) {
         addAsmOperand(String.slice(Prev, i), IsIsolatedToken);
         InTok = false;
         IsIsolatedToken = false;

       addAsmOperand(String.slice(i, i + 1), IsIsolatedToken);
       Prev = i + 1;
       IsIsolatedToken = true;
-      continue;
-    }
-    if (Variant.SeparatorCharacters.find(Char) != std::string::npos) {
+      break;
+    case ' ':
+    case '\t':
+    case ',':
       if (InTok) {
         addAsmOperand(String.slice(Prev, i), IsIsolatedToken);
         InTok = false;

       }
       Prev = i + 1;
       IsIsolatedToken = true;
-      continue;
-    }
-
-    switch (Char) {
+      break;
+    case '.':
+      if (!Info.AsmParser->getValueAsBit("MnemonicContainsDot")) {
+        if (InTok)
+          addAsmOperand(String.slice(Prev, i), false);
+        Prev = i;
+        IsIsolatedToken = false;
+      }
+      InTok = true;
+      break;
     case '\\':
       if (InTok) {
         addAsmOperand(String.slice(Prev, i), false);

   }
   if (InTok && Prev != String.size())
     addAsmOperand(String.substr(Prev), IsIsolatedToken);
+
+  // The first token of the instruction is the mnemonic, which must be a
+  // simple string, not a $foo variable or a singleton register.
+  if (AsmOperands.empty())
+    PrintFatalError(TheDef->getLoc(),
+                  "Instruction '" + TheDef->getName() + "' has no tokens");
+  assert(!AsmOperands[0].Token.empty());
+  if (AsmOperands[0].Token[0] != '$')
+    Mnemonic = AsmOperands[0].Token;
 }
 
 bool MatchableInfo::validate(StringRef CommentDelimiter, bool Hack) const {

     assert(SubtargetFeatures.size() <= 64 && "Too many subtarget features!");
   }
 
-  bool HasMnemonicFirst = AsmParser->getValueAsBit("HasMnemonicFirst");
-
   // Parse the instructions; we need to do this first so that we can gather the
   // singleton register classes.
   SmallPtrSet<Record*, 16> SingletonRegisters;

       AsmVariant->getValueAsString("CommentDelimiter");
     AsmVariantInfo Variant;
     Variant.RegisterPrefix = AsmVariant->getValueAsString("RegisterPrefix");
-    Variant.TokenizingCharacters =
-        AsmVariant->getValueAsString("TokenizingCharacters");
-    Variant.SeparatorCharacters =
-        AsmVariant->getValueAsString("SeparatorCharacters");
-    Variant.BreakCharacters =
-        AsmVariant->getValueAsString("BreakCharacters");
     Variant.AsmVariantNo = AsmVariant->getValueAsInt("Variant");
 
     for (const CodeGenInstruction *CGI : Target.instructions()) {

 
       auto II = llvm::make_unique<MatchableInfo>(*CGI);
 
-      II->initialize(*this, SingletonRegisters, Variant, HasMnemonicFirst);
+      II->initialize(*this, SingletonRegisters, Variant);
 
       // Ignore instructions which shouldn't be matched and diagnose invalid
       // instruction definitions with an error.

 
       auto II = llvm::make_unique<MatchableInfo>(std::move(Alias));
 
-      II->initialize(*this, SingletonRegisters, Variant, HasMnemonicFirst);
+      II->initialize(*this, SingletonRegisters, Variant);
 
       // Validate the alias definitions.
       II->validate(CommentDelimiter, false);

 
 static void emitConvertFuncs(CodeGenTarget &Target, StringRef ClassName,
                              std::vector<std::unique_ptr<MatchableInfo>> &Infos,
-                             bool HasMnemonicFirst, raw_ostream &OS) {
+                             raw_ostream &OS) {
   SmallSetVector<std::string, 16> OperandConversionKinds;
   SmallSetVector<std::string, 16> InstructionConversionKinds;
   std::vector<std::vector<uint8_t> > ConversionTable;

 
         // Add the operand entry to the instruction kind conversion row.
         ConversionRow.push_back(ID);
-        ConversionRow.push_back(OpInfo.AsmOperandNum + HasMnemonicFirst);
+        ConversionRow.push_back(OpInfo.AsmOperandNum);
 
         if (!IsNewConverter)
           break;

 static void emitCustomOperandParsing(raw_ostream &OS, CodeGenTarget &Target,
                               const AsmMatcherInfo &Info, StringRef ClassName,
                               StringToOffsetTable &StringTable,
-                              unsigned MaxMnemonicIndex, bool HasMnemonicFirst) {
+                              unsigned MaxMnemonicIndex) {
   unsigned MaxMask = 0;
   for (const OperandMatchEntry &OMI : Info.OperandMatchInfo) {
     MaxMask |= OMI.OperandMask;

   OS << "  uint64_t AvailableFeatures = getAvailableFeatures();\n\n";
 
   OS << "  // Get the next operand index.\n";
-  OS << "  unsigned NextOpNum = Operands.size()"
-     << (HasMnemonicFirst ? " - 1" : "") << ";\n";
+  OS << "  unsigned NextOpNum = Operands.size();\n";
 
   // Emit code to search the table.
   OS << "  // Search the table.\n";
-  if (HasMnemonicFirst) {
-    OS << "  auto MnemonicRange =\n";
-    OS << "    std::equal_range(std::begin(OperandMatchTable), "
-          "std::end(OperandMatchTable),\n";
-    OS << "                     Mnemonic, LessOpcodeOperand());\n\n";
-  } else {
-    OS << "  auto MnemonicRange = std::make_pair(std::begin(OperandMatchTable),"
-          " std::end(OperandMatchTable));\n";
-    OS << "  if (!Mnemonic.empty())\n";
-    OS << "    MnemonicRange =\n";
-    OS << "      std::equal_range(std::begin(OperandMatchTable), "
-          "std::end(OperandMatchTable),\n";
-    OS << "                       Mnemonic, LessOpcodeOperand());\n\n";
-  }
+  OS << "  std::pair<const OperandMatchEntry*, const OperandMatchEntry*>";
+  OS << " MnemonicRange\n";
+  OS << "       (OperandMatchTable, OperandMatchTable+";
+  OS << Info.OperandMatchInfo.size() << ");\n";
+  OS << "  if(!Mnemonic.empty())\n";
+  OS << "    MnemonicRange = std::equal_range(OperandMatchTable,";
+  OS << " OperandMatchTable+"
+     << Info.OperandMatchInfo.size() << ", Mnemonic,\n"
+     << "                     LessOpcodeOperand());\n\n";
 
   OS << "  if (MnemonicRange.first == MnemonicRange.second)\n";
   OS << "    return MatchOperand_NoMatch;\n\n";

   // Compute the information on the custom operand parsing.
   Info.buildOperandMatchInfo();
 
-  bool HasMnemonicFirst = AsmParser->getValueAsBit("HasMnemonicFirst");
-
   // Write the output.
 
   // Information for the class declaration.

      << "&Operands);\n";
   OS << "  void convertToMapAndConstraints(unsigned Kind,\n                ";
   OS << "           const OperandVector &Operands) override;\n";
-  if (HasMnemonicFirst)
-    OS << "  bool mnemonicIsValid(StringRef Mnemonic, unsigned VariantID);\n";
+  OS << "  bool mnemonicIsValid(StringRef Mnemonic, unsigned VariantID);\n";
   OS << "  unsigned MatchInstructionImpl(const OperandVector &Operands,\n"
      << "                                MCInst &Inst,\n"
      << "                                uint64_t &ErrorInfo,"

   // Generate the convertToMCInst function to convert operands into an MCInst.
   // Also, generate the convertToMapAndConstraints function for MS-style inline
   // assembly.  The latter doesn't actually generate a MCInst.
-  emitConvertFuncs(Target, ClassName, Info.Matchables, HasMnemonicFirst, OS);
+  emitConvertFuncs(Target, ClassName, Info.Matchables, OS);
 
   // Emit the enumeration for classes which participate in matching.
   emitMatchClassEnumeration(Target, Info.Classes, OS);

   }
 
   // A method to determine if a mnemonic is in the list.
-  if (HasMnemonicFirst) {
-    OS << "bool " << Target.getName() << ClassName << "::\n"
-       << "mnemonicIsValid(StringRef Mnemonic, unsigned VariantID) {\n";
-    OS << "  // Find the appropriate table for this asm variant.\n";
-    OS << "  const MatchEntry *Start, *End;\n";
-    OS << "  switch (VariantID) {\n";
-    OS << "  default: llvm_unreachable(\"invalid variant!\");\n";
-    for (unsigned VC = 0; VC != VariantCount; ++VC) {
-      Record *AsmVariant = Target.getAsmParserVariant(VC);
-      int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
-      OS << "  case " << AsmVariantNo << ": Start = std::begin(MatchTable" << VC
-         << "); End = std::end(MatchTable" << VC << "); break;\n";
-    }
-    OS << "  }\n";
-    OS << "  // Search the table.\n";
-    OS << "  auto MnemonicRange = ";
-    OS << "std::equal_range(Start, End, Mnemonic, LessOpcode());\n";
-    OS << "  return MnemonicRange.first != MnemonicRange.second;\n";
-    OS << "}\n\n";
+  OS << "bool " << Target.getName() << ClassName << "::\n"
+     << "mnemonicIsValid(StringRef Mnemonic, unsigned VariantID) {\n";
+  OS << "  // Find the appropriate table for this asm variant.\n";
+  OS << "  const MatchEntry *Start, *End;\n";
+  OS << "  switch (VariantID) {\n";
+  OS << "  default: llvm_unreachable(\"invalid variant!\");\n";
+  for (unsigned VC = 0; VC != VariantCount; ++VC) {
+    Record *AsmVariant = Target.getAsmParserVariant(VC);
+    int AsmVariantNo = AsmVariant->getValueAsInt("Variant");
+    OS << "  case " << AsmVariantNo << ": Start = std::begin(MatchTable" << VC
+       << "); End = std::end(MatchTable" << VC << "); break;\n";
   }
+  OS << "  }\n";
+  OS << "  // Search the table.\n";
+  OS << "  std::pair<const MatchEntry*, const MatchEntry*> MnemonicRange =\n";
+  OS << "    std::equal_range(Start, End, Mnemonic, LessOpcode());\n";
+  OS << "  return MnemonicRange.first != MnemonicRange.second;\n";
+  OS << "}\n\n";
 
   // Finally, build the match function.
   OS << "unsigned " << Target.getName() << ClassName << "::\n"

      << "                     bool matchingInlineAsm, unsigned VariantID) {\n";
 
   OS << "  // Eliminate obvious mismatches.\n";
-  OS << "  if (Operands.size() > "
-     << (MaxNumOperands + HasMnemonicFirst) << ") {\n";
-  OS << "    ErrorInfo = "
-     << (MaxNumOperands + HasMnemonicFirst) << ";\n";
+  OS << "  if (Operands.size() > " << MaxNumOperands << ") {\n";
+  OS << "    ErrorInfo = " << MaxNumOperands << ";\n";
   OS << "    return Match_InvalidOperand;\n";
   OS << "  }\n\n";
 

   OS << "  uint64_t AvailableFeatures = getAvailableFeatures();\n\n";
 
   OS << "  // Get the instruction mnemonic, which is the first token.\n";
-  if (HasMnemonicFirst) {
-    OS << "  StringRef Mnemonic = ((" << Target.getName()
-       << "Operand&)*Operands[0]).getToken();\n\n";
-  } else {
-    OS << "  StringRef Mnemonic;\n";
-    OS << "  if (Operands[0]->isToken())\n";
-    OS << "    Mnemonic = ((" << Target.getName()
-       << "Operand&)*Operands[0]).getToken();\n\n";
-  }
+  OS << "  StringRef Mnemonic;\n";
+  OS << "  if (Operands[0]->isToken())\n";
+  OS << "    Mnemonic = ((" << Target.getName()
+     << "Operand&)*Operands[0]).getToken();\n\n";
 
   if (HasMnemonicAliases) {
     OS << "  // Process all MnemonicAliases to remap the mnemonic.\n";

        << "); End = std::end(MatchTable" << VC << "); break;\n";
   }
   OS << "  }\n";
-
   OS << "  // Search the table.\n";
-  if (HasMnemonicFirst) {
-    OS << "  auto MnemonicRange = "
-          "std::equal_range(Start, End, Mnemonic, LessOpcode());\n\n";
-  } else {
-    OS << "  auto MnemonicRange = std::make_pair(Start, End);\n";
-    OS << "  unsigned SIndex = Mnemonic.empty() ? 0 : 1;\n";
-    OS << "  if (!Mnemonic.empty())\n";
-    OS << "    MnemonicRange = "
-          "std::equal_range(Start, End, Mnemonic.lower(), LessOpcode());\n\n";
-  }
+  OS << "  std::pair<const MatchEntry*, const MatchEntry*> "
+        "MnemonicRange(Start, End);\n";
+  OS << "  unsigned SIndex = Mnemonic.empty() ? 0 : 1;\n";
+  OS << "  if (!Mnemonic.empty())\n";
+  OS << "    MnemonicRange = std::equal_range(Start, End, Mnemonic.lower(), LessOpcode());\n\n";
 
   OS << "  // Return a more specific error code if no mnemonics match.\n";
   OS << "  if (MnemonicRange.first == MnemonicRange.second)\n";

      << "*ie = MnemonicRange.second;\n";
   OS << "       it != ie; ++it) {\n";
 
-  if (HasMnemonicFirst) {
-    OS << "    // equal_range guarantees that instruction mnemonic matches.\n";
-    OS << "    assert(Mnemonic == it->getMnemonic());\n";
-  }
-
   // Emit check that the subclasses match.
   OS << "    bool OperandsValid = true;\n";
-  OS << "    for (unsigned i = " << (HasMnemonicFirst ? "0" : "SIndex")
-     << "; i != " << MaxNumOperands << "; ++i) {\n";
+  OS << "    for (unsigned i = SIndex; i != " << MaxNumOperands << "; ++i) {\n";
   OS << "      auto Formal = static_cast<MatchClassKind>(it->Classes[i]);\n";
-  OS << "      if (i" << (HasMnemonicFirst ? "+1" : "")
-     << " >= Operands.size()) {\n";
+  OS << "      if (i >= Operands.size()) {\n";
   OS << "        OperandsValid = (Formal == " <<"InvalidMatchClass);\n";
-  OS << "        if (!OperandsValid) ErrorInfo = i"
-     << (HasMnemonicFirst ? "+1" : "") << ";\n";
+  OS << "        if (!OperandsValid) ErrorInfo = i;\n";
   OS << "        break;\n";
   OS << "      }\n";
-  OS << "      MCParsedAsmOperand &Actual = *Operands[i"
-     << (HasMnemonicFirst ? "+1" : "") << "];\n";
+  OS << "      MCParsedAsmOperand &Actual = *Operands[i];\n";
   OS << "      unsigned Diag = validateOperandClass(Actual, Formal);\n";
   OS << "      if (Diag == Match_Success)\n";
   OS << "        continue;\n";

   OS << "      // If we already had a match that only failed due to a\n";
   OS << "      // target predicate, that diagnostic is preferred.\n";
   OS << "      if (!HadMatchOtherThanPredicate &&\n";
-  OS << "          (it == MnemonicRange.first || ErrorInfo <= i"
-     << (HasMnemonicFirst ? "+1" : "") << ")) {\n";
-  OS << "        ErrorInfo = i" << (HasMnemonicFirst ? "+1" : "") << ";\n";
+  OS << "          (it == MnemonicRange.first || ErrorInfo <= i)) {\n";
+  OS << "        ErrorInfo = i;\n";
   OS << "        // InvalidOperand is the default. Prefer specificity.\n";
   OS << "        if (Diag != Match_InvalidOperand)\n";
   OS << "          RetCode = Diag;\n";

 
   if (!Info.OperandMatchInfo.empty())
     emitCustomOperandParsing(OS, Target, Info, ClassName, StringTable,
-                             MaxMnemonicIndex, HasMnemonicFirst);
+                             MaxMnemonicIndex);
 
   OS << "#endif // GET_MATCHER_IMPLEMENTATION\n\n";
 }