Subzero: Remove IceString.

src/IceELFObjectWriter.h

 //===- subzero/src/IceELFObjectWriter.h - ELF object writer -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 46 matching lines @@
   /// Write the initial ELF header. This is just to reserve space in the ELF
   /// file. Reserving space allows the other functions to write text and data
   /// directly to the file and get the right file offsets.
   void writeInitialELFHeader();
 
   /// Copy initializer data for globals to file and note the offset and size of
   /// each global's definition in the symbol table. Use the given target's
   /// RelocationKind for any relocations.
   void writeDataSection(const VariableDeclarationList &Vars,
                         FixupKind RelocationKind,
-                        const IceString &SectionSuffix, bool IsPIC);
+                        const std::string &SectionSuffix, bool IsPIC);
 
   /// Copy data of a function's text section to file and note the offset of the
   /// symbol's definition in the symbol table. Copy the text fixups for use
   /// after all functions are written. The text buffer and fixups are extracted
   /// from the Assembler object.
-  void writeFunctionCode(const IceString &FuncName, bool IsInternal,
+  void writeFunctionCode(GlobalString FuncName, bool IsInternal,
                          Assembler *Asm);
 
   /// Queries the GlobalContext for constant pools of the given type and writes
   /// out read-only data sections for those constants. This also fills the
   /// symbol table with labels for each constant pool entry.
   template <typename ConstType> void writeConstantPool(Type Ty);
 
   /// Write a jump table and register fixups for the target addresses.
   void writeJumpTable(const JumpTableData &JT, FixupKind RelocationKind,
                       bool IsPIC);
@@ skipping 28 matching lines @@
   RelSectionList RelRODataSections;
   DataSectionList BSSSections;
 
   // Handles to special sections that need incremental bookkeeping.
   ELFSection *NullSection;
   ELFStringTableSection *ShStrTab;
   ELFSymbolTableSection *SymTab;
   ELFStringTableSection *StrTab;
 
   template <typename T>
-  T *createSection(const IceString &Name, Elf64_Word ShType,
+  T *createSection(const std::string &Name, Elf64_Word ShType,
                    Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
                    Elf64_Xword ShEntsize);
 
   /// Create a relocation section, given the related section (e.g., .text,
   /// .data., .rodata).
   ELFRelocationSection *
   createRelocationSection(const ELFSection *RelatedSection);
 
   /// Align the file position before writing out a section's data, and return
   /// the position of the file.
@@ skipping 16 matching lines @@
                                   SectionList &AllSections);
 
   /// Link the relocation sections to the symbol table.
   void assignRelLinkNum(SizeT SymTabNumber, RelSectionList &RelSections);
 
   /// Helper function for writeDataSection. Writes a data section of type
   /// SectionType, given the global variables Vars belonging to that
   /// SectionType.
   void writeDataOfType(SectionType SectionType,
                        const VariableDeclarationPartition &Vars,
-                       FixupKind RelocationKind, const IceString &SectionSuffix,
-                       bool IsPIC);
+                       FixupKind RelocationKind,
+                       const std::string &SectionSuffix, bool IsPIC);
 
   /// Write the final relocation sections given the final symbol table. May also
   /// be able to seek around the file and resolve function calls that are for
   /// functions within the same section.
   void writeAllRelocationSections();
   void writeRelocationSections(RelSectionList &RelSections);
 
   /// Write the ELF file header with the given information about sections.
   template <bool IsELF64>
   void writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
                               SizeT SectHeaderStrIndex, SizeT NumSections);
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFOBJECTWRITER_H