[TableGen] Allow mnemonics with uppercase letters to be matched

[nlguillemot]

Summary

The assembly parser "canonicalizes" the mnemonics it processes at an
early level by making them lowercase. The goal of this is presumably to
allow assembly to be case-insensitive. However, if one declares an
instruction with a mnemonic using uppercase letters, then it will
never get matched, since the generated lookup tables for the
AsmMatcherEmitter didn't lower() their inputs. This made it difficult to
have instructions that get printed using a mnemonic that includes
uppercase letters, since they could not be parsed.

To fix this problem, this patch adds a few calls to lower() to make the
lookup tables used in AsmMatcherEmitter be case-insensitive. This allows
instruction mnemonics with uppercase letters to be parsed.

[dsanders]

LGTM

llvm/test/TableGen/MixedCasedMnemonic.td

+// RUN: llvm-tblgen -gen-asm-matcher -I %p/../../include %s | FileCheck %s --check-prefix=MATCHER
+// RUN: llvm-tblgen -gen-asm-writer -I %p/../../include %s | FileCheck %s --check-prefix=WRITER
+
+// Check that an instruction that uses mixed upper/lower case in its mnemonic
+// is printed as-is, and is parsed in its "canonicalized" lowercase form.
+
+include "llvm/Target/Target.td"
+
+def ArchInstrInfo : InstrInfo { }
+
+def Arch : Target {
+  let InstructionSet = ArchInstrInfo;
+}
+
+def Reg : Register<"reg">;
+def RegClass : RegisterClass<"foo", [i32], 0, (add Reg)>;
+
+// Define instructions that demonstrate case-insensitivity.
+// In case-sensitive ASCII order, "BInst" < "aInst".
+// In case-insensitive order, "aInst" < "BInst".
+// If the matcher really treats the mnemonics in a case-insensitive way,
+// then we should see "aInst" appearing before "BInst", despite the
+// fact that "BInst" would appear before "aInst" in ASCIIbetical order.
+def AlphabeticallySecondInst : Instruction {
+  let Size = 2;
+  let OutOperandList = (outs);
+  let InOperandList = (ins);
+  let AsmString = "BInst";
+}
+
+def AlphabeticallyFirstInst : Instruction {
+  let Size = 2;
+  let OutOperandList = (outs);
+  let InOperandList = (ins);
+  let AsmString = "aInst";
+}
+
+// Check that the matcher lower()s the mnemonics it matches.
+// MATCHER: static const char *const MnemonicTable =
+// MATCHER-NEXT: "\005ainst\005binst";
+
+// Check that aInst appears before BInst in the match table.
+// This shows that the mnemonics are sorted in a case-insensitive way,
+// since otherwise "B" would be less than "a" by ASCII order.
+// MATCHER:      static const MatchEntry MatchTable0[] = {
+// MATCHER-NEXT:     /* aInst */, ::AlphabeticallyFirstInst
+// MATCHER-NEXT:     /* BInst */, ::AlphabeticallySecondInst
+// MATCHER-NEXT: };
+
+// Check that the writer preserves the case of the mnemonics.
+// WRITER:      static const char AsmStrs[] = {
+// WRITER:        "BInst\0"
+// WRITER-NEXT:   "aInst\0"
+// WRITER-NEXT: };
+

llvm/utils/TableGen/AsmMatcherEmitter.cpp

struct MatchableInfo {
   }
 
   void buildInstructionResultOperands();
   void buildAliasResultOperands(bool AliasConstraintsAreChecked);
 
   /// operator< - Compare two matchables.
   bool operator<(const MatchableInfo &RHS) const {
     // The primary comparator is the instruction mnemonic.
-    if (int Cmp = Mnemonic.compare(RHS.Mnemonic))
+    if (int Cmp = Mnemonic.compare_lower(RHS.Mnemonic))
       return Cmp == -1;
 
     if (AsmOperands.size() != RHS.AsmOperands.size())
       return AsmOperands.size() < RHS.AsmOperands.size();
 
     // Compare lexicographically by operand. The matcher validates that other
     // orderings wouldn't be ambiguous using \see couldMatchAmbiguouslyWith().
     for (unsigned i = 0, e = AsmOperands.size(); i != e; ++i) {
static void emitCustomOperandParsing(raw_ostream &OS, CodeGenTarget &Target,
 
   OS << "  /* Operand List Mnemonic, Mask, Operand Class, Features */\n";
   for (const OperandMatchEntry &OMI : Info.OperandMatchInfo) {
     const MatchableInfo &II = *OMI.MI;
 
     OS << "  { ";
 
     // Store a pascal-style length byte in the mnemonic.
-    std::string LenMnemonic = char(II.Mnemonic.size()) + II.Mnemonic.str();
+    std::string LenMnemonic = char(II.Mnemonic.size()) + II.Mnemonic.lower();
     OS << StringTable.GetOrAddStringOffset(LenMnemonic, false)
        << " /* " << II.Mnemonic << " */, ";
 
     OS << OMI.OperandMask;
     OS << " /* ";
     bool printComma = false;
     for (int i = 0, e = 31; i !=e; ++i)
       if (OMI.OperandMask & (1 << i)) {
#endif
   size_t MaxNumOperands = 0;
   unsigned MaxMnemonicIndex = 0;
   bool HasDeprecation = false;
   for (const auto &MI : Info.Matchables) {
     MaxNumOperands = std::max(MaxNumOperands, MI->AsmOperands.size());
     HasDeprecation |= MI->HasDeprecation;
 
     // Store a pascal-style length byte in the mnemonic.
-    std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.str();
+    std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.lower();
     MaxMnemonicIndex = std::max(MaxMnemonicIndex,
                         StringTable.GetOrAddStringOffset(LenMnemonic, false));
   }
 
   OS << "static const char *const MnemonicTable =\n";
   StringTable.EmitString(OS);
   OS << ";\n\n";
 
for (unsigned VC = 0; VC != VariantCount; ++VC) {
 
     OS << "static const MatchEntry MatchTable" << VC << "[] = {\n";
 
     for (const auto &MI : Info.Matchables) {
       if (MI->AsmVariantID != AsmVariantNo)
         continue;
 
       // Store a pascal-style length byte in the mnemonic.
-      std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.str();
+      std::string LenMnemonic =
+          char(MI->Mnemonic.size()) + MI->Mnemonic.lower();
       OS << "  { " << StringTable.GetOrAddStringOffset(LenMnemonic, false)
          << " /* " << MI->Mnemonic << " */, "
          << Target.getInstNamespace() << "::"
          << MI->getResultInst()->TheDef->getName() << ", "
          << MI->ConversionFnKind << ", ";
 
       // Write the required features mask.
       OS << "AMFBS";