Subzero: Remove IceString.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global declarations -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 43 matching lines @@
   GlobalDeclaration(const GlobalDeclaration &) = delete;
   GlobalDeclaration &operator=(const GlobalDeclaration &) = delete;
 
 public:
   /// Discriminator for LLVM-style RTTI.
   enum GlobalDeclarationKind {
     FunctionDeclarationKind,
     VariableDeclarationKind
   };
   GlobalDeclarationKind getKind() const { return Kind; }
-  const IceString &getName() const { return Name; }
-  void setName(const IceString &NewName) {
-    Name = getSuppressMangling() ? NewName : mangleName(NewName);
+  GlobalString getName() const { return Name; }
+  void setName(GlobalContext *Ctx, const std::string &NewName) {
+    Name = Ctx->getGlobalString(getSuppressMangling() ? NewName
+                                                      : mangleName(NewName));
   }
-  bool hasName() const { return !Name.empty(); }
+  void setName(GlobalString NewName) { Name = NewName; }
+  void setName(GlobalContext *Ctx) { Name = GlobalString(Ctx); }
+  bool hasName() const { return Name.hasString(); }
   bool isInternal() const {
     return Linkage == llvm::GlobalValue::InternalLinkage;
   }
   llvm::GlobalValue::LinkageTypes getLinkage() const { return Linkage; }
   void setLinkage(llvm::GlobalValue::LinkageTypes L) {
     assert(!hasName());
     Linkage = L;
   }
   bool isExternal() const {
     return Linkage == llvm::GlobalValue::ExternalLinkage;
   }
   virtual ~GlobalDeclaration() = default;
 
   /// Prints out type of the global declaration.
   virtual void dumpType(Ostream &Stream) const = 0;
 
   /// Prints out the global declaration.
   virtual void dump(Ostream &Stream) const = 0;
 
   /// Returns true if when emitting names, we should suppress mangling.
   virtual bool getSuppressMangling() const = 0;
 
   /// Returns textual name of linkage.
   const char *getLinkageName() const {
     return isInternal() ? "internal" : "external";
   }
 
   /// Returns true if the name of this GlobalDeclaration indicates that it
   /// should have ExternalLinkage (as a special case).
-  virtual bool isPNaClABIExternalName(const IceString &Name) const = 0;
+  virtual bool isPNaClABIExternalName(const std::string &Name) const = 0;
 
 protected:
   GlobalDeclaration(GlobalDeclarationKind Kind,
                     llvm::GlobalValue::LinkageTypes Linkage)
       : Kind(Kind), Linkage(Linkage) {}
 
   /// Returns true if linkage is defined correctly for the global declaration,
   /// based on default rules.
   bool verifyLinkageDefault(const GlobalContext *Ctx) const {
     switch (Linkage) {
     default:
       return false;
     case llvm::GlobalValue::InternalLinkage:
       return true;
     case llvm::GlobalValue::ExternalLinkage:
       return Ctx->getFlags().getAllowExternDefinedSymbols();
     }
   }
 
   const GlobalDeclarationKind Kind;
   llvm::GlobalValue::LinkageTypes Linkage;
-  IceString Name;
+  GlobalString Name;
 };
 
 /// Models a function declaration. This includes the type signature of the
 /// function, its calling conventions, and its linkage.
 class FunctionDeclaration : public GlobalDeclaration {
   FunctionDeclaration() = delete;
   FunctionDeclaration(const FunctionDeclaration &) = delete;
   FunctionDeclaration &operator=(const FunctionDeclaration &) = delete;
 
 public:
@@ skipping 11 matching lines @@
   bool isProto() const { return IsProto; }
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == FunctionDeclarationKind;
   }
   void dumpType(Ostream &Stream) const final;
   void dump(Ostream &Stream) const final;
   bool getSuppressMangling() const final { return isExternal() && IsProto; }
 
   /// Returns true if linkage is correct for the function declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
-    if (isPNaClABIExternalName(getName()) || isIntrinsicName(Ctx)) {
-      return Linkage == llvm::GlobalValue::ExternalLinkage;
-    } else {
-      return verifyLinkageDefault(Ctx);
+    if (getName().hasString()) {
+      if (isPNaClABIExternalName(getName().toString()) ||
+          isIntrinsicName(Ctx)) {
+        return Linkage == llvm::GlobalValue::ExternalLinkage;
+      }
     }
+    return verifyLinkageDefault(Ctx);
   }
 
   /// Validates that the type signature of the function is correct. Returns true
   /// if valid.
   bool validateTypeSignature(const GlobalContext *Ctx) const {
     bool IsIntrinsic;
     if (const Intrinsics::FullIntrinsicInfo *Info =
             getIntrinsicInfo(Ctx, &IsIntrinsic))
       return validateIntrinsicTypeSignature(Info);
     return !IsIntrinsic && validateRegularTypeSignature();
   }
 
   /// Generates an error message describing why validateTypeSignature returns
   /// false.
-  IceString getTypeSignatureError(const GlobalContext *Ctx);
+  std::string getTypeSignatureError(const GlobalContext *Ctx);
 
   /// Returns corresponding PNaCl intrisic information.
   const Intrinsics::FullIntrinsicInfo *
   getIntrinsicInfo(const GlobalContext *Ctx) const {
     bool BadIntrinsic;
     return getIntrinsicInfo(Ctx, &BadIntrinsic);
   }
 
   /// Same as above, except IsIntrinsic is true if the function is intrinsic
   /// (even if not a PNaCl intrinsic).
   const Intrinsics::FullIntrinsicInfo *
   getIntrinsicInfo(const GlobalContext *Ctx, bool *IsIntrinsic) const;
 
 private:
   const Ice::FuncSigType Signature;
   llvm::CallingConv::ID CallingConv;
   const bool IsProto;
 
   FunctionDeclaration(const FuncSigType &Signature,
                       llvm::CallingConv::ID CallingConv,
                       llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
       : GlobalDeclaration(FunctionDeclarationKind, Linkage),
         Signature(Signature), CallingConv(CallingConv), IsProto(IsProto) {}
 
-  bool isPNaClABIExternalName(const IceString &Name) const override {
+  bool isPNaClABIExternalName(const std::string &Name) const override {
     return Name == "_start";
   }
 
   bool isIntrinsicName(const GlobalContext *Ctx) const {
     bool IsIntrinsic;
     getIntrinsicInfo(Ctx, &IsIntrinsic);
     return IsIntrinsic;
   }
 
   bool validateRegularTypeSignature() const;
@@ skipping 229 matching lines @@
   void addInitializer(Initializer *Initializer) {
     const bool OldSuppressMangling = getSuppressMangling();
     Initializers.emplace_back(Initializer);
     HasInitializer = true;
     // The getSuppressMangling() logic depends on whether the global variable
     // has initializers.  If its value changed as a result of adding an
     // initializer, then make sure we haven't previously set the name based on
     // faulty SuppressMangling logic.
     const bool SameMangling = (OldSuppressMangling == getSuppressMangling());
     (void)SameMangling;
-    assert(!Name.empty() || SameMangling);
+    assert(Name.hasString() || SameMangling);
   }
 
   /// Prints out type for initializer associated with the declaration to Stream.
   void dumpType(Ostream &Stream) const final;
 
   /// Prints out the definition of the global variable declaration (including
   /// initialization).
   virtual void dump(Ostream &Stream) const override;
 
   /// Returns true if linkage is correct for the variable declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
-    if (isPNaClABIExternalName(getName())) {
-      return Linkage == llvm::GlobalValue::ExternalLinkage;
+    if (getName().hasString()) {
+      if (isPNaClABIExternalName(getName().toString())) {
+        return Linkage == llvm::GlobalValue::ExternalLinkage;
+      }
     }
     return verifyLinkageDefault(Ctx);
   }
 
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
   }
 
   bool getSuppressMangling() const final {
     if (ForceSuppressMangling)
       return true;
     return isExternal() && !hasInitializer();
   }
 
   void discardInitializers() { Initializers.clear(); }
 
-  bool isPNaClABIExternalName(const IceString &Name) const override {
+  bool isPNaClABIExternalName(const std::string &Name) const override {
     return Name == "__pnacl_pso_root";
   }
 
 private:
   /// List of initializers for the declared variable.
   InitializerListType Initializers;
   bool HasInitializer = false;
   /// The alignment of the declared variable.
   uint32_t Alignment = 0;
   /// True if a declared (global) constant.
@@ skipping 17 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H