Subzero: Remove IceString.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- 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 aspects of the compilation that persist across multiple
 /// functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALCONTEXT_H
 #define SUBZERO_SRC_ICEGLOBALCONTEXT_H
 
 #include "IceDefs.h"
 #include "IceClFlags.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
+#include "IceStringPool.h"
 #include "IceSwitchLowering.h"
 #include "IceTargetLowering.def"
 #include "IceThreading.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 #include "IceUtils.h"
 
 #include <array>
 #include <cassert>
 #include <functional>
@@ skipping 13 matching lines @@
 
 // Runtime helper function IDs
 
 enum class RuntimeHelper {
 #define X(Tag, Name) H_##Tag,
   RUNTIME_HELPER_FUNCTIONS_TABLE
 #undef X
       H_Num
 };
 
-/// LockedPtr is a way to provide automatically locked access to some object.
-template <typename T> class LockedPtr {
-  LockedPtr() = delete;
-  LockedPtr(const LockedPtr &) = delete;
-  LockedPtr &operator=(const LockedPtr &) = delete;
-
-public:
-  LockedPtr(T *Value, GlobalLockType *Lock) : Value(Value), Lock(Lock) {
-    Lock->lock();
-  }
-  LockedPtr(LockedPtr &&Other) : Value(Other.Value), Lock(Other.Lock) {
-    Other.Value = nullptr;
-    Other.Lock = nullptr;
-  }
-  ~LockedPtr() { Lock->unlock(); }
-  T *operator->() const { return Value; }
-  T &operator*() const { return *Value; }
-  T *get() { return Value; }
-
-private:
-  T *Value;
-  GlobalLockType *Lock;
-};
-
 class GlobalContext {
   GlobalContext() = delete;
   GlobalContext(const GlobalContext &) = delete;
   GlobalContext &operator=(const GlobalContext &) = delete;
 
   /// CodeStats collects rudimentary statistics during translation.
   class CodeStats {
     CodeStats(const CodeStats &) = delete;
     CodeStats &operator=(const CodeStats &) = default;
 #define CODESTATS_TABLE                                                        \
@@ skipping 16 matching lines @@
     CodeStats() { reset(); }
     void reset() { Stats.fill(0); }
     void update(CSTag Tag, uint32_t Count = 1) {
       assert(Tag < Stats.size());
       Stats[Tag] += Count;
     }
     void add(const CodeStats &Other) {
       for (uint32_t i = 0; i < Stats.size(); ++i)
         Stats[i] += Other.Stats[i];
     }
-    void dump(const IceString &Name, GlobalContext *Ctx);
+    void dump(const std::string &Name, GlobalContext *Ctx);
 
   private:
     std::array<uint32_t, CS_NUM> Stats;
   };
 
   /// TimerList is a vector of TimerStack objects, with extra methods
   /// to initialize and merge these vectors.
   class TimerList : public std::vector<TimerStack> {
     TimerList(const TimerList &) = delete;
     TimerList &operator=(const TimerList &) = delete;
@@ skipping 38 matching lines @@
     TimerList Timers;
   };
 
 public:
   /// The dump stream is a log stream while emit is the stream code
   /// is emitted to. The error stream is strictly for logging errors.
   GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                 ELFStreamer *ELFStreamer);
   ~GlobalContext();
 
+  void dumpStrings();
   ///
   /// The dump, error, and emit streams need to be used by only one
   /// thread at a time.  This is done by exclusively reserving the
   /// streams via lockStr() and unlockStr().  The OstreamLocker class
   /// can be used to conveniently manage this.
   ///
   /// The model is that a thread grabs the stream lock, then does an
   /// arbitrary amount of work during which far-away callees may grab
   /// the stream and do something with it, and finally the thread
   /// releases the stream lock.  This allows large chunks of output to
