Subzero: Remove IceString.

src/IceELFSection.cpp

 //===- subzero/src/IceELFSection.cpp - Representation of ELF sections -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 76 matching lines @@
     }
   }
 }
 
 size_t ELFRelocationSection::getSectionDataSize() const {
   return Fixups.size() * Header.sh_entsize;
 }
 
 // Symbol tables.
 
-void ELFSymbolTableSection::createNullSymbol(ELFSection *NullSection) {
+void ELFSymbolTableSection::createNullSymbol(ELFSection *NullSection,
+                                             GlobalContext *Ctx) {
   // The first entry in the symbol table should be a NULL entry, so make sure
   // the map is still empty.
   assert(LocalSymbols.empty());
-  const IceString NullSymName("");
-  createDefinedSym(NullSymName, STT_NOTYPE, STB_LOCAL, NullSection, 0, 0);
-  NullSymbol = findSymbol(NullSymName);
+  // Explicitly set the null symbol name to the empty string, so that
+  // GlobalString::operator<() orders the null string first.
+  NullSymbolName = GlobalString::createWithString(Ctx, "");
+  createDefinedSym(NullSymbolName, STT_NOTYPE, STB_LOCAL, NullSection, 0, 0);
+  NullSymbol = findSymbol(NullSymbolName);
 }
 
-void ELFSymbolTableSection::createDefinedSym(const IceString &Name,
-                                             uint8_t Type, uint8_t Binding,
+void ELFSymbolTableSection::createDefinedSym(GlobalString Name, uint8_t Type,
+                                             uint8_t Binding,
                                              ELFSection *Section,
                                              RelocOffsetT Offset, SizeT Size) {
   ELFSym NewSymbol = ELFSym();
   NewSymbol.Sym.setBindingAndType(Binding, Type);
   NewSymbol.Sym.st_value = Offset;
   NewSymbol.Sym.st_size = Size;
   NewSymbol.Section = Section;
   NewSymbol.Number = ELFSym::UnknownNumber;
   bool Unique;
   if (Binding == STB_LOCAL)
     Unique = LocalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
   else
     Unique = GlobalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
   assert(Unique);
   (void)Unique;
 }
 
-void ELFSymbolTableSection::noteUndefinedSym(const IceString &Name,
+void ELFSymbolTableSection::noteUndefinedSym(GlobalString Name,
                                              ELFSection *NullSection) {
   ELFSym NewSymbol = ELFSym();
   NewSymbol.Sym.setBindingAndType(STB_GLOBAL, STT_NOTYPE);
   NewSymbol.Section = NullSection;
   NewSymbol.Number = ELFSym::UnknownNumber;
   bool Unique = GlobalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
   if (!Unique) {
     std::string Buffer;
     llvm::raw_string_ostream StrBuf(Buffer);
     StrBuf << "Symbol external and defined: " << Name;
     llvm::report_fatal_error(StrBuf.str());
   }
   (void)Unique;
 }
 
-const ELFSym *ELFSymbolTableSection::findSymbol(const IceString &Name) const {
+const ELFSym *ELFSymbolTableSection::findSymbol(GlobalString Name) const {
   auto I = LocalSymbols.find(Name);
   if (I != LocalSymbols.end())
     return &I->second;
   I = GlobalSymbols.find(Name);
   if (I != GlobalSymbols.end())
     return &I->second;
   return nullptr;
 }
 
 void ELFSymbolTableSection::updateIndices(const ELFStringTableSection *StrTab) {
   SizeT SymNumber = 0;
   for (auto &KeyValue : LocalSymbols) {
-    const IceString &Name = KeyValue.first;
+    GlobalString Name = KeyValue.first;
     ELFSection *Section = KeyValue.second.Section;
     Elf64_Sym &SymInfo = KeyValue.second.Sym;
-    if (!Name.empty())
-      SymInfo.st_name = StrTab->getIndex(Name);
+    if (Name != NullSymbolName && Name.hasStdString())
+      SymInfo.st_name = StrTab->getIndex(Name.toString());
     SymInfo.st_shndx = Section->getNumber();
     KeyValue.second.setNumber(SymNumber++);
   }
   for (auto &KeyValue : GlobalSymbols) {
-    const IceString &Name = KeyValue.first;
+    const std::string &Name = KeyValue.first.toString();
     ELFSection *Section = KeyValue.second.Section;
     Elf64_Sym &SymInfo = KeyValue.second.Sym;
     if (!Name.empty())
       SymInfo.st_name = StrTab->getIndex(Name);
     SymInfo.st_shndx = Section->getNumber();
     KeyValue.second.setNumber(SymNumber++);
   }
 }
 
 void ELFSymbolTableSection::writeData(ELFStreamer &Str, bool IsELF64) {
   if (IsELF64) {
     writeSymbolMap<true>(Str, LocalSymbols);
     writeSymbolMap<true>(Str, GlobalSymbols);
   } else {
     writeSymbolMap<false>(Str, LocalSymbols);
     writeSymbolMap<false>(Str, GlobalSymbols);
   }
 }
 
 // String tables.
 
-void ELFStringTableSection::add(const IceString &Str) {
+void ELFStringTableSection::add(const std::string &Str) {
   assert(!isLaidOut());
   assert(!Str.empty());
   StringToIndexMap.insert(std::make_pair(Str, UnknownIndex));
 }
 
-size_t ELFStringTableSection::getIndex(const IceString &Str) const {
+size_t ELFStringTableSection::getIndex(const std::string &Str) const {
   assert(isLaidOut());
   StringToIndexType::const_iterator It = StringToIndexMap.find(Str);
   if (It == StringToIndexMap.end()) {
-    llvm_unreachable("String index not found");
+    llvm::report_fatal_error("String index not found: " + Str);
     return UnknownIndex;
   }
   return It->second;
 }
 
 bool ELFStringTableSection::SuffixComparator::
-operator()(const IceString &StrA, const IceString &StrB) const {
+operator()(const std::string &StrA, const std::string &StrB) const {
   size_t LenA = StrA.size();
   size_t LenB = StrB.size();
   size_t CommonLen = std::min(LenA, LenB);
   // If there is a difference in the common suffix, use that diff to sort.
   for (size_t i = 0; i < CommonLen; ++i) {
     char a = StrA[LenA - i - 1];
     char b = StrB[LenB - i - 1];
     if (a != b)
       return a > b;
   }
@@ skipping 19 matching lines @@
       continue;
     }
     StringIndex.second = StringData.size();
     std::copy(Cur.begin(), Cur.end(), back_inserter(StringData));
     StringData.push_back(0);
     Prev = Cur;
   }
 }
 
 } // end of namespace Ice