Subzero: Remove IceString.

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
 /// \brief Declares the Operand class and its target-independent subclasses.
 ///
 /// The main classes are Variable, which represents an LLVM variable that is
 /// either register- or stack-allocated, and the Constant hierarchy, which
 /// represents integer, floating-point, and/or symbolic constants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceDefs.h"
 #include "IceCfg.h"
 #include "IceGlobalContext.h"
+#include "IceStringPool.h"
 #include "IceTypes.h"
 
 #include "llvm/Support/Format.h"
 
 #include <limits>
 #include <type_traits>
 
 namespace Ice {
 
 class Operand {
@@ skipping 79 matching lines @@
 }
 
 /// Constant is the abstract base class for constants. All constants are
 /// allocated from a global arena and are pooled.
 class Constant : public Operand {
   Constant() = delete;
   Constant(const Constant &) = delete;
   Constant &operator=(const Constant &) = delete;
 
 public:
-  virtual void emitPoolLabel(Ostream &Str) const {
-    (void)Str;
-    llvm::report_fatal_error("emitPoolLabel not defined for type");
-  };
   // Declare the lookup counter to take minimal space in a non-DUMP build.
   using CounterType =
       std::conditional<BuildDefs::dump(), uint64_t, uint8_t>::type;
   void emit(const Cfg *Func) const override { emit(Func->getTarget()); }
   virtual void emit(TargetLowering *Target) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Max;
   }
 
+  const GlobalString getLabelName() const { return LabelName; }
+
   /// Judge if this given immediate should be randomized or pooled By default
   /// should return false, only constant integers should truly go through this
   /// method.
-  virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
-    (void)Ctx;
-    return false;
-  }
+  virtual bool shouldBeRandomizedOrPooled() const { return false; }
 
-  void setShouldBePooled(bool R) { ShouldBePooled = R; }
+  void initShouldBePooled();
   bool getShouldBePooled() const { return ShouldBePooled; }
 
   // This should be thread-safe because the constant pool lock is acquired
   // before the method is invoked.
   void updateLookupCount() {
     if (!BuildDefs::dump())
       return;
     ++LookupCount;
   }
   CounterType getLookupCount() const { return LookupCount; }
 
 protected:
-  Constant(OperandKind Kind, Type Ty) : Operand(Kind, Ty) {
+  Constant(GlobalContext *, OperandKind Kind, Type Ty) : Operand(Kind, Ty) {
     Vars = nullptr;
     NumVars = 0;
   }
+  GlobalString LabelName;
   /// Whether we should pool this constant. Usually Float/Double and pooled
-  /// Integers should be flagged true.
+  /// Integers should be flagged true.  Ideally this field would be const, but
+  /// it needs to be initialized only after the subclass is fully constructed.
   bool ShouldBePooled = false;
   /// Note: If ShouldBePooled is ever removed from the base class, we will want
   /// to completely disable LookupCount in a non-DUMP build to save space.
   CounterType LookupCount = 0;
 };
 
 /// ConstantPrimitive<> wraps a primitive type.
 template <typename T, Operand::OperandKind K>
 class ConstantPrimitive : public Constant {
   ConstantPrimitive() = delete;
   ConstantPrimitive(const ConstantPrimitive &) = delete;
   ConstantPrimitive &operator=(const ConstantPrimitive &) = delete;
 
 public:
   using PrimType = T;
 
   static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty,
                                    PrimType Value) {
-    return new (Ctx->allocate<ConstantPrimitive>())
-        ConstantPrimitive(Ty, Value);
+    auto *Const = new (Ctx->allocate<ConstantPrimitive>())
+        ConstantPrimitive(Ctx, Ty, Value);
+    Const->initShouldBePooled();
+    if (Const->getShouldBePooled())
+      Const->initName(Ctx);
+    return Const;
   }
   PrimType getValue() const { return Value; }