@@ skipping 55 matching lines @@
     switch (ConstantInt64) {
     case 0:
       return getConstantZero(IceType_i64);
     default:
       return getConstantInt64Internal(ConstantInt64);
     }
   }
   Constant *getConstantFloat(float Value);
   Constant *getConstantDouble(double Value);
   /// Returns a symbolic constant.
-  Constant *getConstantSym(const RelocOffsetT Offset,
-                           const RelocOffsetArray &OffsetExpr,
-                           const IceString &Name, const IceString &EmitString);
-  Constant *getConstantSym(RelocOffsetT Offset, const IceString &Name);
-  Constant *getConstantExternSym(const IceString &Name);
+  Constant *getConstantSymWithEmitString(const RelocOffsetT Offset,
+                                         const RelocOffsetArray &OffsetExpr,
+                                         GlobalString Name,
+                                         const std::string &EmitString);
+  Constant *getConstantSym(RelocOffsetT Offset, GlobalString Name);
+  Constant *getConstantExternSym(GlobalString Name);
   /// Returns an undef.
   Constant *getConstantUndef(Type Ty);
   /// Returns a zero value.
   Constant *getConstantZero(Type Ty);
   /// getConstantPool() returns a copy of the constant pool for constants of a
   /// given type.
   ConstantList getConstantPool(Type Ty);
   /// Returns a copy of the list of external symbols.
   ConstantList getConstantExternSyms();
   /// @}
   Constant *getRuntimeHelperFunc(RuntimeHelper FuncID) const {
     assert(FuncID < RuntimeHelper::H_Num);
     Constant *Result = RuntimeHelperFunc[static_cast<size_t>(FuncID)];
     assert(Result != nullptr && "No such runtime helper function");
     return Result;
   }
+  GlobalString getGlobalString(const std::string &Name);
 
   /// Return a locked pointer to the registered jump tables.
   JumpTableDataList getJumpTables();
   /// Create a new jump table entry and return a reference to it.
