Subzero: Remove IceString.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 25 matching lines @@
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif // __clang__
 
 #include <algorithm> // max()
 
 namespace std {
 template <> struct hash<Ice::RelocatableTuple> {
   size_t operator()(const Ice::RelocatableTuple &Key) const {
-    if (!Key.EmitString.empty()) {
-      return hash<Ice::IceString>()(Key.EmitString);
-    }
-
-    // If there's no emit string, then we use the relocatable's name, plus the
-    // hash of a combination of the number of OffsetExprs and the known, fixed
-    // offset for the reloc. We left shift the known relocatable by 5 trying to
-    // minimize the interaction between the bits in OffsetExpr.size() and
-    // Key.Offset.
-    return hash<Ice::IceString>()(Key.Name) +
+    // Use the relocatable's name, plus the hash of a combination of the number
+    // of OffsetExprs and the known, fixed offset for the reloc. We left shift
+    // the known relocatable by 5 trying to minimize the interaction between the
+    // bits in OffsetExpr.size() and Key.Offset.
+    return hash<Ice::SizeT>()(Key.Name.getID()) +
            hash<std::size_t>()(Key.OffsetExpr.size() + (Key.Offset << 5));
   }
 };
 } // end of namespace std
 
 namespace Ice {
 
 namespace {
 
 // Define the key comparison function for the constant pool's unordered_map,
@@ skipping 145 matching lines @@
   TypePool<IceType_i8, int8_t, ConstantInteger32> Integers8;
   TypePool<IceType_i16, int16_t, ConstantInteger32> Integers16;
   TypePool<IceType_i32, int32_t, ConstantInteger32> Integers32;
   TypePool<IceType_i64, int64_t, ConstantInteger64> Integers64;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable> Relocatables;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable>
       ExternRelocatables;
   UndefPool Undefs;
 };
 
-void GlobalContext::CodeStats::dump(const IceString &Name, GlobalContext *Ctx) {
+void GlobalContext::CodeStats::dump(const std::string &Name,
+                                    GlobalContext *Ctx) {
   if (!BuildDefs::dump())
     return;
   OstreamLocker _(Ctx);
   Ostream &Str = Ctx->getStrDump();
 #define X(str, tag)                                                            \
   Str << "|" << Name << "|" str "|" << Stats[CS_##tag] << "\n";
   CODESTATS_TABLE
 #undef X
   Str << "|" << Name << "|Spills+Fills|"
       << Stats[CS_NumSpills] + Stats[CS_NumFills] << "\n";
@@ skipping 14 matching lines @@
     Str << "|i32=" << Pool->Integers32.size();
     Str << "|i64=" << Pool->Integers64.size();
     Str << "|Rel=" << Pool->Relocatables.size();
     Str << "|ExtRel=" << Pool->ExternRelocatables.size();
   }
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr)
-    : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
-      StrEmit(OsEmit), StrError(OsError), ObjectWriter(),
-      OptQ(/*Sequential=*/Flags.isSequential(),
-           /*MaxSize=*/Flags.getNumTranslationThreads()),
+    : Strings(new StringPool()), ConstPool(new ConstantPool()), ErrorStatus(),
+      StrDump(OsDump), StrEmit(OsEmit), StrError(OsError), IntrinsicsInfo(this),
+      ObjectWriter(), OptQ(/*Sequential=*/Flags.isSequential(),
+                           /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()),
       DataLowering(TargetDataLowering::createLowering(this)) {
   assert(OsDump && "OsDump is not defined for GlobalContext");
   assert(OsEmit && "OsEmit is not defined for GlobalContext");
   assert(OsError && "OsError is not defined for GlobalContext");
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
   // main() so that all clients (e.g. unit tests) can benefit for
   // free.
@@ skipping 23 matching lines @@
   }
 // Cache up front common constants.
 #define X(tag, sizeLog2, align, elts, elty, str, rcstr)                        \
   ConstZeroForType[IceType_##tag] = getConstantZeroInternal(IceType_##tag);
   ICETYPE_TABLE;
 #undef X
   ConstantTrue = getConstantInt1Internal(1);
 // Define runtime helper functions.
 #define X(Tag, Name)                                                           \
   RuntimeHelperFunc[static_cast<size_t>(RuntimeHelper::H_##Tag)] =             \
-      getConstantExternSym(Name);
+      getConstantExternSym(getGlobalString(Name));
   RUNTIME_HELPER_FUNCTIONS_TABLE
 #undef X
 
   TargetLowering::staticInit(this);
 }
 
 void GlobalContext::translateFunctions() {
   TimerMarker Timer(TimerStack::TT_translateFunctions, this);
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
@@ skipping 27 matching lines @@
       Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber());
     } else {
       Func->getAssembler<>()->setInternal(Func->getInternal());
       switch (getFlags().getOutFileType()) {
       case FT_Elf:
       case FT_Iasm: {
         Func->emitIAS();
         // The Cfg has already emitted into the assembly buffer, so
         // stats have been fully collected into this thread's TLS.
         // Dump them before TLS is reset for the next Cfg.
-        dumpStats(Func->getFunctionNameAndSize());
+        if (BuildDefs::dump())
+          dumpStats(Func->getFunctionNameAndSize());
         auto Asm = Func->releaseAssembler();
         // Copy relevant fields into Asm before Func is deleted.
         Asm->setFunctionName(Func->getFunctionName());
         Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber(),
                                            std::move(Asm));
         Item->setGlobalInits(Func->getGlobalInits());
       } break;
       case FT_Asm:
         // The Cfg has not been emitted yet, so stats are not ready
         // to be dumped.
@@ skipping 40 matching lines @@
 void GlobalContext::lowerJumpTables() { DataLowering->lowerJumpTables(); }
 
 void GlobalContext::saveBlockInfoPtrs() {
   for (VariableDeclaration *Global : Globals) {
     if (Cfg::isProfileGlobal(*Global)) {
       ProfileBlockInfos.push_back(Global);
     }
   }
 }
 
-void GlobalContext::lowerGlobals(const IceString &SectionSuffix) {
+void GlobalContext::lowerGlobals(const std::string &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
   const bool DumpGlobalVariables = BuildDefs::dump() &&
                                    (Flags.getVerbose() & IceV_GlobalInit) &&
                                    Flags.getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
       Global->dump(Stream);
     }
@@ skipping 25 matching lines @@
   assert(ProfileBlockInfoVarDecl == nullptr);
 
   auto GlobalVariablePool = getInitializerAllocator();
   ProfileBlockInfoVarDecl =
       VariableDeclaration::createExternal(GlobalVariablePool.get());
   ProfileBlockInfoVarDecl->setAlignment(typeWidthInBytes(IceType_i64));
   ProfileBlockInfoVarDecl->setIsConstant(true);
 
   // Note: if you change this symbol, make sure to update
   // runtime/szrt_profiler.c as well.
-  ProfileBlockInfoVarDecl->setName("__Sz_block_profile_info");
+  ProfileBlockInfoVarDecl->setName(this, "__Sz_block_profile_info");
 
   for (const VariableDeclaration *PBI : ProfileBlockInfos) {
     if (Cfg::isProfileGlobal(*PBI)) {
       constexpr RelocOffsetT BlockExecutionCounterOffset = 0;
       ProfileBlockInfoVarDecl->addInitializer(
           VariableDeclaration::RelocInitializer::create(
               GlobalVariablePool.get(), PBI,
               {RelocOffset::create(this, BlockExecutionCounterOffset)}));
     }
   }
 
   // This adds a 64-bit sentinel entry to the end of our array. For 32-bit
   // architectures this will waste 4 bytes.
   const SizeT Sizeof64BitNullPtr = typeWidthInBytes(IceType_i64);
   ProfileBlockInfoVarDecl->addInitializer(
       VariableDeclaration::ZeroInitializer::create(GlobalVariablePool.get(),
                                                    Sizeof64BitNullPtr));
   Globals.push_back(ProfileBlockInfoVarDecl);
   constexpr char ProfileDataSection[] = "$sz_profiler$";
   lowerGlobals(ProfileDataSection);
 }
 
+bool GlobalContext::matchSymbolName(const GlobalString &SymbolName,
+                                    const std::string &Match) {
+  return Match.empty() || Match == SymbolName.toString();
+}
+
 void GlobalContext::emitItems() {
   const bool Threaded = !getFlags().isSequential();
   // Pending is a vector containing the reassembled, ordered list of
   // work items.  When we're ready for the next item, we first check
   // whether it's in the Pending list.  If not, we take an item from
   // the work queue, and if it's not the item we're waiting for, we
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
   std::vector<std::unique_ptr<EmitterWorkItem>> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
@@ skipping 70 matching lines @@
         break;
       case EmitterWorkItem::WI_GlobalInits: {
         accumulateGlobals(Item->getGlobalInits());
       } break;
       case EmitterWorkItem::WI_Asm: {
         lowerGlobalsIfNoCodeHasBeenSeen();
         accumulateGlobals(Item->getGlobalInits());
 
         std::unique_ptr<Assembler> Asm = Item->getAsm();
         Asm->alignFunction();
-        const IceString &Name = Asm->getFunctionName();
+        GlobalString Name = Asm->getFunctionName();
         switch (getFlags().getOutFileType()) {
         case FT_Elf:
           getObjectWriter()->writeFunctionCode(Name, Asm->getInternal(),
                                                Asm.get());
           break;
         case FT_Iasm: {
           OstreamLocker L(this);
           Cfg::emitTextHeader(Name, this, Asm.get());
           Asm->emitIASBytes(this);
         } break;
@@ skipping 29 matching lines @@
 }
 
 GlobalContext::~GlobalContext() {
   llvm::DeleteContainerPointers(AllThreadContexts);
   LockedPtr<DestructorArray> Dtors = getDestructors();
   // Destructors are invoked in the opposite object construction order.
   for (const auto &Dtor : reverse_range(*Dtors))
     Dtor();
 }
 
+void GlobalContext::dumpStrings() {
+  if (!getFlags().getDumpStrings())
+    return;
+  OstreamLocker _(this);
+  Ostream &Str = getStrDump();
+  Str << "GlobalContext strings:\n";
+  getStrings()->dump(Str);
+}
+
 void GlobalContext::dumpConstantLookupCounts() {
   if (!BuildDefs::dump())
     return;
   const bool DumpCounts = (Flags.getVerbose() & IceV_ConstPoolStats) &&
                           Flags.getVerboseFocusOn().empty();
   if (!DumpCounts)
     return;
 
   OstreamLocker _(this);
   Ostream &Str = getStrDump();
@@ skipping 60 matching lines @@
 }
 
 Constant *GlobalContext::getConstantFloat(float ConstantFloat) {
   return getConstPool()->Floats.getOrAdd(this, ConstantFloat);
 }
 
 Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
   return getConstPool()->Doubles.getOrAdd(this, ConstantDouble);
 }
 
-Constant *GlobalContext::getConstantSym(const RelocOffsetT Offset,
-                                        const RelocOffsetArray &OffsetExpr,
-                                        const IceString &Name,
-                                        const IceString &EmitString) {
+Constant *GlobalContext::getConstantSymWithEmitString(
+    const RelocOffsetT Offset, const RelocOffsetArray &OffsetExpr,
+    GlobalString Name, const std::string &EmitString) {
   return getConstPool()->Relocatables.getOrAdd(
       this, RelocatableTuple(Offset, OffsetExpr, Name, EmitString));
 }
 
 Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
-                                        const IceString &Name) {
+                                        GlobalString Name) {
   constexpr char EmptyEmitString[] = "";
-  return getConstantSym(Offset, {}, Name, EmptyEmitString);
+  return getConstantSymWithEmitString(Offset, {}, Name, EmptyEmitString);
 }
 
-Constant *GlobalContext::getConstantExternSym(const IceString &Name) {
+Constant *GlobalContext::getConstantExternSym(GlobalString Name) {
   constexpr RelocOffsetT Offset = 0;
   return getConstPool()->ExternRelocatables.getOrAdd(
       this, RelocatableTuple(Offset, {}, Name));
 }
 
 Constant *GlobalContext::getConstantUndef(Type Ty) {
   return getConstPool()->Undefs.getOrAdd(this, Ty);
 }
 
 Constant *GlobalContext::getConstantZero(Type Ty) {
   Constant *Zero = ConstZeroForType[Ty];
   if (Zero == nullptr)
-    llvm::report_fatal_error("Unsupported constant type: " + typeIceString(Ty));
+    llvm::report_fatal_error("Unsupported constant type: " + typeStdString(Ty));
   return Zero;
 }
 
 // All locking is done by the getConstant*() target function.
 Constant *GlobalContext::getConstantZeroInternal(Type Ty) {
   switch (Ty) {
   case IceType_i1:
     return getConstantInt1Internal(0);
   case IceType_i8:
     return getConstantInt8Internal(0);
@@ skipping 26 matching lines @@
   case IceType_f32:
     return getConstPool()->Floats.getConstantPool();
   case IceType_f64:
     return getConstPool()->Doubles.getConstantPool();
   case IceType_v4i1:
   case IceType_v8i1:
   case IceType_v16i1:
   case IceType_v16i8:
   case IceType_v8i16:
   case IceType_v4i32:
-  case IceType_v4f32: {
-    IceString Str;
-    llvm::raw_string_ostream BaseOS(Str);
-    BaseOS << "Unsupported constant type: " << Ty;
-    llvm_unreachable(BaseOS.str().c_str());
-  } break;
+  case IceType_v4f32:
+    llvm::report_fatal_error("Unsupported constant type: " + typeStdString(Ty));
+    break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
 ConstantList GlobalContext::getConstantExternSyms() {
   return getConstPool()->ExternRelocatables.getConstantPool();
 }
 
+GlobalString GlobalContext::getGlobalString(const std::string &Name) {
+  return GlobalString::createWithString(this, Name);
+}
+
 JumpTableDataList GlobalContext::getJumpTables() {
   JumpTableDataList JumpTables(*getJumpTableList());
   // Make order deterministic by sorting into functions and then ID of the jump
   // table within that function.
   std::sort(JumpTables.begin(), JumpTables.end(),
             [](const JumpTableData &A, const JumpTableData &B) {
               if (A.getFunctionName() != B.getFunctionName())
                 return A.getFunctionName() < B.getFunctionName();
               return A.getId() < B.getId();
             });
 
   if (getFlags().getReorderPooledConstants()) {
     // If reorder-pooled-constants option is set to true, we also shuffle the
     // jump tables before emitting them.
 
     // Create a random number generator for jump tables reordering, considering
     // jump tables as pooled constants.
     RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                               RPE_PooledConstantReordering);
     RandomShuffle(JumpTables.begin(), JumpTables.end(),
                   [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
   return JumpTables;
 }
 
 JumpTableData &
-GlobalContext::addJumpTable(const IceString &FuncName, SizeT Id,
+GlobalContext::addJumpTable(GlobalString FuncName, SizeT Id,
                             const JumpTableData::TargetList &TargetList) {
   auto JumpTableList = getJumpTableList();
   JumpTableList->emplace_back(FuncName, Id, TargetList);
   return JumpTableList->back();
 }
 
-TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
+TimerStackIdT GlobalContext::newTimerStackID(const std::string &Name) {
   if (!BuildDefs::timers())
     return 0;
   auto Timers = getTimers();
   TimerStackIdT NewID = Timers->size();
   Timers->push_back(TimerStack(Name));
   return NewID;
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
-                                   const IceString &Name) {
+                                   const std::string &Name) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   return Timers->at(StackID).getTimerID(Name);
 }
 
 void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).push(ID);
 }
 
 void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).pop(ID);
 }
 
 void GlobalContext::resetTimer(TimerStackIdT StackID) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).reset();
 }
 
 void GlobalContext::setTimerName(TimerStackIdT StackID,
-                                 const IceString &NewName) {
+                                 const std::string &NewName) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
 // Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr at the
 // interface to take and transfer ownership, but they internally store the raw
 // Cfg pointer in the work queue. This allows e.g. future queue optimizations
 // such as the use of atomics to modify queue elements.
 void GlobalContext::optQueueBlockingPush(std::unique_ptr<Cfg> Func) {
@@ skipping 20 matching lines @@
   }
   if (getFlags().isSequential())
     emitItems();
 }
 
 std::unique_ptr<EmitterWorkItem> GlobalContext::emitQueueBlockingPop() {
   TimerMarker _(TimerStack::TT_qEmitPop, this);
   return EmitQ.blockingPop();
 }
 
-void GlobalContext::dumpStats(const IceString &Name, bool Final) {
+void GlobalContext::dumpStats(const std::string &Name, bool Final) {
   if (!getFlags().getDumpStats())
     return;
   if (Final) {
     getStatsCumulative()->dump(Name, this);
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, this);
   }
 }
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!BuildDefs::timers())
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
+LockedPtr<StringPool>
+GlobalStringPoolTraits::getStrings(const GlobalContext *PoolOwner) {
+  return PoolOwner->getStrings();
+}
+
 ClFlags GlobalContext::Flags;
 
 TimerIdT TimerMarker::getTimerIdFromFuncName(GlobalContext *Ctx,
-                                             const IceString &FuncName) {
+                                             const std::string &FuncName) {
   if (!BuildDefs::timers())
     return 0;
   if (!Ctx->getFlags().getTimeEachFunction())
     return 0;
   return Ctx->getTimerID(GlobalContext::TSK_Funcs, FuncName);
 }
 
 void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
@@ skipping 13 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice