[NFC][TableGen] Optimize DecoderEmmitter

[zsrkmyn]

Summary

1. Replace std::string with StringRef;
2. Hoist a map query out of loop & avoid unnecessary element construction.

llvm/utils/TableGen/DecoderEmitter.cpp

     InOutOperands.push_back(
         std::make_pair(Out->getArg(i), Out->getArgNameStr(i)));
   for (unsigned i = 0; i < In->getNumArgs(); ++i)
     InOutOperands.push_back(
         std::make_pair(In->getArg(i), In->getArgNameStr(i)));
 
   // Search for tied operands, so that we can correctly instantiate
   // operands that are not explicitly represented in the encoding.
-  std::map<std::string, std::string> TiedNames;
+  std::map<StringRef, StringRef> TiedNames;
   for (unsigned i = 0; i < CGI.Operands.size(); ++i) {
     int tiedTo = CGI.Operands[i].getTiedRegister();
     if (tiedTo != -1) {
       std::pair<unsigned, unsigned> SO =
         CGI.Operands.getSubOperandNumber(tiedTo);
-      TiedNames[std::string(InOutOperands[i].second)] =
-          std::string(InOutOperands[SO.first].second);
-      TiedNames[std::string(InOutOperands[SO.first].second)] =
-          std::string(InOutOperands[i].second);
+      TiedNames[InOutOperands[i].second] = InOutOperands[SO.first].second;
+      TiedNames[InOutOperands[SO.first].second] = InOutOperands[i].second;
     }
   }
 
   if (IsVarLenInst) {
     parseVarLenInstOperand(EncodingDef, InsnOperands, CGI);
   } else {
-    std::map<std::string, std::vector<OperandInfo>> NumberedInsnOperands;
-    std::set<std::string> NumberedInsnOperandsNoTie;
+    std::map<StringRef, std::vector<OperandInfo>> NumberedInsnOperands;
+    std::set<StringRef> NumberedInsnOperandsNoTie;
     if (Target.getInstructionSet()->getValueAsBit(
             "decodePositionallyEncodedOperands")) {
       const std::vector<RecordVal> &Vals = Def.getValues();
       unsigned NumberedOp = 0;
 
       std::set<unsigned> NamedOpIndices;
       if (Target.getInstructionSet()->getValueAsBit(
               "noNamedPositionallyEncodedOperands"))

             CGI.Operands[SO.first].MIOperandInfo->getNumArgs() > 1 && String &&
             String->getValue() != "")
           NumberedInsnOperandsNoTie.insert(Name);
       }
     }
 
     // For each operand, see if we can figure out where it is encoded.
     for (const auto &Op : InOutOperands) {
-      if (!NumberedInsnOperands[std::string(Op.second)].empty()) {
-        llvm::append_range(InsnOperands,
-                           NumberedInsnOperands[std::string(Op.second)]);
+      if (!NumberedInsnOperands[Op.second].empty()) {
+        llvm::append_range(InsnOperands, NumberedInsnOperands[Op.second]);
         continue;
       }
-      if (!NumberedInsnOperands[TiedNames[std::string(Op.second)]].empty()) {
-        if (!NumberedInsnOperandsNoTie.count(
-                TiedNames[std::string(Op.second)])) {
+      if (!NumberedInsnOperands[TiedNames[Op.second]].empty()) {
+        if (!NumberedInsnOperandsNoTie.count(TiedNames[Op.second])) {
           // Figure out to which (sub)operand we're tied.
-          unsigned i =
-              CGI.Operands.getOperandNamed(TiedNames[std::string(Op.second)]);
+          unsigned i = CGI.Operands.getOperandNamed(TiedNames[Op.second]);
           int tiedTo = CGI.Operands[i].getTiedRegister();
           if (tiedTo == -1) {
             i = CGI.Operands.getOperandNamed(Op.second);
             tiedTo = CGI.Operands[i].getTiedRegister();
           }
 
           if (tiedTo != -1) {
             std::pair<unsigned, unsigned> SO =
                 CGI.Operands.getSubOperandNumber(tiedTo);
 
             InsnOperands.push_back(
-                NumberedInsnOperands[TiedNames[std::string(Op.second)]]
-                                    [SO.second]);
+                NumberedInsnOperands[TiedNames[Op.second]][SO.second]);
           }
         }
         continue;
       }
 
       // At this point, we can locate the decoder field, but we need to know how
       // to interpret it.  As a first step, require the target to provide
       // callbacks for decoding register classes.

             if (const BitInit *OpBit = dyn_cast<BitInit>(OpBits->getBit(I)))
               if (OpBit->getValue())
                 OpInfo.InitValue |= 1ULL << I;
 
       unsigned Base = ~0U;
       unsigned Width = 0;
       unsigned Offset = 0;
 
+      auto It = TiedNames.find(Op.second);
+      StringRef TiedName = It == TiedNames.end() ? It->second : "";
       for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
         VarInit *Var = nullptr;
         VarBitInit *BI = dyn_cast<VarBitInit>(Bits.getBit(bi));
         if (BI)
           Var = dyn_cast<VarInit>(BI->getBitVar());
         else
           Var = dyn_cast<VarInit>(Bits.getBit(bi));
 
         if (!Var) {
           if (Base != ~0U) {
             OpInfo.addField(Base, Width, Offset);
             Base = ~0U;
             Width = 0;
             Offset = 0;
           }
           continue;
         }
 
-        if ((Var->getName() != Op.second &&
-             Var->getName() != TiedNames[std::string(Op.second)])) {
+        if ((Var->getName() != Op.second && Var->getName() != TiedName)) {
           if (Base != ~0U) {
             OpInfo.addField(Base, Width, Offset);
             Base = ~0U;
             Width = 0;
             Offset = 0;
           }
           continue;
         }