-  JumpTableData &addJumpTable(const IceString &FuncName, SizeT Id,
+  JumpTableData &addJumpTable(GlobalString FuncName, SizeT Id,
                               const JumpTableData::TargetList &TargetList);
 
   static const ClFlags &getFlags() { return Flags; }
 
   /// Allocate data of type T using the global allocator. We allow entities
   /// allocated from this global allocator to be either trivially or
   /// non-trivially destructible. We optimize the case when T is trivially
   /// destructible by not registering a destructor. Destructors will be invoked
   /// during GlobalContext destruction in the reverse object creation order.
   template <typename T>
@@ skipping 12 matching lines @@
 
   const Intrinsics &getIntrinsicsInfo() const { return IntrinsicsInfo; }
 
   ELFObjectWriter *getObjectWriter() const { return ObjectWriter.get(); }
 
   /// Reset stats at the beginning of a function.
   void resetStats() {
     if (BuildDefs::dump())
       ICE_TLS_GET_FIELD(TLS)->StatsFunction.reset();
   }
-  void dumpStats(const IceString &Name, bool Final = false);
+  void dumpStats(const std::string &Name, bool Final = false);
   void statsUpdateEmitted(uint32_t InstCount) {
     if (!getFlags().getDumpStats())
       return;
     ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
     Tls->StatsFunction.update(CodeStats::CS_InstCount, InstCount);
     Tls->StatsCumulative.update(CodeStats::CS_InstCount, InstCount);
   }
   void statsUpdateRegistersSaved(uint32_t Num) {
     if (!getFlags().getDumpStats())
       return;
@@ skipping 30 matching lines @@
     ThreadContext *Tls = ICE_TLS_GET_FIELD(TLS);
     Tls->StatsFunction.update(CodeStats::CS_NumRPImms);
     Tls->StatsCumulative.update(CodeStats::CS_NumRPImms);
   }
 
   /// These are predefined TimerStackIdT values.
   enum TimerStackKind { TSK_Default = 0, TSK_Funcs, TSK_Num };
 
   /// newTimerStackID() creates a new TimerStack in the global space. It does
   /// not affect any TimerStack objects in TLS.
-  TimerStackIdT newTimerStackID(const IceString &Name);
+  TimerStackIdT newTimerStackID(const std::string &Name);
   /// dumpTimers() dumps the global timer data. As such, one probably wants to
   /// call mergeTimerStacks() as a prerequisite.
   void dumpTimers(TimerStackIdT StackID = TSK_Default,
                   bool DumpCumulative = true);
   /// The following methods affect only the calling thread's TLS timer data.
-  TimerIdT getTimerID(TimerStackIdT StackID, const IceString &Name);
+  TimerIdT getTimerID(TimerStackIdT StackID, const std::string &Name);
   void pushTimer(TimerIdT ID, TimerStackIdT StackID);
   void popTimer(TimerIdT ID, TimerStackIdT StackID);
   void resetTimer(TimerStackIdT StackID);
-  void setTimerName(TimerStackIdT StackID, const IceString &NewName);
+  void setTimerName(TimerStackIdT StackID, const std::string &NewName);
 
   /// This is the first work item sequence number that the parser produces, and
   /// correspondingly the first sequence number that the emitter thread will
   /// wait for. Start numbering at 1 to leave room for a sentinel, in case e.g.
   /// we wish to inject items with a special sequence number that may be
   /// executed out of order.
-  static uint32_t getFirstSequenceNumber() { return 1; }
+  static constexpr uint32_t getFirstSequenceNumber() { return 1; }
   /// Adds a newly parsed and constructed function to the Cfg work queue.
   /// Notifies any idle workers that a new function is available for
   /// translating. May block if the work queue is too large, in order to control
   /// memory footprint.
   void optQueueBlockingPush(std::unique_ptr<Cfg> Func);
   /// Takes a Cfg from the work queue for translating. May block if the work
   /// queue is currently empty. Returns nullptr if there is no more work - the
   /// queue is empty and either end() has been called or the Sequential flag was
   /// set.
   std::unique_ptr<Cfg> optQueueBlockingPop();
@@ skipping 80 matching lines @@
     ICE_TLS_SET_FIELD(TLS, MyTLS);
     emitItems();
   }
   /// Emit functions and global initializers from the emitter queue until the
   /// queue is empty.
   void emitItems();
 
   /// Uses DataLowering to lower Globals. Side effects:
   ///  - discards the initializer list for the global variable in Globals.
   ///  - clears the Globals array.
-  void lowerGlobals(const IceString &SectionSuffix);
+  void lowerGlobals(const std::string &SectionSuffix);
 
   /// Lowers the profile information.
   void lowerProfileData();
 
   void dumpConstantLookupCounts();
 
   /// Utility function to match a symbol name against a match string. This is
   /// used in a few cases where we want to take some action on a particular
   /// function or symbol based on a command-line argument, such as changing the
   /// verbose level for a particular function. An empty Match argument means
   /// match everything. Returns true if there is a match.
-  static bool matchSymbolName(const IceString &SymbolName,
-                              const IceString &Match) {
-    return Match.empty() || Match == SymbolName;
-  }
+  static bool matchSymbolName(const GlobalString &SymbolName,
+                              const std::string &Match);
 
   static ClFlags Flags;
 
   /// DisposeGlobalVariablesAfterLowering controls whether the memory used by
   /// GlobaleVariables can be reclaimed right after they have been lowered.
   /// @{
   bool getDisposeGlobalVariablesAfterLowering() const {
     return DisposeGlobalVariablesAfterLowering;
   }
 
   void setDisposeGlobalVariablesAfterLowering(bool Value) {
     DisposeGlobalVariablesAfterLowering = Value;
   }
   /// @}
 
