Subzero: Remove IceString.

src/IceTargetLoweringX86Base.h

 //===- subzero/src/IceTargetLoweringX86Base.h - x86 lowering ----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 61 matching lines @@
   using SegmentRegisters = typename Traits::X86OperandMem::SegmentRegisters;
   using SpillVariable = typename Traits::SpillVariable;
 
   using InstX86Br = typename Traits::Insts::Br;
   using InstX86FakeRMW = typename Traits::Insts::FakeRMW;
   using InstX86Label = typename Traits::Insts::Label;
 
   ~TargetX86Base() override = default;
 
   static void staticInit(GlobalContext *Ctx);
+  static bool shouldBePooled(const Constant *C);
 
   static FixupKind getPcRelFixup() { return PcRelFixup; }
   static FixupKind getAbsFixup() { return AbsFixup; }
 
   bool needSandboxing() const { return NeedSandboxing; }
 
   void translateOm1() override;
   void translateO2() override;
   void doLoadOpt();
   bool doBranchOpt(Inst *I, const CfgNode *NextNode) override;
 
   SizeT getNumRegisters() const override {
     return Traits::RegisterSet::Reg_NUM;
   }
   Variable *getPhysicalRegister(RegNumT RegNum,
                                 Type Ty = IceType_void) override;
-  IceString getRegName(RegNumT RegNum, Type Ty) const override;
-  static IceString getRegClassName(RegClass C) {
+  const char *getRegName(RegNumT RegNum, Type Ty) const override;
+  static const char *getRegClassName(RegClass C) {
     auto ClassNum = static_cast<RegClassX86>(C);
     assert(ClassNum < RCX86_NUM);
     switch (ClassNum) {
     default:
       assert(C < RC_Target);
       return regClassString(C);
     case RCX86_Is64To8:
       return "i64to8"; // 64-bit GPR truncable to i8
     case RCX86_Is32To8:
       return "i32to8"; // 32-bit GPR truncable to i8
@@ skipping 57 matching lines @@
   virtual void updateMaxOutArgsSizeBytes(uint32_t Size) {
     MaxOutArgsSizeBytes = std::max(MaxOutArgsSizeBytes, Size);
   }
 
   bool shouldSplitToVariable64On32(Type Ty) const override {
     return Traits::Is64Bit ? false : Ty == IceType_i64;
   }
 
   ConstantRelocatable *createGetIPForRegister(const Variable *Dest) {
     assert(Dest->hasReg());
-    const IceString RegName = Traits::getRegName(Dest->getRegNum());
-    return llvm::cast<ConstantRelocatable>(
-        Ctx->getConstantExternSym(H_getIP_prefix + RegName));
+    const std::string RegName = Traits::getRegName(Dest->getRegNum());
+    return llvm::cast<ConstantRelocatable>(Ctx->getConstantExternSym(
+        Ctx->getGlobalString(H_getIP_prefix + RegName)));
   }
 
   SizeT getMinJumpTableSize() const override { return 4; }
 
   void emitVariable(const Variable *Var) const override;
 
   void emit(const ConstantInteger32 *C) const final;
   void emit(const ConstantInteger64 *C) const final;
   void emit(const ConstantFloat *C) const final;
   void emit(const ConstantDouble *C) const final;
@@ skipping 900 matching lines @@
   TargetDataX86 &operator=(const TargetDataX86 &) = delete;
 
 public:
   ~TargetDataX86() override = default;
 
   static std::unique_ptr<TargetDataLowering> create(GlobalContext *Ctx) {
     return makeUnique<TargetDataX86>(Ctx);
   }
 
   void lowerGlobals(const VariableDeclarationList &Vars,
-                    const IceString &SectionSuffix) override;
+                    const std::string &SectionSuffix) override;
   void lowerConstants() override;
   void lowerJumpTables() override;
 
 private:
   ENABLE_MAKE_UNIQUE;
 
   explicit TargetDataX86(GlobalContext *Ctx) : TargetDataLowering(Ctx){};
   template <typename T> static void emitConstantPool(GlobalContext *Ctx);
 };
 
@@ skipping 14 matching lines @@
 
   explicit TargetHeaderX86(GlobalContext *Ctx) : TargetHeaderLowering(Ctx) {}
 };
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceTargetLoweringX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASE_H