Subzero: Remove IceString.

src/IceCompileServer.cpp

 //===- subzero/src/IceCompileServer.cpp - Compile server ------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 32 matching lines @@
 namespace Ice {
 
 namespace {
 
 // Define a SmallVector backed buffer as a data stream, so that it can hold the
 // generated binary version of the textual bitcode in the input file.
 class TextDataStreamer : public llvm::DataStreamer {
 public:
   TextDataStreamer() = default;
   ~TextDataStreamer() final = default;
-  static TextDataStreamer *create(const IceString &Filename, std::string *Err);
+  static TextDataStreamer *create(const std::string &Filename,
+                                  std::string *Err);
   size_t GetBytes(unsigned char *Buf, size_t Len) final;
 
 private:
   llvm::SmallVector<char, 1024> BitcodeBuffer;
   size_t Cursor = 0;
 };
 
-TextDataStreamer *TextDataStreamer::create(const IceString &Filename,
+TextDataStreamer *TextDataStreamer::create(const std::string &Filename,
                                            std::string *Err) {
   TextDataStreamer *Streamer = new TextDataStreamer();
   llvm::raw_string_ostream ErrStrm(*Err);
   if (std::error_code EC = llvm::readNaClRecordTextAndBuildBitcode(
           Filename, Streamer->BitcodeBuffer, &ErrStrm)) {
     ErrStrm << EC.message();
     ErrStrm.flush();
     delete Streamer;
     return nullptr;
   }
   ErrStrm.flush();
   return Streamer;
 }
 
 size_t TextDataStreamer::GetBytes(unsigned char *Buf, size_t Len) {
   if (Cursor >= BitcodeBuffer.size())
     return 0;
   size_t Remaining = BitcodeBuffer.size();
   Len = std::min(Len, Remaining);
   for (size_t i = 0; i < Len; ++i)
     Buf[i] = BitcodeBuffer[Cursor + i];
   Cursor += Len;
   return Len;
 }
 
-std::unique_ptr<Ostream> makeStream(const IceString &Filename,
+std::unique_ptr<Ostream> makeStream(const std::string &Filename,
                                     std::error_code &EC) {
   if (Filename == "-") {
     return std::unique_ptr<Ostream>(new llvm::raw_os_ostream(std::cout));
   } else {
     return std::unique_ptr<Ostream>(
         new llvm::raw_fd_ostream(Filename, EC, llvm::sys::fs::F_None));
   }
 }
 
 ErrorCodes getReturnValue(ErrorCodes Val) {
@@ skipping 105 matching lines @@
       return transferErrorCode(getReturnValue(Ice::EC_Args));
     }
     Os->SetUnbuffered();
   } break;
   }
 
   if (BuildDefs::minimal() && Flags.getBitcodeAsText())
     llvm::report_fatal_error("Can't specify 'bitcode-as-text' flag in "
                              "minimal build");
 
-  IceString StrError;
+  std::string StrError;
   std::unique_ptr<llvm::DataStreamer> InputStream(
       (!BuildDefs::minimal() && Flags.getBitcodeAsText())
           ? TextDataStreamer::create(Flags.getIRFilename(), &StrError)
           : llvm::getDataFileStreamer(Flags.getIRFilename(), &StrError));
   if (!StrError.empty() || !InputStream) {
     llvm::SMDiagnostic Err(Flags.getIRFilename(), llvm::SourceMgr::DK_Error,
                            StrError);
     Err.print(Flags.getAppName().c_str(), *Ls);
     return transferErrorCode(getReturnValue(Ice::EC_Bitcode));
   }
 
   if (Flags.getGenerateBuildAtts()) {
     dumpBuildAttributes(*Os.get());
     return transferErrorCode(getReturnValue(Ice::EC_None));
   }
 
   Ctx.reset(new GlobalContext(Ls.get(), Os.get(), Ls.get(), ELFStr.get()));
   if (Ctx->getFlags().getNumTranslationThreads() != 0) {
     std::thread CompileThread([this, &Flags, &InputStream]() {
       Ctx->initParserThread();
       getCompiler().run(Flags, *Ctx.get(), std::move(InputStream));
     });
     CompileThread.join();
   } else {
     getCompiler().run(Flags, *Ctx.get(), std::move(InputStream));
   }
   transferErrorCode(
       getReturnValue(static_cast<ErrorCodes>(Ctx->getErrorStatus()->value())));
   Ctx->dumpConstantLookupCounts();
+  Ctx->dumpStrings();
 }
 
 } // end of namespace Ice