Subzero: Remove IceString.

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 58 matching lines @@
     return ELFTargetInfo[Arch].ELFFlags;
   llvm_unreachable("Invalid target arch for getELFFlags");
   return 0;
 }
 
 } // end of anonymous namespace
 
 ELFObjectWriter::ELFObjectWriter(GlobalContext &Ctx, ELFStreamer &Out)
     : Ctx(Ctx), Str(Out), ELF64(isELF64(Ctx.getFlags())) {
   // Create the special bookkeeping sections now.
-  const IceString NullSectionName("");
+  constexpr char NullSectionName[] = "";
   NullSection = new (Ctx.allocate<ELFSection>())
       ELFSection(NullSectionName, SHT_NULL, 0, 0, 0);
 
-  const IceString ShStrTabName(".shstrtab");
+  constexpr char ShStrTabName[] = ".shstrtab";
   ShStrTab = new (Ctx.allocate<ELFStringTableSection>())
       ELFStringTableSection(ShStrTabName, SHT_STRTAB, 0, 1, 0);
   ShStrTab->add(ShStrTabName);
 
-  const IceString SymTabName(".symtab");
+  constexpr char SymTabName[] = ".symtab";
   const Elf64_Xword SymTabAlign = ELF64 ? 8 : 4;
   const Elf64_Xword SymTabEntSize =
       ELF64 ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym);
   static_assert(sizeof(Elf64_Sym) == 24 && sizeof(Elf32_Sym) == 16,
                 "Elf_Sym sizes cannot be derived from sizeof");
   SymTab = createSection<ELFSymbolTableSection>(SymTabName, SHT_SYMTAB, 0,
                                                 SymTabAlign, SymTabEntSize);
-  SymTab->createNullSymbol(NullSection);
+  SymTab->createNullSymbol(NullSection, &Ctx);
 
-  const IceString StrTabName(".strtab");
+  constexpr char StrTabName[] = ".strtab";
   StrTab =
       createSection<ELFStringTableSection>(StrTabName, SHT_STRTAB, 0, 1, 0);
 }
 
 template <typename T>
-T *ELFObjectWriter::createSection(const IceString &Name, Elf64_Word ShType,
+T *ELFObjectWriter::createSection(const std::string &Name, Elf64_Word ShType,
                                   Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
                                   Elf64_Xword ShEntsize) {
   assert(!SectionNumbersAssigned);
   T *NewSection =
       new (Ctx.allocate<T>()) T(Name, ShType, ShFlags, ShAddralign, ShEntsize);
   ShStrTab->add(Name);
   return NewSection;
 }
 
 ELFRelocationSection *
 ELFObjectWriter::createRelocationSection(const ELFSection *RelatedSection) {
   // Choice of RELA vs REL is actually separate from elf64 vs elf32, but in
   // practice we've only had .rela for elf64 (x86-64). In the future, the two
   // properties may need to be decoupled and the ShEntSize can vary more.
   const Elf64_Word ShType = ELF64 ? SHT_RELA : SHT_REL;
-  const IceString RelPrefix = ELF64 ? ".rela" : ".rel";
-  const IceString RelSectionName = RelPrefix + RelatedSection->getName();
+  const std::string RelPrefix = ELF64 ? ".rela" : ".rel";
+  const std::string RelSectionName = RelPrefix + RelatedSection->getName();
   const Elf64_Xword ShAlign = ELF64 ? 8 : 4;
   const Elf64_Xword ShEntSize = ELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
   static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
                 "Elf_Rel/Rela sizes cannot be derived from sizeof");
   constexpr Elf64_Xword ShFlags = 0;
   ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
       RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
   RelSection->setRelatedSection(RelatedSection);
   return RelSection;
 }
@@ skipping 77 matching lines @@
 Elf64_Off ELFObjectWriter::alignFileOffset(Elf64_Xword Align) {
   Elf64_Off OffsetInFile = Str.tell();
   Elf64_Xword AlignDiff = Utils::OffsetToAlignment(OffsetInFile, Align);
   if (AlignDiff == 0)
     return OffsetInFile;
   Str.writeZeroPadding(AlignDiff);
   OffsetInFile += AlignDiff;
   return OffsetInFile;
 }
 
