Subzero: Remove IceString.

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 39 matching lines @@
 // a TargetLowering object pointer and an Inst pointer, it adds appropriate
 // FakeDef and FakeUse instructions to try maintain liveness consistency.
 #define UnimplementedLoweringError(Target, Instr)                              \
   do {                                                                         \
     if ((Target)->Ctx->getFlags().getSkipUnimplemented()) {                    \
       (Target)->addFakeDefUses(Instr);                                         \
     } else {                                                                   \
       /* Use llvm_unreachable instead of report_fatal_error, which gives       \
          better stack traces. */                                               \
       llvm_unreachable(                                                        \
-          ("Not yet implemented: " + Instr->getInstName()).c_str());           \
+          (std::string("Not yet implemented: ") + Instr->getInstName())        \
+              .c_str());                                                       \
       abort();                                                                 \
     }                                                                          \
   } while (0)
 
 /// LoweringContext makes it easy to iterate through non-deleted instructions in
 /// a node, and insert new (lowered) instructions at the current point. Along
 /// with the instruction list container and associated iterators, it holds the
 /// current node, which is needed when inserting new instructions in order to
 /// track whether variables are used as single-block or multi-block.
 class LoweringContext {
@@ skipping 94 matching lines @@
 ///  }
 class TargetLowering {
   TargetLowering() = delete;
   TargetLowering(const TargetLowering &) = delete;
   TargetLowering &operator=(const TargetLowering &) = delete;
 
 public:
   static void staticInit(GlobalContext *Ctx);
   // Each target must define a public static method:
   //   static void staticInit(GlobalContext *Ctx);
+  static bool shouldBePooled(const class Constant *C);
 
   static std::unique_ptr<TargetLowering> createLowering(TargetArch Target,
                                                         Cfg *Func);
 
   virtual std::unique_ptr<Assembler> createAssembler() const = 0;
 
   void translate() {
     switch (Ctx->getFlags().getOptLevel()) {
     case Opt_m1:
       translateOm1();
@@ skipping 45 matching lines @@
   }
 
   virtual SizeT getNumRegisters() const = 0;
   /// Returns a variable pre-colored to the specified physical register. This is
   /// generally used to get very direct access to the register such as in the
   /// prolog or epilog or for marking scratch registers as killed by a call. If
   /// a Type is not provided, a target-specific default type is used.
   virtual Variable *getPhysicalRegister(RegNumT RegNum,
                                         Type Ty = IceType_void) = 0;
   /// Returns a printable name for the register.
-  virtual IceString getRegName(RegNumT RegNum, Type Ty) const = 0;
+  virtual const char *getRegName(RegNumT RegNum, Type Ty) const = 0;
 
   virtual bool hasFramePointer() const { return false; }
   virtual void setHasFramePointer() = 0;
   virtual RegNumT getStackReg() const = 0;
   virtual RegNumT getFrameReg() const = 0;
   virtual RegNumT getFrameOrStackReg() const = 0;
   virtual size_t typeWidthInBytesOnStack(Type Ty) const = 0;
   virtual uint32_t getStackAlignment() const = 0;
   virtual void reserveFixedAllocaArea(size_t Size, size_t Align) = 0;
   virtual int32_t getFrameFixedAllocaOffset() const = 0;
@@ skipping 106 matching lines @@
                                                     InstBundleLock::Opt_None);
     ~AutoBundle();
 
   private:
     TargetLowering *const Target;
     const bool NeedSandboxing;
   };
 
   explicit TargetLowering(Cfg *Func);
   // Applies command line filters to TypeToRegisterSet array.
-  static void
-  filterTypeToRegisterSet(GlobalContext *Ctx, int32_t NumRegs,
-                          SmallBitVector TypeToRegisterSet[],
-                          size_t TypeToRegisterSetSize,
-                          std::function<IceString(RegNumT)> getRegName,
-                          std::function<IceString(RegClass)> getRegClassName);
+  static void filterTypeToRegisterSet(
+      GlobalContext *Ctx, int32_t NumRegs, SmallBitVector TypeToRegisterSet[],
+      size_t TypeToRegisterSetSize,
+      std::function<std::string(RegNumT)> getRegName,
+      std::function<const char *(RegClass)> getRegClassName);
   virtual void lowerAlloca(const InstAlloca *Instr) = 0;
   virtual void lowerArithmetic(const InstArithmetic *Instr) = 0;
   virtual void lowerAssign(const InstAssign *Instr) = 0;
   virtual void lowerBr(const InstBr *Instr) = 0;
   virtual void lowerCall(const InstCall *Instr) = 0;
   virtual void lowerCast(const InstCast *Instr) = 0;
   virtual void lowerFcmp(const InstFcmp *Instr) = 0;
   virtual void lowerExtractElement(const InstExtractElement *Instr) = 0;
   virtual void lowerIcmp(const InstIcmp *Instr) = 0;
   virtual void lowerInsertElement(const InstInsertElement *Instr) = 0;
@@ skipping 193 matching lines @@
 class TargetDataLowering {
   TargetDataLowering() = delete;
   TargetDataLowering(const TargetDataLowering &) = delete;
   TargetDataLowering &operator=(const TargetDataLowering &) = delete;
 
 public:
   static std::unique_ptr<TargetDataLowering> createLowering(GlobalContext *Ctx);
   virtual ~TargetDataLowering();
 
   virtual void lowerGlobals(const VariableDeclarationList &Vars,
-                            const IceString &SectionSuffix) = 0;
+                            const std::string &SectionSuffix) = 0;
   virtual void lowerConstants() = 0;
   virtual void lowerJumpTables() = 0;
 
 protected:
   void emitGlobal(const VariableDeclaration &Var,
-                  const IceString &SectionSuffix);
+                  const std::string &SectionSuffix);
 
   /// For now, we assume .long is the right directive for emitting 4 byte emit
   /// global relocations. However, LLVM MIPS usually uses .4byte instead.
   /// Perhaps there is some difference when the location is unaligned.
   static const char *getEmit32Directive() { return ".long"; }
 
   explicit TargetDataLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
@@ skipping 13 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H