Subzero: Remove IceString.

src/IceCfg.h

 //===- subzero/src/IceCfg.h - Control flow graph ----------------*- 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 Cfg class, which represents the control flow graph and
 /// the overall per-function compilation context.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICECFG_H
 #define SUBZERO_SRC_ICECFG_H
 
 #include "IceAssembler.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
+#include "IceStringPool.h"
 #include "IceTypes.h"
 
 namespace Ice {
 
 class Cfg {
   Cfg() = delete;
   Cfg(const Cfg &) = delete;
   Cfg &operator=(const Cfg &) = delete;
 
 public:
@@ skipping 13 matching lines @@
   /// Returns true if any of the specified options in the verbose mask are set.
   /// If the argument is omitted, it checks if any verbose options at all are
   /// set.
   bool isVerbose(VerboseMask Mask = defaultVerboseMask()) const {
     return VMask & Mask;
   }
   void setVerbose(VerboseMask Mask) { VMask = Mask; }
 
   /// \name Manage the name and return type of the function being translated.
   /// @{
-  void setFunctionName(const IceString &Name) { FunctionName = Name; }
-  const IceString &getFunctionName() const { return FunctionName; }
-  IceString getFunctionNameAndSize() const;
+  void setFunctionName(GlobalString Name) { FunctionName = Name; }
+  GlobalString getFunctionName() const { return FunctionName; }
+  std::string getFunctionNameAndSize() const;
   void setReturnType(Type Ty) { ReturnType = Ty; }
   Type getReturnType() const { return ReturnType; }
   /// @}
 
   /// \name Manage the "internal" attribute of the function.
   /// @{
   void setInternal(bool Internal) { IsInternalLinkage = Internal; }
   bool getInternal() const { return IsInternalLinkage; }
   /// @}
 
   /// \name Manage errors.
   /// @{
 
   /// Translation error flagging. If support for some construct is known to be
   /// missing, instead of an assertion failure, setError() should be called and
   /// the error should be propagated back up. This way, we can gracefully fail
   /// to translate and let a fallback translator handle the function.
-  void setError(const IceString &Message);
+  void setError(const std::string &Message);
   bool hasError() const { return HasError; }
-  IceString getError() const { return ErrorMessage; }
+  std::string getError() const { return ErrorMessage; }
   /// @}
 
   /// \name Manage nodes (a.k.a. basic blocks, CfgNodes).
   /// @{
   void setEntryNode(CfgNode *EntryNode) { Entry = EntryNode; }
   CfgNode *getEntryNode() const { return Entry; }
   /// Create a node and append it to the end of the linearized list. The loop
   /// nest depth of the new node may not be valid if it is created after
   /// computeLoopNestDepth.
   CfgNode *makeNode();
   SizeT getNumNodes() const { return Nodes.size(); }
   const NodeList &getNodes() const { return Nodes; }
   /// Swap nodes of Cfg with given list of nodes.  The number of nodes must
   /// remain unchanged.
   void swapNodes(NodeList &NewNodes);
   /// @}
 
-  using IdentifierIndexType = int32_t;
-  /// Adds a name to the list and returns its index, suitable for the argument
-  /// to getIdentifierName(). No checking for duplicates is done. This is
-  /// generally used for node names and variable names to avoid embedding a
-  /// std::string inside an arena-allocated object.
-  IdentifierIndexType addIdentifierName(const IceString &Name) {
-    IdentifierIndexType Index = IdentifierNames.size();
-    IdentifierNames.push_back(Name);
-    return Index;
-  }
-  const IceString &getIdentifierName(IdentifierIndexType Index) const {
-    return IdentifierNames[Index];
-  }
-  enum { IdentifierIndexInvalid = -1 };
+  /// String pool for CfgNode::Name values.
+  StringPool *getNodeStrings() const { return NodeStrings.get(); }
+  /// String pool for Variable::Name values.
+  StringPool *getVarStrings() const { return VarStrings.get(); }
 
   /// \name Manage instruction numbering.
   /// @{
   InstNumberT newInstNumber() { return NextInstNumber++; }
   InstNumberT getNextInstNumber() const { return NextInstNumber; }
   /// @}
 
   /// \name Manage Variables.
   /// @{
 
@@ skipping 114 matching lines @@
   void resetCurrentNode() { setCurrentNode(nullptr); }
   const CfgNode *getCurrentNode() const { return CurrentNode; }
   /// @}
 
   /// Get the total amount of memory held by the per-Cfg allocator.  This is
   /// mostly meant for use inside a debugger.
   static size_t getTotalMemoryMB();
 
   void emit();
   void emitIAS();
-  static void emitTextHeader(const IceString &Name, GlobalContext *Ctx,
+  static void emitTextHeader(GlobalString Name, GlobalContext *Ctx,
                              const Assembler *Asm);
   void dump(const char *Message = "");
 
   /// Allocate data of type T using the per-Cfg allocator.
   template <typename T> T *allocate() { return Allocator->Allocate<T>(); }
 
   /// Allocate an array of data of type T using the per-Cfg allocator.
   template <typename T> T *allocateArrayOf(size_t NumElems) {
     return Allocator->Allocate<T>(NumElems);
   }
@@ skipping 15 matching lines @@
 
   /// Adds a call to the ProfileSummary runtime function as the first
   /// instruction in this CFG's entry block.
   void addCallToProfileSummary();
 
   /// Iterates over the basic blocks in this CFG, adding profiling code to each
   /// one of them. It returns a list with all the globals that the profiling
   /// code needs to be defined.
   void profileBlocks();
 
-  void createNodeNameDeclaration(const IceString &NodeAsmName);
+  void createNodeNameDeclaration(const std::string &NodeAsmName);
   void
-  createBlockProfilingInfoDeclaration(const IceString &NodeAsmName,
+  createBlockProfilingInfoDeclaration(const std::string &NodeAsmName,
                                       VariableDeclaration *NodeNameDeclaration);
 
   /// Delete registered jump table placeholder instructions. This should only be
   /// called once all repointing has taken place.
   void deleteJumpTableInsts();
   /// Iterate through the registered jump tables and emit them.
   void emitJumpTables();
 
   enum AllocaBaseVariableType {
     BVT_StackPointer,
     BVT_FramePointer,
     BVT_UserPointer
   };
   void sortAndCombineAllocas(CfgVector<Inst *> &Allocas,
                              uint32_t CombinedAlignment, InstList &Insts,
                              AllocaBaseVariableType BaseVariableType);
   void findRematerializable();
 
   GlobalContext *Ctx;
   uint32_t SequenceNumber;             /// output order for emission
   uint32_t ConstantBlindingCookie = 0; /// cookie for constant blinding
   VerboseMask VMask;
-  IceString FunctionName = "";
+  GlobalString FunctionName;
   Type ReturnType = IceType_void;
   bool IsInternalLinkage = false;
   bool HasError = false;
   bool FocusedTiming = false;
-  IceString ErrorMessage = "";
+  std::string ErrorMessage = "";
   CfgNode *Entry = nullptr; /// entry basic block
   NodeList Nodes;           /// linearized node list; Entry should be first
-  std::vector<IceString> IdentifierNames;
   InstNumberT NextInstNumber;
   VarList Variables;
   VarList Args;         /// subset of Variables, in argument order
   VarList ImplicitArgs; /// subset of Variables
   std::unique_ptr<ArenaAllocator> Allocator;
+  // Separate string pools for CfgNode and Variable names, due to a combination
+  // of the uniqueness requirement, and assumptions in lit tests.
+  std::unique_ptr<StringPool> NodeStrings;
+  std::unique_ptr<StringPool> VarStrings;
   std::unique_ptr<Liveness> Live;
   std::unique_ptr<TargetLowering> Target;
   std::unique_ptr<VariablesMetadata> VMetadata;
   std::unique_ptr<Assembler> TargetAssembler;
   /// Globals required by this CFG. Mostly used for the profiler's globals.
   std::unique_ptr<VariableDeclarationList> GlobalInits;
   CfgVector<InstJumpTable *> JumpTables;
 
   /// CurrentNode is maintained during dumping/emitting just for validating
   /// Variable::DefNode. Normally, a traversal over CfgNodes maintains this, but
   /// before global operations like register allocation, resetCurrentNode()
   /// should be called to avoid spurious validation failures.
   const CfgNode *CurrentNode = nullptr;
 
 public:
   static void TlsInit() { CfgAllocatorTraits::init(); }
 };
 
 template <> Variable *Cfg::makeVariable<Variable>(Type Ty);
 
+struct NodeStringPoolTraits {
+  using OwnerType = Cfg;
+  static StringPool *getStrings(const OwnerType *PoolOwner) {
+    return PoolOwner->getNodeStrings();
+  }
+};
+using NodeString = StringID<NodeStringPoolTraits>;
+
+struct VariableStringPoolTraits {
+  using OwnerType = Cfg;
+  static StringPool *getStrings(const OwnerType *PoolOwner) {
+    return PoolOwner->getVarStrings();
+  }
+};
+using VariableString = StringID<VariableStringPoolTraits>;
+
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECFG_H