+  LockedPtr<StringPool> getStrings() const {
+    return LockedPtr<StringPool>(Strings.get(), &StringsLock);
+  }
+
 private:
   // Try to ensure mutexes are allocated on separate cache lines.
 
   // Destructors collaborate with Allocator
   ICE_CACHELINE_BOUNDARY;
   // Managed by getAllocator()
-  GlobalLockType AllocLock;
+  mutable GlobalLockType AllocLock;
   ArenaAllocator Allocator;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getInitializerAllocator()
-  GlobalLockType InitAllocLock;
+  mutable GlobalLockType InitAllocLock;
   VariableDeclarationList Globals;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getDestructors()
   using DestructorArray = std::vector<std::function<void()>>;
-  GlobalLockType DestructorsLock;
+  mutable GlobalLockType DestructorsLock;
   DestructorArray Destructors;
 
   ICE_CACHELINE_BOUNDARY;
-  // Managed by getConstantPool()
-  GlobalLockType ConstPoolLock;
+  // Managed by getStrings()
+  mutable GlobalLockType StringsLock;
+  std::unique_ptr<StringPool> Strings;
+
+  ICE_CACHELINE_BOUNDARY;
+  // Managed by getConstPool()
+  mutable GlobalLockType ConstPoolLock;
   std::unique_ptr<ConstantPool> ConstPool;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getJumpTableList()
-  GlobalLockType JumpTablesLock;
+  mutable GlobalLockType JumpTablesLock;
   JumpTableDataList JumpTableList;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getErrorStatus()
-  GlobalLockType ErrorStatusLock;
+  mutable GlobalLockType ErrorStatusLock;
   ErrorCode ErrorStatus;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getStatsCumulative()
-  GlobalLockType StatsLock;
+  mutable GlobalLockType StatsLock;
   CodeStats StatsCumulative;
 
   ICE_CACHELINE_BOUNDARY;
   // Managed by getTimers()
-  GlobalLockType TimerLock;
+  mutable GlobalLockType TimerLock;
   TimerList Timers;
 
   ICE_CACHELINE_BOUNDARY;
   /// StrLock is a global lock on the dump and emit output streams.
   using StrLockType = std::mutex;
   StrLockType StrLock;
   Ostream *StrDump;  /// Stream for dumping / diagnostics
   Ostream *StrEmit;  /// Stream for code emission
   Ostream *StrError; /// Stream for logging errors.
 
@@ skipping 95 matching lines @@
     if (BuildDefs::timers())
       push();
   }
   TimerMarker(TimerIdT ID, const Cfg *Func,
               TimerStackIdT StackID = GlobalContext::TSK_Default)
       : ID(ID), Ctx(nullptr), StackID(StackID) {
     // Ctx gets set at the beginning of pushCfg().
     if (BuildDefs::timers())
       pushCfg(Func);
   }
-  TimerMarker(GlobalContext *Ctx, const IceString &FuncName)
+  TimerMarker(GlobalContext *Ctx, const std::string &FuncName)
       : ID(getTimerIdFromFuncName(Ctx, FuncName)), Ctx(Ctx),
         StackID(GlobalContext::TSK_Funcs) {
     if (BuildDefs::timers())
       push();
   }
 
   ~TimerMarker() {
     if (BuildDefs::timers() && Active)
       Ctx->popTimer(ID, StackID);
   }
 
 private:
   void push();
   void pushCfg(const Cfg *Func);
   static TimerIdT getTimerIdFromFuncName(GlobalContext *Ctx,
-                                         const IceString &FuncName);
+                                         const std::string &FuncName);
   const TimerIdT ID;
   GlobalContext *Ctx;
   const TimerStackIdT StackID;
   bool Active = false;
 };
 
 /// Helper class for locking the streams and then automatically unlocking them.
 class OstreamLocker {
 private:
   OstreamLocker() = delete;
   OstreamLocker(const OstreamLocker &) = delete;
   OstreamLocker &operator=(const OstreamLocker &) = delete;
 
 public:
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H