[tablegen] Avoid creating temporary strings

[alexander-shaposhnikov]

Summary

If a method / function returns a StringRef but the
variable is of type const std::string& a temporary string is
created (StringRef has a cast operator to std::string),
which is a suboptimal behavior.

Test plan: make check-all

This cleanup is a continuation of the efforts started
in https://reviews.llvm.org/D34969 and https://reviews.llvm.org/D34970.
The changes are broken up into multiples diffs
to make reviewing / landing / reverting (if necessary) easier.

Test plan: make check-all

[dblaikie]

Looks good - thanks!

llvm/trunk/utils/TableGen/FixedLenDecoderEmitter.cpp

void FilterChooser::emitTableEntries(DecoderTableInfo &TableInfo) const {
   // conflict set and bail.
 
   // Print out useful conflict information for postmortem analysis.
   errs() << "Decoding Conflict:\n";
 
   dumpStack(errs(), "\t\t");
 
   for (unsigned i = 0; i < Opcodes.size(); ++i) {
-    const std::string &Name = nameWithID(Opcodes[i]);
-
-    errs() << '\t' << Name << " ";
+    errs() << '\t' << nameWithID(Opcodes[i]) << " ";
     dumpBits(errs(),
              getBitsField(*AllInstructions[Opcodes[i]]->TheDef, "Inst"));
     errs() << '\n';
   }
 }
 
 static std::string findOperandDecoderMethod(TypedInit *TI) {
   std::string Decoder;

llvm/trunk/utils/TableGen/SearchableTableEmitter.cpp

void SearchableTableEmitter::emitLookupDeclaration(StringRef Name,
   OS << "const " << Name << " *"
      << "lookup" << Name << "By" << Field;
   OS << "(" << (IsIntegral ? FieldType : "StringRef") << " " << Field
      << ");\n\n";
 }
 
 void SearchableTableEmitter::emitMapping(Record *InstanceClass,
                                          raw_ostream &OS) {
-  const std::string &TableName = InstanceClass->getName();
+  StringRef TableName = InstanceClass->getName();
   std::vector<Record *> Items = Records.getAllDerivedDefinitions(TableName);
 
   // Gather all the records we're going to need for this particular mapping.
   std::vector<std::vector<SearchTableEntry>> SearchTables;
   std::vector<std::string> SearchFieldNames;
 
   std::vector<std::string> FieldNames;
   for (const RecordVal &Field : InstanceClass->getValues()) {
void SearchableTableEmitter::emitMapping(Record *InstanceClass,
   for (Record *Item : Items) {
     for (unsigned i = 0; i < SearchFieldNames.size(); ++i) {
       Init *SearchVal = Item->getValueInit(SearchFieldNames[i]);
       SearchTables[i].emplace_back(SearchVal, Idx);
     }
     ++Idx;
   }
 
-  OS << "#ifdef GET_" << StringRef(TableName).upper() << "_DECL\n";
-  OS << "#undef GET_" << StringRef(TableName).upper() << "_DECL\n";
+  OS << "#ifdef GET_" << TableName.upper() << "_DECL\n";
+  OS << "#undef GET_" << TableName.upper() << "_DECL\n";
 
   // Next emit the enum containing the top-level names for use in C++ code if
   // requested
   if (!InstanceClass->isValueUnset("EnumNameField")) {
     emitMappingEnum(Items, InstanceClass, OS);
   }
 
   // And the declarations for the functions that will perform lookup.
   for (unsigned i = 0; i < SearchFieldNames.size(); ++i)
     emitLookupDeclaration(TableName, SearchFieldNames[i],
                           SearchTables[i][0].first, OS);
 
   OS << "#endif\n\n";
 
-  OS << "#ifdef GET_" << StringRef(TableName).upper() << "_IMPL\n";
-  OS << "#undef GET_" << StringRef(TableName).upper() << "_IMPL\n";
+  OS << "#ifdef GET_" << TableName.upper() << "_IMPL\n";
+  OS << "#undef GET_" << TableName.upper() << "_IMPL\n";
 
   // The primary data table contains all the fields defined for this map.
   emitPrimaryTable(TableName, FieldNames, SearchFieldNames, SearchTables, Items,
                    OS);
 
   // Indexes are sorted "{ Thing, PrimaryIdx }" arrays, so that a binary
   // search can be performed by "Thing".
   for (unsigned i = 0; i < SearchTables.size(); ++i) {

llvm/trunk/utils/TableGen/SubtargetEmitter.cpp

for (const CodeGenProcModel &ProcModel : SchedModels.procModels()) {
 
     if (!ItinsDefSet.insert(ProcModel.ItinsDef).second)
       continue;
 
     std::vector<Record*> FUs = ProcModel.ItinsDef->getValueAsListOfDefs("FU");
     if (FUs.empty())
       continue;
 
-    const std::string &Name = ProcModel.ItinsDef->getName();
+    StringRef Name = ProcModel.ItinsDef->getName();
     OS << "\n// Functional units for \"" << Name << "\"\n"
        << "namespace " << Name << "FU {\n";
 
     for (unsigned j = 0, FUN = FUs.size(); j < FUN; ++j)
       OS << "  const unsigned " << FUs[j]->getName()
          << " = 1 << " << j << ";\n";
 
     OS << "} // end namespace " << Name << "FU\n";
for (const CodeGenProcModel &ProcModel : SchedModels.procModels()) {
     ProcItinLists.resize(ProcItinLists.size()+1);
 
     // If this processor defines no itineraries, then leave the itinerary list
     // empty.
     std::vector<InstrItinerary> &ItinList = ProcItinLists.back();
     if (!ProcModel.hasItineraries())
       continue;
 
-    const std::string &Name = ProcModel.ItinsDef->getName();
+    StringRef Name = ProcModel.ItinsDef->getName();
 
     ItinList.resize(SchedModels.numInstrSchedClasses());
     assert(ProcModel.ItinDefList.size() == ItinList.size() && "bad Itins");
 
     for (unsigned SchedClassIdx = 0, SchedClassEnd = ItinList.size();
          SchedClassIdx < SchedClassEnd; ++SchedClassIdx) {
 
       // Next itinerary data
std::vector<std::vector<InstrItinerary>>::iterator
       ProcItinListsIter = ProcItinLists.begin();
   for (CodeGenSchedModels::ProcIter PI = SchedModels.procModelBegin(),
          PE = SchedModels.procModelEnd(); PI != PE; ++PI, ++ProcItinListsIter) {
 
     Record *ItinsDef = PI->ItinsDef;
     if (!ItinsDefSet.insert(ItinsDef).second)
       continue;
 
-    // Get processor itinerary name
-    const std::string &Name = ItinsDef->getName();
-
     // Get the itinerary list for the processor.
     assert(ProcItinListsIter != ProcItinLists.end() && "bad iterator");
     std::vector<InstrItinerary> &ItinList = *ProcItinListsIter;
 
     // Empty itineraries aren't referenced anywhere in the tablegen output
     // so don't emit them.
     if (ItinList.empty())
       continue;
 
     OS << "\n";
     OS << "static const llvm::InstrItinerary ";
 
     // Begin processor itinerary table
-    OS << Name << "[] = {\n";
+    OS << ItinsDef->getName() << "[] = {\n";
 
     // For each itinerary class in CodeGenSchedClass::Index order.
     for (unsigned j = 0, M = ItinList.size(); j < M; ++j) {
       InstrItinerary &Intinerary = ItinList[j];
 
       // Emit Itinerary in the form of
       // { firstStage, lastStage, firstCycle, lastCycle } // index
       OS << "  { " <<

llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp

void RecognizableInstr::handleOperand(bool optional, unsigned &operandIndex,
 
   while (operandMapping[operandIndex] != operandIndex) {
     Spec->operands[operandIndex].encoding = ENCODING_DUP;
     Spec->operands[operandIndex].type =
       (OperandType)(TYPE_DUP0 + operandMapping[operandIndex]);
     ++operandIndex;
   }
 
-  const std::string &typeName = (*Operands)[operandIndex].Rec->getName();
+  StringRef typeName = (*Operands)[operandIndex].Rec->getName();
 
   OperandEncoding encoding = encodingFromString(typeName, OpSize);
   // Adjust the encoding type for an operand based on the instruction.
   adjustOperandEncoding(encoding);
   Spec->operands[operandIndex].encoding = encoding;
   Spec->operands[operandIndex].type = typeFromString(typeName,
                                                      HasREX_WPrefix, OpSize);