Subzero: Remove IceString.

src/IceTargetLoweringARM32.h

 //===- subzero/src/IceTargetLoweringARM32.h - ARM32 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 40 matching lines @@
 };
 
 // The target lowering logic for ARM32.
 class TargetARM32 : public TargetLowering {
   TargetARM32() = delete;
   TargetARM32(const TargetARM32 &) = delete;
   TargetARM32 &operator=(const TargetARM32 &) = delete;
 
 public:
   static void staticInit(GlobalContext *Ctx);
+
+  static bool shouldBePooled(const Constant *C) {
+    if (auto *ConstDouble = llvm::dyn_cast<ConstantDouble>(C)) {
+      return !Utils::isPositiveZero(ConstDouble->getValue());
+    }
+    if (llvm::isa<ConstantFloat>(C))
+      return true;
+    return false;
+  }
+
   // TODO(jvoung): return a unique_ptr.
   static std::unique_ptr<::Ice::TargetLowering> create(Cfg *Func) {
     return makeUnique<TargetARM32>(Func);
   }
 
   std::unique_ptr<::Ice::Assembler> createAssembler() const override {
     const bool IsNonsfi = SandboxingType == ST_Nonsfi;
     return makeUnique<ARM32::AssemblerARM32>(IsNonsfi);
   }
 
   void initNodeForLowering(CfgNode *Node) override {
     Computations.forgetProducers();
     Computations.recordProducers(Node);
     Computations.dump(Func);
   }
 
   void translateOm1() override;
   void translateO2() override;
   bool doBranchOpt(Inst *I, const CfgNode *NextNode) override;
 
   SizeT getNumRegisters() const override { return RegARM32::Reg_NUM; }
   Variable *getPhysicalRegister(RegNumT RegNum,
                                 Type Ty = IceType_void) override;
-  IceString getRegName(RegNumT RegNum, Type Ty) const override;
+  const char *getRegName(RegNumT RegNum, Type Ty) const override;
   SmallBitVector getRegisterSet(RegSetMask Include,
                                 RegSetMask Exclude) const override;
   const SmallBitVector &
   getRegistersForVariable(const Variable *Var) const override {
     RegClass RC = Var->getRegClass();
     switch (RC) {
     default:
       assert(RC < RC_Target);
       return TypeToRegisterSet[RC];
     case RegARM32::RCARM32_QtoS:
@@ skipping 812 matching lines @@
   Variable *GotPtr = nullptr;
   // TODO(jpp): use CfgLocalAllocator.
   /// @}
 
   /// Manages the Gotoff relocations created during the function lowering. A
   /// single Gotoff relocation is created for each global variable used by the
   /// function being lowered.
   /// @{
   // TODO(jpp): if the same global G is used in different functions, then this
   // method will emit one G(gotoff) relocation per function.
-  IceString createGotoffRelocation(const ConstantRelocatable *CR);
-  CfgUnorderedSet<IceString> KnownGotoffs;
+  GlobalString createGotoffRelocation(const ConstantRelocatable *CR);
+  CfgUnorderedSet<GlobalString> KnownGotoffs;
   /// @}
 
   /// Loads the constant relocatable Name to Register. Then invoke Finish to
   /// finish the relocatable lowering. Finish **must** use PC in its first
   /// emitted instruction, or the relocatable in Register will contain the wrong
   /// value.
   //
   // Lowered sequence:
   //
   // Movw:
   //     movw Register, #:lower16:Name - (End - Movw) - 8 .
   // Movt:
   //     movt Register, #:upper16:Name - (End - Movt) - 8 .
   //     PC = fake-def
   // End:
   //     Finish(PC)
   //
   // The -8 in movw/movt above is to account for the PC value that the first
   // instruction emitted by Finish(PC) will read.
   void
-  loadNamedConstantRelocatablePIC(const IceString &Name, Variable *Register,
+  loadNamedConstantRelocatablePIC(GlobalString Name, Variable *Register,
                                   std::function<void(Variable *PC)> Finish);
 
   /// Sandboxer defines methods for ensuring that "dangerous" operations are
   /// masked during sandboxed code emission. For regular, non-sandboxed code
   /// emission, its methods are simple pass-through methods.
   ///
   /// The Sandboxer also emits BundleLock/BundleUnlock pseudo-instructions
   /// in the constructor/destructor during sandboxed code emission. Therefore,
   /// it is a bad idea to create an object of this type and "keep it around."
   /// The recommended usage is:
@@ skipping 339 matching lines @@
   TargetDataARM32() = delete;
   TargetDataARM32(const TargetDataARM32 &) = delete;
   TargetDataARM32 &operator=(const TargetDataARM32 &) = delete;
 
 public:
   static std::unique_ptr<TargetDataLowering> create(GlobalContext *Ctx) {
     return std::unique_ptr<TargetDataLowering>(new TargetDataARM32(Ctx));
   }
 
   void lowerGlobals(const VariableDeclarationList &Vars,
-                    const IceString &SectionSuffix) override;
+                    const std::string &SectionSuffix) override;
   void lowerConstants() override;
   void lowerJumpTables() override;
 
 protected:
   explicit TargetDataARM32(GlobalContext *Ctx);
 
 private:
   ~TargetDataARM32() override = default;
 };
 
@@ skipping 15 matching lines @@
 private:
   ~TargetHeaderARM32() = default;
 
   TargetARM32Features CPUFeatures;
 };
 
 } // end of namespace ARM32
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGARM32_H