-void ELFObjectWriter::writeFunctionCode(const IceString &FuncName,
-                                        bool IsInternal, Assembler *Asm) {
+void ELFObjectWriter::writeFunctionCode(GlobalString FuncName, bool IsInternal,
+                                        Assembler *Asm) {
   assert(!SectionNumbersAssigned);
-  TimerMarker T_func(&Ctx, FuncName);
+  TimerMarker T_func(&Ctx, FuncName.toStringOrEmpty());
   TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   ELFTextSection *Section = nullptr;
   ELFRelocationSection *RelSection = nullptr;
   const bool FunctionSections = Ctx.getFlags().getFunctionSections();
   if (TextSections.empty() || FunctionSections) {
-    IceString SectionName = ".text";
+    std::string SectionName = ".text";
     if (FunctionSections)
       SectionName += "." + FuncName;
     constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
     const Elf64_Xword ShAlign = 1 << Asm->getBundleAlignLog2Bytes();
     Section = createSection<ELFTextSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAlign, 0);
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
     RelSection = createRelocationSection(Section);
@@ skipping 43 matching lines @@
     return ELFObjectWriter::ROData;
   if (Var->hasNonzeroInitializer())
     return ELFObjectWriter::Data;
   return ELFObjectWriter::BSS;
 }
 
 // Partition the Vars list by SectionType into VarsBySection. If TranslateOnly
 // is non-empty, then only the TranslateOnly variable is kept for emission.
 void partitionGlobalsBySection(const VariableDeclarationList &Vars,
                                VariableDeclarationPartition VarsBySection[],
-                               const IceString &TranslateOnly) {
+                               const std::string &TranslateOnly) {
   for (VariableDeclaration *Var : Vars) {
     if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
       size_t Section = classifyGlobalSection(Var);
       assert(Section < ELFObjectWriter::NumSectionTypes);
       VarsBySection[Section].push_back(Var);
     }
   }
 }
 
 } // end of anonymous namespace
 
 void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
                                        FixupKind RelocationKind,
