Subzero: Remove IceString.

src/IceTargetLoweringX8664.cpp

 //===- subzero/src/IceTargetLoweringX8664.cpp - x86-64 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 18 matching lines @@
 }
 
 std::unique_ptr<::Ice::TargetHeaderLowering>
 createTargetHeaderLowering(::Ice::GlobalContext *Ctx) {
   return ::Ice::X8664::TargetHeaderX86::create(Ctx);
 }
 
 void staticInit(::Ice::GlobalContext *Ctx) {
   ::Ice::X8664::TargetX8664::staticInit(Ctx);
 }
+
+bool shouldBePooled(const class ::Ice::Constant *C) {
+  return ::Ice::X8664::TargetX8664::shouldBePooled(C);
+}
+
 } // end of namespace X8664
 
 namespace Ice {
 namespace X8664 {
 
 //------------------------------------------------------------------------------
 //      ______   ______     ______     __     ______   ______
 //     /\__  _\ /\  == \   /\  __ \   /\ \   /\__  _\ /\  ___\
 //     \/_/\ \/ \ \  __<   \ \  __ \  \ \ \  \/_/\ \/ \ \___  \
 //        \ \_\  \ \_\ \_\  \ \_\ \_\  \ \_\    \ \_\  \/\_____\
@@ skipping 288 matching lines @@
 
   Variable *Base = Mem->getBase();
   Variable *Index = Mem->getIndex();
   uint16_t Shift = 0;
   Variable *ZeroReg = RebasePtr;
   Constant *Offset = Mem->getOffset();
   Variable *T = nullptr;
 
   bool AbsoluteAddress = false;
   if (Base == nullptr && Index == nullptr) {
-    if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(Offset)) {
-      if (CR->getName() != "") {
-        // Mem is RIP-relative. There's no need to rebase it.
-        return Mem;
-      }
+    if (llvm::isa<ConstantRelocatable>(Offset)) {
+      // Mem is RIP-relative. There's no need to rebase it.
+      return Mem;
     }
     // Offset is an absolute address, so we need to emit
     //   Offset(%r15)
     AbsoluteAddress = true;
   }
 
   if (Mem->getIsRebased()) {
     // If Mem.IsRebased, then we don't need to update Mem, as it's already been
     // updated to contain a reference to one of %rsp, %rbp, or %r15.
     // We don't return early because we still need to zero extend Index.
@@ skipping 42 matching lines @@
   }
 
   // NeedsLea is a flags indicating whether Mem needs to be materialized to a
   // GPR prior to being used. A LEA is needed if Mem.Offset is a constant
   // relocatable, or if Mem.Offset is negative. In both these cases, the LEA is
   // needed to ensure the sandboxed memory operand will only use the lower
   // 32-bits of T+Offset.
   bool NeedsLea = false;
   if (Offset != nullptr) {
     if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(Offset)) {
-      NeedsLea = CR->getName() != "" || CR->getOffset() < 0;
+      NeedsLea = CR->getOffset() < 0;
     } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Offset)) {
       NeedsLea = Imm->getValue() < 0;
     } else {
       llvm::report_fatal_error("Unexpected Offset type.");
     }
   }
 
   RegNumT RegNum, RegNum32;
   if (T != nullptr) {
     if (T->hasReg()) {
@@ skipping 194 matching lines @@
     //
     // ReturnReloc has an offset that is only known during binary emission.
     // Therefore, we set a custom emit string for ReturnReloc that will be
     // used instead. In this particular case, the code will be emitted as
     //
     //  push .after_call
     InstX86Label *ReturnAddress = InstX86Label::create(Func, this);
     auto *ReturnRelocOffset = RelocOffset::create(Func->getAssembler());
     ReturnAddress->setRelocOffset(ReturnRelocOffset);
     constexpr RelocOffsetT NoFixedOffset = 0;
-    const IceString EmitString = ReturnAddress->getName(Func);
+    const std::string EmitString =
+        BuildDefs::dump() ? ReturnAddress->getLabelName().toString() : "";
     auto *ReturnReloc = ConstantRelocatable::create(
-        Func->getAssembler(), IceType_i32,
+        Func->getAssembler(), Ctx, IceType_i32,
         RelocatableTuple(NoFixedOffset, {ReturnRelocOffset},
                          Func->getFunctionName(), EmitString));
     /* AutoBundle scoping */ {
       std::unique_ptr<AutoBundle> Bundler;
       if (CallTargetR == nullptr) {
         Bundler = makeUnique<AutoBundle>(this, InstBundleLock::Opt_PadToEnd);
         _push(ReturnReloc);
       } else {
         Variable *T = makeReg(IceType_i32);
         Variable *T64 = makeReg(IceType_i64);
@@ skipping 164 matching lines @@
 #define X(tag, sizeLog2, align, elts, elty, str, rcstr)                        \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8664_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace X8664
 } // end of namespace Ice