Subzero: Remove IceString.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 455 matching lines @@
       if (Ty->getKind() == WantedKind)
         return Ty;
     }
     // Generate an error message and set ErrorStatus.
     this->reportBadTypeIDAs(ID, Ty, WantedKind);
     return nullptr;
   }
 
   // Gives Decl a name if it doesn't already have one. Prefix and NameIndex are
   // used to generate the name. NameIndex is automatically incremented if a new
-  // name is created. DeclType is literal text describing the type of name
-  // being created. Also generates warning if created names may conflict with
-  // named declarations.
+  // name is created. DeclType is literal text describing the type of name being
+  // created. Also generates a warning if created names may conflict with named
+  // declarations.
   void installDeclarationName(Ice::GlobalDeclaration *Decl,
-                              const Ice::IceString &Prefix,
-                              const char *DeclType,
+                              const std::string &Prefix, const char *DeclType,
                               NaClBcIndexSize_t &NameIndex) {
     if (Decl->hasName()) {
-      Translator.checkIfUnnamedNameSafe(Decl->getName(), DeclType, Prefix);
+      Translator.checkIfUnnamedNameSafe(Decl->getName().toString(), DeclType,
+                                        Prefix);
     } else {
-      Decl->setName(Translator.createUnnamedName(Prefix, NameIndex));
+      Ice::GlobalContext *Ctx = Translator.getContext();
+      if (Ice::BuildDefs::dump() || !Decl->isInternal()) {
+        Decl->setName(Ctx, Translator.createUnnamedName(Prefix, NameIndex));
+      } else {
+        Decl->setName(Ctx);
+      }
       ++NameIndex;
     }
   }
 
   // Installs names for global variables without names.
   void installGlobalVarNames() {
     assert(VariableDeclarations);
-    const Ice::IceString &GlobalPrefix =
+    const std::string &GlobalPrefix =
         getTranslator().getFlags().getDefaultGlobalPrefix();
     if (!GlobalPrefix.empty()) {
       NaClBcIndexSize_t NameIndex = 0;
       for (Ice::VariableDeclaration *Var : *VariableDeclarations) {
         installDeclarationName(Var, GlobalPrefix, "global", NameIndex);
       }
     }
   }
 
   // Installs names for functions without names.
   void installFunctionNames() {
-    const Ice::IceString &FunctionPrefix =
+    const std::string &FunctionPrefix =
         getTranslator().getFlags().getDefaultFunctionPrefix();
     if (!FunctionPrefix.empty()) {
       NaClBcIndexSize_t NameIndex = 0;
       for (Ice::FunctionDeclaration *Func : FunctionDeclarations) {
         installDeclarationName(Func, FunctionPrefix, "function", NameIndex);
       }
     }
   }
 
   // Builds a constant symbol named Name.  IsExternal is true iff the symbol is
   // external.
-  Ice::Constant *getConstantSym(const Ice::IceString &Name,
-                                bool IsExternal) const {
+  Ice::Constant *getConstantSym(Ice::GlobalString Name, bool IsExternal) const {
+    Ice::GlobalContext *Ctx = getTranslator().getContext();
     if (IsExternal) {
-      return getTranslator().getContext()->getConstantExternSym(Name);
+      return Ctx->getConstantExternSym(Name);
     } else {
       const Ice::RelocOffsetT Offset = 0;
-      return getTranslator().getContext()->getConstantSym(Offset, Name);
+      return Ctx->getConstantSym(Offset, Name);
     }
   }
 
   void reportLinkageError(const char *Kind,
                           const Ice::GlobalDeclaration &Decl) {
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << Kind << " " << Decl.getName()
            << " has incorrect linkage: " << Decl.getLinkageName();
     if (Decl.isExternal())
@@ skipping 811 matching lines @@
       : BlockParserBaseClass(BlockID, EnclosingParser),
         Timer(Ice::TimerStack::TT_parseFunctions, getTranslator().getContext()),
         Func(nullptr), FcnId(Context->getNextFunctionBlockValueID()),
         FuncDecl(Context->getFunctionByID(FcnId)),
         CachedNumGlobalValueIDs(Context->getNumGlobalIDs()),
         NextLocalInstIndex(Context->getNumGlobalIDs()) {}
 
   bool convertFunction() {
     bool ParserResult;
     {
-      Ice::TimerMarker T(getTranslator().getContext(), FuncDecl->getName());
+      Ice::TimerMarker T(getTranslator().getContext(),
+                         FuncDecl->getName().toStringOrEmpty());
       // Note: The Cfg is created, even when IR generation is disabled. This is
       // done to install a CfgLocalAllocator for various internal containers.
-      Func = Ice::Cfg::create(getTranslator().getContext(),
-                              getTranslator().getNextSequenceNumber());
+      Ice::GlobalContext *Ctx = getTranslator().getContext();
+      Func = Ice::Cfg::create(Ctx, getTranslator().getNextSequenceNumber());
 
       Ice::CfgLocalAllocatorScope _(Func.get());
 
       // TODO(kschimpf) Clean up API to add a function signature to a CFG.
       const Ice::FuncSigType &Signature = FuncDecl->getSignature();
 
       Func->setFunctionName(FuncDecl->getName());
       Func->setReturnType(Signature.getReturnType());
       Func->setInternal(FuncDecl->getLinkage() == GlobalValue::InternalLinkage);
       CurrentNode = installNextBasicBlock();
@@ skipping 724 matching lines @@
                                 Ice::Type ArgType, Ice::Type ParamType) {
     if (ArgType != ParamType) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Argument " << (Index + 1) << " of " << printName(Fcn)
              << " expects " << ParamType << ". Found: " << ArgType;
       Error(StrBuf.str());
     }
   }
 
-  const Ice::IceString printName(Ice::FunctionDeclaration *Fcn) {
+  const std::string printName(Ice::FunctionDeclaration *Fcn) {
     if (Fcn)
-      return Fcn->getName();
+      return Fcn->getName().toString();
     return "function";
   }
 };
 
 void FunctionParser::ExitBlock() {
   // Check if the last instruction in the function was terminating.
   if (!InstIsTerminating) {
     Error("Last instruction in function not terminator");
     // Recover by inserting an unreachable instruction.
     CurrentNode->appendInst(Ice::InstUnreachable::create(Func.get()));
@@ skipping 927 matching lines @@
   Ice::GlobalDeclaration *Decl = Context->getGlobalDeclarationByID(Index);
   if (llvm::isa<Ice::VariableDeclaration>(Decl) &&
       Decl->isPNaClABIExternalName(Name.str())) {
     // Force linkage of (specific) Global Variables be external for the PNaCl
     // ABI. PNaCl bitcode has a linkage field for Functions, but not for
     // GlobalVariables (because the latter is not needed for pexes, so it has
     // been removed).
     Decl->setLinkage(llvm::GlobalValue::ExternalLinkage);
   }
 
-  Decl->setName(StringRef(Name.data(), Name.size()));
+  // Unconditionally capture the name if it is provided in the input file,
+  // regardless of whether dump is enabled or whether the symbol is internal vs
+  // external.  This fits in well with the lit tests, and most symbols in a
+  // conforming pexe are nameless and don't take this path.
+  Decl->setName(getTranslator().getContext(),
+                StringRef(Name.data(), Name.size()));
 }
 
 void ModuleValuesymtabParser::setBbName(NaClBcIndexSize_t Index,
                                         StringType &Name) {
   reportUnableToAssign("Basic block", Index, Name);
 }
 
 bool ModuleParser::ParseBlock(unsigned BlockID) {
   switch (BlockID) {
   case naclbitc::BLOCKINFO_BLOCK_ID:
@@ skipping 144 matching lines @@
     raw_string_ostream StrBuf(Buffer);
     StrBuf << IRFilename << ": Does not contain a module!";
     llvm::report_fatal_error(StrBuf.str());
   }
   if (InputStreamFile.getBitcodeBytes().getExtent() % 4 != 0) {
     llvm::report_fatal_error("Bitcode stream should be a multiple of 4 bytes");
   }
 }
 
 } // end of namespace Ice