-  void emitPoolLabel(Ostream &Str) const final {
+  using Constant::emit;
+  void emit(TargetLowering *Target) const final;
+  using Constant::dump;
+  void dump(const Cfg *, Ostream &Str) const override {
+    if (BuildDefs::dump())
+      Str << getValue();
+  }
+
+  static bool classof(const Operand *Operand) {
+    return Operand->getKind() == K;
+  }
+
+  virtual bool shouldBeRandomizedOrPooled() const override { return false; }
+
+private:
+  ConstantPrimitive(GlobalContext *Ctx, Type Ty, PrimType Value)
+      : Constant(Ctx, K, Ty), Value(Value) {}
+
+  void initName(GlobalContext *Ctx) {
+    std::string Buffer;
+    llvm::raw_string_ostream Str(Buffer);
     Str << ".L$" << getType() << "$";
     // Print hex characters byte by byte, starting from the most significant
     // byte.  NOTE: This ordering assumes Subzero runs on a little-endian
     // platform.  That means the possibility of different label names depending
     // on the endian-ness of the platform where Subzero runs.
     for (unsigned i = 0; i < sizeof(Value); ++i) {
       constexpr unsigned HexWidthChars = 2;
       unsigned Offset = sizeof(Value) - 1 - i;
       Str << llvm::format_hex_no_prefix(
           *(Offset + (const unsigned char *)&Value), HexWidthChars);
     }
     // For a floating-point value in DecorateAsm mode, also append the value in
     // human-readable sprintf form, changing '+' to 'p' and '-' to 'm' to
     // maintain valid asm labels.
     if (std::is_floating_point<PrimType>::value && !BuildDefs::minimal() &&
         GlobalContext::getFlags().getDecorateAsm()) {
       char Buf[30];
       snprintf(Buf, llvm::array_lengthof(Buf), "$%g", (double)Value);
       for (unsigned i = 0; i < llvm::array_lengthof(Buf) && Buf[i]; ++i) {
         if (Buf[i] == '-')
           Buf[i] = 'm';
         else if (Buf[i] == '+')
           Buf[i] = 'p';
       }
       Str << Buf;
     }
-  }
-  using Constant::emit;
-  void emit(TargetLowering *Target) const final;
-  using Constant::dump;
-  void dump(const Cfg *, Ostream &Str) const override {
-    if (BuildDefs::dump())
-      Str << getValue();
+    LabelName = GlobalString(Ctx, Str.str());
   }
 
-  static bool classof(const Operand *Operand) {
-    return Operand->getKind() == K;
-  }
-
-  virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) override {
-    (void)Ctx;
-    return false;
-  }
-
-private:
-  ConstantPrimitive(Type Ty, PrimType Value) : Constant(K, Ty), Value(Value) {}
   const PrimType Value;
 };
 
 using ConstantInteger32 = ConstantPrimitive<int32_t, Operand::kConstInteger32>;
 using ConstantInteger64 = ConstantPrimitive<int64_t, Operand::kConstInteger64>;
 using ConstantFloat = ConstantPrimitive<float, Operand::kConstFloat>;
 using ConstantDouble = ConstantPrimitive<double, Operand::kConstDouble>;
 
 template <>
 inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int32_t>(getValue());
 }
 
 /// Specialization of the template member function for ConstantInteger32
-template <>
-bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx);
+template <> bool ConstantInteger32::shouldBeRandomizedOrPooled() const;
 
 template <>
 inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
   assert(getType() == IceType_i64);
   Str << static_cast<int64_t>(getValue());
 }
 
 /// RelocOffset allows symbolic references in ConstantRelocatables' offsets,
@@ skipping 42 matching lines @@
 
 /// RelocatableTuple bundles the parameters that are used to construct an
 /// ConstantRelocatable. It is done this way so that ConstantRelocatable can fit
 /// into the global constant pool template mechanism.
 class RelocatableTuple {
   RelocatableTuple() = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
   RelocatableTuple(const RelocOffsetT Offset,
-                   const RelocOffsetArray &OffsetExpr, const IceString &Name)
+                   const RelocOffsetArray &OffsetExpr, GlobalString Name)
       : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name) {}
 
   RelocatableTuple(const RelocOffsetT Offset,
-                   const RelocOffsetArray &OffsetExpr, const IceString &Name,
-                   const IceString &EmitString)
+                   const RelocOffsetArray &OffsetExpr, GlobalString Name,
+                   const std::string &EmitString)
       : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name),
         EmitString(EmitString) {}
 
   RelocatableTuple(const RelocatableTuple &) = default;
 
   const RelocOffsetT Offset;
   const RelocOffsetArray OffsetExpr;
-  const IceString Name;
-  const IceString EmitString;
+  const GlobalString Name;
+  const std::string EmitString;
 };
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 /// ConstantRelocatable represents a symbolic constant combined with a fixed
 /// offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable() = delete;
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
   template <typename T>
-  static ConstantRelocatable *create(T *AllocOwner, Type Ty,
+  static ConstantRelocatable *create(T *AllocOwner, GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple) {
     return new (AllocOwner->template allocate<ConstantRelocatable>())
-        ConstantRelocatable(Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name,
+        ConstantRelocatable(Ctx, Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name,
                             Tuple.EmitString);
   }
+  static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
+                                     const RelocatableTuple &Tuple) {
+    return create(Ctx, Ctx, Ty, Tuple);
+  }
 
   RelocOffsetT getOffset() const {
     RelocOffsetT Ret = Offset;
     for (const auto *const OffsetReloc : OffsetExpr) {
       Ret += OffsetReloc->getOffset();
     }
     return Ret;
   }
 
-  const IceString &getEmitString() const { return EmitString; }
+  const std::string &getEmitString() const { return EmitString; }
 
-  const IceString &getName() const { return Name; }
+  GlobalString getName() const { return Name; }
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   void emitWithoutPrefix(const TargetLowering *Target,
                          const char *Suffix = "") const;
   using Constant::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
-  ConstantRelocatable(Type Ty, const RelocOffsetT Offset,
-                      const RelocOffsetArray &OffsetExpr, const IceString &Name,
-                      const IceString &EmitString)
-      : Constant(kConstRelocatable, Ty), Offset(Offset), OffsetExpr(OffsetExpr),
-        Name(Name), EmitString(EmitString) {}
+  ConstantRelocatable(GlobalContext *Ctx, Type Ty, const RelocOffsetT Offset,
+                      const RelocOffsetArray &OffsetExpr, GlobalString Name,
+                      const std::string &EmitString)
+      : Constant(Ctx, kConstRelocatable, Ty), Offset(Offset),
+        OffsetExpr(OffsetExpr), Name(Name), EmitString(EmitString) {}
 
   const RelocOffsetT Offset;         /// fixed, known offset to add
   const RelocOffsetArray OffsetExpr; /// fixed, unknown offset to add
-  const IceString Name;              /// optional for debug/dump
-  const IceString EmitString;        /// optional for textual emission
+  const GlobalString Name;           /// optional for debug/dump
+  const std::string EmitString;      /// optional for textual emission
 };
 
 /// ConstantUndef represents an unspecified bit pattern. Although it is legal to
 /// lower ConstantUndef to any value, backends should try to make code
 /// generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef() = delete;
   ConstantUndef(const ConstantUndef &) = delete;
   ConstantUndef &operator=(const ConstantUndef &) = delete;
 
 public:
   static ConstantUndef *create(GlobalContext *Ctx, Type Ty) {
-    return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty);
+    return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ctx, Ty);
   }
 
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   using Constant::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (BuildDefs::dump())
       Str << "undef";
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
 
 private:
