Subzero: Improve non-MINIMAL string performance.

src/IceRegAlloc.cpp

 //===- subzero/src/IceRegAlloc.cpp - Linear-scan implementation -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 151 matching lines @@
 
   if (!BuildDefs::dump())
     return false;
 
   const VarList &Vars = Func->getVariables();
   OstreamLocker L(Ctx);
   Ostream &Str = Ctx->getStrDump();
   for (SizeT VarNum : DefsWithoutUses) {
     Variable *Var = Vars[VarNum];
     Str << "LR def without use, instruction " << LRBegin[VarNum]
-        << ", variable " << Var->getName(Func) << "\n";
+        << ", variable " << Var->getName() << "\n";
   }
   for (SizeT VarNum : UsesBeforeDefs) {
     Variable *Var = Vars[VarNum];
     Str << "LR use before def, instruction " << LREnd[VarNum] << ", variable "
-        << Var->getName(Func) << "\n";
+        << Var->getName() << "\n";
   }
   return false;
 }
 
 // Prepare for very simple register allocation of only infinite-weight Variables
 // while respecting pre-colored Variables. Some properties we take advantage of:
 //
 // * Live ranges of interest consist of a single segment.
 //
 // * Live ranges of interest never span a call instruction.
@@ skipping 82 matching lines @@
     return;
   }
 
   if (!DefsWithoutUses.empty() || !UsesBeforeDefs.empty()) {
     if (BuildDefs::dump()) {
       OstreamLocker L(Ctx);
       Ostream &Str = Ctx->getStrDump();
       for (SizeT VarNum : DefsWithoutUses) {
         Variable *Var = Vars[VarNum];
         Str << "LR def without use, instruction " << LRBegin[VarNum]
-            << ", variable " << Var->getName(Func) << "\n";
+            << ", variable " << Var->getName() << "\n";
       }
       for (SizeT VarNum : UsesBeforeDefs) {
         Variable *Var = Vars[VarNum];
         Str << "LR use before def, instruction " << LREnd[VarNum]
-            << ", variable " << Var->getName(Func) << "\n";
+            << ", variable " << Var->getName() << "\n";
       }
     }
     llvm::report_fatal_error("initForInfOnly: Liveness error");
   }
   // This isn't actually a fatal condition, but it would be nice to know if we
   // somehow pre-calculated Unhandled's size wrong.
   assert(NumVars == 0);
 
   // Don't build up the list of Kills because we know that no infinite-weight
   // Variable has a live range spanning a call.
@@ skipping 412 matching lines @@
       // At this point, we need to find some reserve register that is already
       // assigned to a non-infinite-weight variable.  This could happen if some
       // variable was previously assigned an alias of such a register.
       MinWeightIndex = findMinWeightIndex(Iter.RegMaskUnfiltered, Iter.Weights);
     }
     if (Iter.Cur->getWeight(Func) <= Iter.Weights[MinWeightIndex]) {
       dumpLiveRangeTrace("Failing      ", Iter.Cur);
       Func->setError("Unable to find a physical register for an "
                      "infinite-weight live range "
                      "(consider using -reg-reserve): " +
-                     Iter.Cur->getName(Func));
+                     Iter.Cur->getName());
       Handled.push_back(Iter.Cur);
       return;
     }
     // At this point, MinWeightIndex points to a valid reserve register to
     // reallocate to Iter.Cur, so drop into the eviction code.
   }
 
   // Evict all live ranges in Active that register number MinWeightIndex is
   // assigned to.
   const auto &Aliases = *RegAliases[MinWeightIndex];
@@ skipping 280 matching lines @@
     Str << "\n";
   }
   Str << "++++++ Inactive:\n";
   for (const Variable *Item : Inactive) {
     dumpLiveRange(Item, Func);
     Str << "\n";
   }
 }
 
 } // end of namespace Ice