Subzero: Improve non-MINIMAL string performance.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 629 matching lines @@
     RR_MustNotHaveRegister,
   };
 
 public:
   static Variable *create(Cfg *Func, Type Ty, SizeT Index) {
     return new (Func->allocate<Variable>())
         Variable(Func, kVariable, Ty, Index);
   }
 
   SizeT getIndex() const { return Number; }
-  std::string getName(const Cfg *Func) const;
+  std::string getName() const {
+    if (Name.hasStdString())
+      return Name.toString();
+    return "__" + std::to_string(getIndex());
+  }
   virtual void setName(const Cfg *Func, const std::string &NewName) {
-    (void)Func;
     if (NewName.empty())
       return;
     Name = VariableString::createWithString(Func, NewName);
   }
 
   bool getIsArg() const { return IsArgument; }
   virtual void setIsArg(bool Val = true) { IsArgument = Val; }
   bool getIsImplicitArg() const { return IsImplicitArgument; }
   void setIsImplicitArg(bool Val = true) { IsImplicitArgument = Val; }
 
   void setIgnoreLiveness() { IgnoreLiveness = true; }
   bool getIgnoreLiveness() const {
     return IgnoreLiveness || IsRematerializable;
   }
 
   int32_t getStackOffset() const { return StackOffset; }
   void setStackOffset(int32_t Offset) { StackOffset = Offset; }
   /// Returns the variable's stack offset in symbolic form, to improve
   /// readability in DecorateAsm mode.
-  std::string getSymbolicStackOffset(const Cfg *Func) const {
+  std::string getSymbolicStackOffset() const {
     if (!BuildDefs::dump())
       return "";
-    return "lv$" + getName(Func);
+    return "lv$" + getName();
   }
 
   bool hasReg() const { return getRegNum().hasValue(); }
   RegNumT getRegNum() const { return RegNum; }
   void setRegNum(RegNumT NewRegNum) {
     // Regnum shouldn't be set more than once.
     assert(!hasReg() || RegNum == NewRegNum);
     RegNum = NewRegNum;
   }
   bool hasRegTmp() const { return getRegNumTmp().hasValue(); }
@@ skipping 62 matching lines @@
   }
 
 protected:
   Variable(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index),
         Name(VariableString::createWithoutString(Func)),
         RegisterClass(static_cast<RegClass>(Ty)) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
-    if (BuildDefs::dump()) {
-      Name = VariableString::createWithString(
-          Func, "__" + std::to_string(getIndex()));
-    } else {
-      Name = VariableString::createWithoutString(Func);
-    }
   }
   /// Number is unique across all variables, and is used as a (bit)vector index
   /// for liveness analysis.
   const SizeT Number;
   VariableString Name;
   bool IsArgument = false;
   bool IsImplicitArgument = false;
   /// IgnoreLiveness means that the variable should be ignored when constructing
   /// and validating live ranges. This is usually reserved for the stack
   /// pointer and other physical registers specifically referenced by name.
@@ skipping 24 matching lines @@
 
 public:
   static Variable64On32 *create(Cfg *Func, Type Ty, SizeT Index) {
     return new (Func->allocate<Variable64On32>())
         Variable64On32(Func, kVariable64On32, Ty, Index);
   }
 
   void setName(const Cfg *Func, const std::string &NewName) override {
     Variable::setName(Func, NewName);
     if (LoVar && HiVar) {
-      LoVar->setName(Func, getName(Func) + "__lo");
-      HiVar->setName(Func, getName(Func) + "__hi");
+      LoVar->setName(Func, getName() + "__lo");
+      HiVar->setName(Func, getName() + "__hi");
     }
   }
 
   void setIsArg(bool Val = true) override {
     Variable::setIsArg(Val);
     if (LoVar && HiVar) {
       LoVar->setIsArg(Val);
       HiVar->setIsArg(Val);
     }
   }
 
   Variable *getLo() const {
     assert(LoVar != nullptr);
     return LoVar;
   }
   Variable *getHi() const {
     assert(HiVar != nullptr);
     return HiVar;
   }
 
   void initHiLo(Cfg *Func) {
     assert(LoVar == nullptr);
     assert(HiVar == nullptr);
     LoVar = Func->makeVariable(IceType_i32);
     HiVar = Func->makeVariable(IceType_i32);
     LoVar->setIsArg(getIsArg());
     HiVar->setIsArg(getIsArg());
     if (BuildDefs::dump()) {
-      LoVar->setName(Func, getName(Func) + "__lo");
-      HiVar->setName(Func, getName(Func) + "__hi");
+      LoVar->setName(Func, getName() + "__lo");
+      HiVar->setName(Func, getName() + "__hi");
     }
   }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kVariable64On32;
   }
 
 protected:
   Variable64On32(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
@@ skipping 117 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H