-  ConstantUndef(Type Ty) : Constant(kConstUndef, Ty) {}
+  ConstantUndef(GlobalContext *Ctx, Type Ty) : Constant(Ctx, kConstUndef, Ty) {}
 };
 
 /// RegNumT is for holding target-specific register numbers, plus the sentinel
 /// value if no register is assigned. Its public ctor allows direct use of enum
 /// values, such as RegNumT(Reg_eax), but not things like RegNumT(Reg_eax+1).
 /// This is to try to prevent inappropriate assumptions about enum ordering. If
 /// needed, the fromInt() method can be used, such as when a RegNumT is based
 /// on a bitvector index.
 class RegNumT {
 public:
@@ skipping 204 matching lines @@
   Variable &operator=(const Variable &) = delete;
 
   enum RegRequirement : uint8_t {
     RR_MayHaveRegister,
     RR_MustHaveRegister,
     RR_MustNotHaveRegister,
   };
 
 public:
   static Variable *create(Cfg *Func, Type Ty, SizeT Index) {
-    return new (Func->allocate<Variable>()) Variable(kVariable, Ty, Index);
+    return new (Func->allocate<Variable>())
+        Variable(Func, kVariable, Ty, Index);
   }
 
   SizeT getIndex() const { return Number; }
-  IceString getName(const Cfg *Func) const;
-  virtual void setName(Cfg *Func, const IceString &NewName) {
-    // Make sure that the name can only be set once.
-    assert(NameIndex == Cfg::IdentifierIndexInvalid);
-    if (!NewName.empty())
-      NameIndex = Func->addIdentifierName(NewName);
+  std::string getName(const Cfg *Func) const;
+  virtual void setName(const Cfg *Func, const std::string &NewName) {
+    (void)Func;
+    if (NewName.empty())
+      return;
+    Name = VariableString(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; }
 
   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.
-  IceString getSymbolicStackOffset(const Cfg *Func) const {
+  std::string getSymbolicStackOffset(const Cfg *Func) const {
     if (!BuildDefs::dump())
       return "";
     return "lv$" + getName(Func);
   }
 
   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);
@@ skipping 43 matching lines @@
     constexpr bool UseTrimmed = true;
     return Live.overlapsInst(Other->Live.getStart(), UseTrimmed);
   }
 
   /// Creates a temporary copy of the variable with a different type. Used
   /// primarily for syntactic correctness of textual assembly emission. Note
   /// that only basic information is copied, in particular not IsArgument,
   /// IsImplicitArgument, IgnoreLiveness, RegNumTmp, Live, LoVar, HiVar,
   /// VarsReal. If NewRegNum.hasValue(), then that register assignment is made
   /// instead of copying the existing assignment.
-  const Variable *asType(Type Ty, RegNumT NewRegNum) const;
+  const Variable *asType(const Cfg *Func, Type Ty, RegNumT NewRegNum) const;
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   /// Return reg num of base register, if different from stack/frame register.
   virtual RegNumT getBaseRegNum() const { return RegNumT(); }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Max;
   }
 
 protected:
-  Variable(OperandKind K, Type Ty, SizeT Index)
-      : Operand(K, Ty), Number(Index),
+  Variable(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
+      : Operand(K, Ty), Number(Index), Name(Func),
         RegisterClass(static_cast<RegClass>(Ty)) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
+    if (BuildDefs::dump()) {
+      Name = VariableString(Func, "__" + std::to_string(getIndex()));
+    } else {
+      Name = VariableString(Func);
+    }
   }
   /// Number is unique across all variables, and is used as a (bit)vector index
   /// for liveness analysis.
   const SizeT Number;
-  Cfg::IdentifierIndexType NameIndex = Cfg::IdentifierIndexInvalid;
+  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.
   bool IgnoreLiveness = false;
   // If IsRematerializable, RegNum keeps track of which register (stack or frame
   // pointer), and StackOffset is the known offset from that register.
   bool IsRematerializable = false;
   RegRequirement RegRequirement = RR_MayHaveRegister;
@@ skipping 13 matching lines @@
 // Variable64On32 represents a 64-bit variable on a 32-bit architecture. In
 // this situation the variable must be split into a low and a high word.
 class Variable64On32 : public Variable {
   Variable64On32() = delete;
   Variable64On32(const Variable64On32 &) = delete;
   Variable64On32 &operator=(const Variable64On32 &) = delete;
 
 public:
   static Variable64On32 *create(Cfg *Func, Type Ty, SizeT Index) {
     return new (Func->allocate<Variable64On32>())
-        Variable64On32(kVariable64On32, Ty, Index);
+        Variable64On32(Func, kVariable64On32, Ty, Index);
   }
 
-  void setName(Cfg *Func, const IceString &NewName) override {
+  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");
     }
   }
 
   void setIsArg(bool Val = true) override {
     Variable::setIsArg(Val);
     if (LoVar && HiVar) {
@@ skipping 11 matching lines @@
     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());
-    LoVar->setName(Func, getName(Func) + "__lo");
-    HiVar->setName(Func, getName(Func) + "__hi");
+    if (BuildDefs::dump()) {
+      LoVar->setName(Func, getName(Func) + "__lo");
+      HiVar->setName(Func, getName(Func) + "__hi");
+    }
   }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kVariable64On32;
   }
 
 protected:
-  Variable64On32(OperandKind K, Type Ty, SizeT Index) : Variable(K, Ty, Index) {
+  Variable64On32(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
+      : Variable(Func, K, Ty, Index) {
     assert(typeWidthInBytes(Ty) == 8);
   }
 
   Variable *LoVar = nullptr;
   Variable *HiVar = nullptr;
 };
 
 enum MetadataKind {
   VMK_Uses,       /// Track only uses, not defs
   VMK_SingleDefs, /// Track uses+defs, but only record single def
@@ skipping 100 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H