[TableGen] Allow mnemonics aliases with uppercase

[paperchalice]

Summary

Improves rG3cf7efec986d. Let applyMnemonicAliases work correctly when mnemonic and mnemonic alias contain uppercase characters.

[Paul-C-Anagnostopoulos]

This looks straightforward. Did you build all the targets and make sure the .inc files didn't change?

[paperchalice]

All inc under Target not are not changed

[paperchalice]

change directory layout to monorepo

[Paul-C-Anagnostopoulos]

Looks good to me.

[paperchalice]

Sorry, I don't have commit access. Thanks in advance if someone can commit the change. @Paul-C-Anagnostopoulos

[Paul-C-Anagnostopoulos]

I will push this revision in the next few days.

[Paul-C-Anagnostopoulos]

I am pushing this revision today.

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
+// RUN: llvm-tblgen -gen-asm-matcher -I %p/../../include %s | FileCheck %s --check-prefix=ALIAS
 
 // 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 AlphabeticallyFirstInst : Instruction {
   let Size = 2;
   let OutOperandList = (outs);
   let InOperandList = (ins);
   let AsmString = "aInst";
 }
 
+def :MnemonicAlias<"Insta", "aInst">;
+def :MnemonicAlias<"InstB", "BInst">;
+
 // 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: };
 
+// ALIAS: static void applyMnemonicAliases(StringRef &Mnemonic, const FeatureBitset &Features, unsigned VariantID) {
+// ALIAS-NEXT  switch (VariantID) {
+// ALIAS-NEXT  case 0:
+// ALIAS-NEXT      switch (Mnemonic.size()) {
+// ALIAS-NEXT      default: break;
+// ALIAS-NEXT      case 5:   // 2 strings to match.
+// ALIAS-NEXT        if (memcmp(Mnemonic.data()+0, "inst", 4) != 0)
+// ALIAS-NEXT          break;
+// ALIAS-NEXT        switch (Mnemonic[4]) {
+// ALIAS-NEXT        default: break;
+// ALIAS-NEXT        case 'a':   // 1 string to match.
+// ALIAS-NEXT          Mnemonic = "ainst";   // "insta"
+// ALIAS-NEXT          return;
+// ALIAS-NEXT        case 'b':   // 1 string to match.
+// ALIAS-NEXT          Mnemonic = "binst";   // "instb"
+// ALIAS-NEXT          return;
+

llvm/utils/TableGen/AsmMatcherEmitter.cpp

static void emitMnemonicAliasVariant(raw_ostream &OS,const AsmMatcherInfo &Info,
   // iteration order of the map is stable.
   std::map<std::string, std::vector<Record*> > AliasesFromMnemonic;
 
   for (Record *R : Aliases) {
     // FIXME: Allow AssemblerVariantName to be a comma separated list.
     StringRef AsmVariantName = R->getValueAsString("AsmVariantName");
     if (AsmVariantName != AsmParserVariantName)
       continue;
-    AliasesFromMnemonic[std::string(R->getValueAsString("FromMnemonic"))]
+    AliasesFromMnemonic[R->getValueAsString("FromMnemonic").lower()]
         .push_back(R);
   }
   if (AliasesFromMnemonic.empty())
     return;
 
   // Process each alias a "from" mnemonic at a time, building the code executed
   // by the string remapper.
   std::vector<StringMatcher::StringPair> Cases;
for (unsigned i = 0, e = ToVec.size(); i != e; ++i) {
       }
       if (R->getValueAsString("ToMnemonic") == AliasEntry.first)
         PrintFatalError(R->getLoc(), "MnemonicAlias to the same string");
 
       if (!MatchCode.empty())
         MatchCode += "else ";
       MatchCode += "if (" + FeatureMask + ")\n";
       MatchCode += "  Mnemonic = \"";
-      MatchCode += R->getValueAsString("ToMnemonic");
+      MatchCode += R->getValueAsString("ToMnemonic").lower();
       MatchCode += "\";\n";
     }
 
     if (AliasWithNoPredicate != -1) {
       Record *R = ToVec[AliasWithNoPredicate];
       if (!MatchCode.empty())
         MatchCode += "else\n  ";
       MatchCode += "Mnemonic = \"";
-      MatchCode += R->getValueAsString("ToMnemonic");
+      MatchCode += R->getValueAsString("ToMnemonic").lower();
       MatchCode += "\";\n";
     }
 
     MatchCode += "return;";
 
     Cases.push_back(std::make_pair(AliasEntry.first, MatchCode));
   }
   StringMatcher("Mnemonic", Cases, OS).Emit(Indent);