-                                       const IceString &SectionSuffix,
+                                       const std::string &SectionSuffix,
                                        bool IsPIC) {
   TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   assert(!SectionNumbersAssigned);
   VariableDeclarationPartition VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
   partitionGlobalsBySection(Vars, VarsBySection,
                             Ctx.getFlags().getTranslateOnly());
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
     writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
                     SectionSuffix, IsPIC);
   }
 }
 
 namespace {
-IceString MangleSectionName(const char Base[], const IceString &Suffix) {
+std::string MangleSectionName(const char Base[], const std::string &Suffix) {
   if (Suffix.empty())
     return Base;
   return Base + ("." + Suffix);
 }
 } // end of anonymous namespace
 
 // TODO(jvoung): Handle fdata-sections.
 void ELFObjectWriter::writeDataOfType(SectionType ST,
                                       const VariableDeclarationPartition &Vars,
                                       FixupKind RelocationKind,
-                                      const IceString &SectionSuffix,
+                                      const std::string &SectionSuffix,
                                       bool IsPIC) {
   if (Vars.empty())
     return;
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
   Elf64_Xword ShAddralign = 1;
   for (VariableDeclaration *Var : Vars) {
     Elf64_Xword Align = Var->getAlignment();
     ShAddralign = std::max(ShAddralign, Align);
   }
   constexpr Elf64_Xword ShEntsize = 0; // non-uniform data element size.
   // Lift this out, so it can be re-used if we do fdata-sections?
   switch (ST) {
   case ROData: {
-    const IceString SectionName =
+    const std::string SectionName =
         MangleSectionName(IsPIC ? ".data.rel.ro" : ".rodata", SectionSuffix);
     const Elf64_Xword ShFlags = IsPIC ? (SHF_ALLOC | SHF_WRITE) : SHF_ALLOC;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     RODataSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelRODataSections.push_back(RelSection);
     break;
   }
   case Data: {
-    const IceString SectionName = MangleSectionName(".data", SectionSuffix);
+    const std::string SectionName = MangleSectionName(".data", SectionSuffix);
     constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     DataSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelDataSections.push_back(RelSection);
     break;
   }
   case BSS: {
-    const IceString SectionName = MangleSectionName(".bss", SectionSuffix);
+    const std::string SectionName = MangleSectionName(".bss", SectionSuffix);
     constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
     Section = createSection<ELFDataSection>(SectionName, SHT_NOBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     BSSSections.push_back(Section);
     break;
   }
   case NumSectionTypes:
     llvm::report_fatal_error("Unknown SectionType");
     break;
   }
 
   constexpr uint8_t SymbolType = STT_OBJECT;
   for (VariableDeclaration *Var : Vars) {
     // If the variable declaration does not have an initializer, its symtab
     // entry will be created separately.
     if (!Var->hasInitializer())
       continue;
     Elf64_Xword Align = Var->getAlignment();
     constexpr Elf64_Xword MinAlign = 1;
     Align = std::max(Align, MinAlign);
     Section->padToAlignment(Str, Align);
     SizeT SymbolSize = Var->getNumBytes();
     bool IsExternal = Var->isExternal() || Ctx.getFlags().getDisableInternal();
     const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
-    const IceString &Name = Var->getName();
+    GlobalString Name = Var->getName();
     SymTab->createDefinedSym(Name, SymbolType, SymbolBinding, Section,
                              Section->getCurrentSize(), SymbolSize);
     StrTab->add(Name);
     if (!Var->hasNonzeroInitializer()) {
       assert(ST == BSS || ST == ROData);
       if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
         Section->setSize(Section->getCurrentSize() + SymbolSize);
     } else {
@@ skipping 130 matching lines @@
     RandomNumberGenerator RNG(Ctx.getFlags().getRandomSeed(),
                               RPE_PooledConstantReordering, K);
     RandomShuffle(Pool.begin(), Pool.end(),
                   [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
   // Write the data.
   for (Constant *C : Pool) {
     if (!C->getShouldBePooled())
       continue;
     auto *Const = llvm::cast<ConstType>(C);
-    std::string SymBuffer;
-    llvm::raw_string_ostream SymStrBuf(SymBuffer);
-    Const->emitPoolLabel(SymStrBuf);
-    std::string &SymName = SymStrBuf.str();
+    GlobalString SymName = Const->getLabelName();
     SymTab->createDefinedSym(SymName, STT_NOTYPE, STB_LOCAL, Section,
                              OffsetInSection, SymbolSize);
     StrTab->add(SymName);
     typename ConstType::PrimType Value = Const->getValue();
     memcpy(Buf, &Value, WriteAmt);
     Str.writeBytes(llvm::StringRef(Buf, WriteAmt));
     OffsetInSection += WriteAmt;
   }
   Section->setSize(OffsetInSection);
 }
@@ skipping 16 matching lines @@
 }
 
 void ELFObjectWriter::writeJumpTable(const JumpTableData &JT,
                                      FixupKind RelocationKind, bool IsPIC) {
   TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
   const Elf64_Xword PointerSize = typeWidthInBytes(getPointerType());
   const Elf64_Xword ShAddralign = PointerSize;
   const Elf64_Xword ShEntsize = PointerSize;
-  const IceString SectionName = MangleSectionName(
-      IsPIC ? ".data.rel.ro" : ".rodata", JT.getFunctionName() + "$jumptable");
+  const GlobalString JTName = JT.getFunctionName();
+  const std::string SectionName = MangleSectionName(
+      IsPIC ? ".data.rel.ro" : ".rodata",
+      (JTName.hasStdString() ? JTName.toString()
+                             : std::to_string(JTName.getID())) +
+          "$jumptable");
   Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, SHF_ALLOC,
                                           ShAddralign, ShEntsize);
   Section->setFileOffset(alignFileOffset(ShAddralign));
   RODataSections.push_back(Section);
   RelSection = createRelocationSection(Section);
   RelRODataSections.push_back(RelSection);
 
   constexpr uint8_t SymbolType = STT_OBJECT;
   Section->padToAlignment(Str, PointerSize);
   const bool IsExternal = Ctx.getFlags().getDisableInternal();
   const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
-  const IceString JumpTableName =
-      InstJumpTable::makeName(JT.getFunctionName(), JT.getId());
+  GlobalString JumpTableName = Ctx.getGlobalString(
+      InstJumpTable::makeName(JT.getFunctionName(), JT.getId()));
   SymTab->createDefinedSym(JumpTableName, SymbolType, SymbolBinding, Section,
                            Section->getCurrentSize(), PointerSize);
   StrTab->add(JumpTableName);
 
   for (intptr_t TargetOffset : JT.getTargetOffsets()) {
     AssemblerFixup NewFixup;
     NewFixup.set_position(Section->getCurrentSize());
     NewFixup.set_kind(RelocationKind);
     NewFixup.set_value(Ctx.getConstantSym(TargetOffset, JT.getFunctionName()));
     RelSection->addRelocation(NewFixup);
     Section->appendRelocationOffset(Str, RelSection->isRela(), TargetOffset);
   }
 }
 
 void ELFObjectWriter::setUndefinedSyms(const ConstantList &UndefSyms) {
   TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   for (const Constant *S : UndefSyms) {
     const auto *Sym = llvm::cast<ConstantRelocatable>(S);
-    const IceString &Name = Sym->getName();
+    GlobalString Name = Sym->getName();
+    assert(Name.hasStdString());
     bool BadIntrinsic;
     const Intrinsics::FullIntrinsicInfo *Info =
         Ctx.getIntrinsicsInfo().find(Name, BadIntrinsic);
     if (Info)
       continue;
     // Ignore BadIntrinsic, which is set if the name begins with "llvm." but
     // doesn't match a known intrinsic.  If we want this to turn into an error,
     // we should catch it early on.
     assert(Sym->getOffset() == 0);
     SymTab->noteUndefinedSym(Name, NullSection);
@@ skipping 59 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice