Subzero: Remove IceString.

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 14 matching lines @@
 #include "IceInstVarIter.h"
 #include "IceLiveness.h"
 #include "IceLoopAnalyzer.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 Cfg::Cfg(GlobalContext *Ctx, uint32_t SequenceNumber)
     : Ctx(Ctx), SequenceNumber(SequenceNumber),
-      VMask(Ctx->getFlags().getVerbose()), NextInstNumber(Inst::NumberInitial),
-      Live(nullptr) {
+      VMask(Ctx->getFlags().getVerbose()), FunctionName(),
+      NextInstNumber(Inst::NumberInitial), Live(nullptr) {
   Allocator.reset(new ArenaAllocator());
+  NodeStrings.reset(new StringPool);
+  VarStrings.reset(new StringPool);
   CfgLocalAllocatorScope _(this);
   Target =
       TargetLowering::createLowering(Ctx->getFlags().getTargetArch(), this);
   VMetadata.reset(new VariablesMetadata(this));
   TargetAssembler = Target->createAssembler();
 
   if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_Randomize) {
     // If -randomize-pool-immediates=randomize, create a random number
     // generator to generate a cookie for constant blinding.
     RandomNumberGenerator RNG(Ctx->getFlags().getRandomSeed(),
                               RPE_ConstantBlinding, this->SequenceNumber);
     ConstantBlindingCookie =
         (uint32_t)RNG.next((uint64_t)std::numeric_limits<uint32_t>::max() + 1);
   }
 }
 
-Cfg::~Cfg() { assert(CfgAllocatorTraits::current() == nullptr); }
+Cfg::~Cfg() {
+  assert(CfgAllocatorTraits::current() == nullptr);
+  if (GlobalContext::getFlags().getDumpStrings()) {
+    OstreamLocker _(Ctx);
+    Ostream &Str = Ctx->getStrDump();
+    getNodeStrings()->dump(Str);
+    getVarStrings()->dump(Str);
+  }
+}
 
 /// Create a string like "foo(i=123:b=9)" indicating the function name, number
 /// of high-level instructions, and number of basic blocks.  This string is only
 /// used for dumping and other diagnostics, and the idea is that given a set of
 /// functions to debug a problem on, it's easy to find the smallest or simplest
 /// function to attack.  Note that the counts may change somewhat depending on
 /// what point it is called during the translation passes.
-IceString Cfg::getFunctionNameAndSize() const {
+std::string Cfg::getFunctionNameAndSize() const {
   if (!BuildDefs::dump())
-    return getFunctionName();
+    return getFunctionName().toString();
   SizeT NodeCount = 0;
   SizeT InstCount = 0;
   for (CfgNode *Node : getNodes()) {
     ++NodeCount;
     // Note: deleted instructions are *not* ignored.
     InstCount += Node->getPhis().size();
     for (Inst &I : Node->getInsts()) {
       if (!llvm::isa<InstTarget>(&I))
         ++InstCount;
     }
   }
   return getFunctionName() + "(i=" + std::to_string(InstCount) + ":b=" +
          std::to_string(NodeCount) + ")";
 }
 
-void Cfg::setError(const IceString &Message) {
+void Cfg::setError(const std::string &Message) {
   HasError = true;
   ErrorMessage = Message;
 }
 
 CfgNode *Cfg::makeNode() {
   SizeT LabelIndex = Nodes.size();
   auto *Node = CfgNode::create(this, LabelIndex);
   Nodes.push_back(Node);
   return Node;
 }
@@ skipping 26 matching lines @@
 
 // Returns whether the stack frame layout has been computed yet. This is used
 // for dumping the stack frame location of Variables.
 bool Cfg::hasComputedFrame() const { return getTarget()->hasComputedFrame(); }
 
 namespace {
 constexpr char BlockNameGlobalPrefix[] = ".L$profiler$block_name$";
 constexpr char BlockStatsGlobalPrefix[] = ".L$profiler$block_info$";
 } // end of anonymous namespace
 
-void Cfg::createNodeNameDeclaration(const IceString &NodeAsmName) {
+void Cfg::createNodeNameDeclaration(const std::string &NodeAsmName) {
   auto *Var = VariableDeclaration::create(GlobalInits.get());
-  Var->setName(BlockNameGlobalPrefix + NodeAsmName);
+  Var->setName(Ctx, BlockNameGlobalPrefix + NodeAsmName);
   Var->setIsConstant(true);
   Var->addInitializer(VariableDeclaration::DataInitializer::create(
       GlobalInits.get(), NodeAsmName.data(), NodeAsmName.size() + 1));
   const SizeT Int64ByteSize = typeWidthInBytes(IceType_i64);
   Var->setAlignment(Int64ByteSize); // Wasteful, 32-bit could use 4 bytes.
   GlobalInits->push_back(Var);
 }
 
 void Cfg::createBlockProfilingInfoDeclaration(
-    const IceString &NodeAsmName, VariableDeclaration *NodeNameDeclaration) {
+    const std::string &NodeAsmName, VariableDeclaration *NodeNameDeclaration) {
   auto *Var = VariableDeclaration::create(GlobalInits.get());
-  Var->setName(BlockStatsGlobalPrefix + NodeAsmName);
+  Var->setName(Ctx, BlockStatsGlobalPrefix + NodeAsmName);
   const SizeT Int64ByteSize = typeWidthInBytes(IceType_i64);
   Var->addInitializer(VariableDeclaration::ZeroInitializer::create(
       GlobalInits.get(), Int64ByteSize));
 
   const RelocOffsetT NodeNameDeclarationOffset = 0;
   Var->addInitializer(VariableDeclaration::RelocInitializer::create(
       GlobalInits.get(), NodeNameDeclaration,
       {RelocOffset::create(Ctx, NodeNameDeclarationOffset)}));
   Var->setAlignment(Int64ByteSize);
   GlobalInits->push_back(Var);
 }
 
 void Cfg::profileBlocks() {
   if (GlobalInits == nullptr)
     GlobalInits.reset(new VariableDeclarationList());
 
   for (CfgNode *Node : Nodes) {
-    const IceString NodeAsmName = Node->getAsmName();
+    const std::string NodeAsmName = Node->getAsmName();
     createNodeNameDeclaration(NodeAsmName);
     createBlockProfilingInfoDeclaration(NodeAsmName, GlobalInits->back());
     Node->profileExecutionCount(GlobalInits->back());
   }
 }
 
 bool Cfg::isProfileGlobal(const VariableDeclaration &Var) {
-  return Var.getName().find(BlockStatsGlobalPrefix) == 0;
+  if (!Var.getName().hasStdString())
+    return false;
+  return Var.getName().toString().find(BlockStatsGlobalPrefix) == 0;
 }
 
 void Cfg::addCallToProfileSummary() {
   // The call(s) to __Sz_profile_summary are added by the profiler in functions
   // that cause the program to exit. This function is defined in
   // runtime/szrt_profiler.c.
   Constant *ProfileSummarySym =
-      Ctx->getConstantExternSym("__Sz_profile_summary");
+      Ctx->getConstantExternSym(Ctx->getGlobalString("__Sz_profile_summary"));
   constexpr SizeT NumArgs = 0;
   constexpr Variable *Void = nullptr;
   constexpr bool HasTailCall = false;
   auto *Call =
       InstCall::create(this, NumArgs, Void, ProfileSummarySym, HasTailCall);
   getEntryNode()->getInsts().push_front(Call);
 }
 
 void Cfg::translate() {
   if (hasError())
     return;
   if (BuildDefs::dump()) {
-    const IceString &TimingFocusOn =
+    const std::string TimingFocusOn =
         getContext()->getFlags().getTimingFocusOn();
-    const IceString &Name = getFunctionName();
+    const std::string Name = getFunctionName().toString();
     if (TimingFocusOn == "*" || TimingFocusOn == Name) {
       setFocusedTiming();
       getContext()->resetTimer(GlobalContext::TSK_Default);
       getContext()->setTimerName(GlobalContext::TSK_Default, Name);
     }
     if (isVerbose(IceV_Status)) {
       getContext()->getStrDump() << ">>>Translating "
                                  << getFunctionNameAndSize() << "\n";
     }
   }
-  TimerMarker T_func(getContext(), getFunctionName());
+  TimerMarker T_func(getContext(), getFunctionName().toStringOrEmpty());
   TimerMarker T(TimerStack::TT_translate, this);
 
   dump("Initial CFG");
 
   if (getContext()->getFlags().getEnableBlockProfile()) {
     profileBlocks();
     // TODO(jpp): this is fragile, at best. Figure out a better way of
     // detecting exit functions.
     if (GlobalContext::matchSymbolName(getFunctionName(), "exit")) {
       addCallToProfileSummary();
@@ skipping 747 matching lines @@
   for (const InstJumpTable *JT : JumpTables)
     for (SizeT I = 0; I < JT->getNumTargets(); ++I)
       JT->getTarget(I)->setNeedsAlignment();
 }
 
 // ======================== Dump routines ======================== //
 
 // emitTextHeader() is not target-specific (apart from what is abstracted by
 // the Assembler), so it is defined here rather than in the target lowering
 // class.
-void Cfg::emitTextHeader(const IceString &Name, GlobalContext *Ctx,
+void Cfg::emitTextHeader(GlobalString Name, GlobalContext *Ctx,
                          const Assembler *Asm) {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   Str << "\t.text\n";
   if (Ctx->getFlags().getFunctionSections())
     Str << "\t.section\t.text." << Name << ",\"ax\",%progbits\n";
   if (!Asm->getInternal() || Ctx->getFlags().getDisableInternal()) {
     Str << "\t.globl\t" << Name << "\n";
     Str << "\t.type\t" << Name << ",%function\n";
@@ skipping 155 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice