Subzero: Remove IceString.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.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 358 matching lines @@
   for (size_t i = 0; i < TypeToRegisterSet.size(); ++i)
     TypeToRegisterSetUnfiltered[i] = TypeToRegisterSet[i];
   filterTypeToRegisterSet(Ctx, Traits::RegisterSet::Reg_NUM,
                           TypeToRegisterSet.data(), TypeToRegisterSet.size(),
                           Traits::getRegName, getRegClassName);
   PcRelFixup = Traits::FK_PcRel;
   AbsFixup =
       Ctx->getFlags().getUseNonsfi() ? Traits::FK_Gotoff : Traits::FK_Abs;
 }
 
+template <typename TraitsType>
+bool TargetX86Base<TraitsType>::shouldBePooled(const Constant *C) {
+  if (auto *ConstFloat = llvm::dyn_cast<ConstantFloat>(C)) {
+    return !Utils::isPositiveZero(ConstFloat->getValue());
+  }
+  if (auto *ConstDouble = llvm::dyn_cast<ConstantDouble>(C)) {
+    return !Utils::isPositiveZero(ConstDouble->getValue());
+  }
+  if (GlobalContext::getFlags().getRandomizeAndPoolImmediatesOption() !=
+      RPI_Pool) {
+    return false;
+  }
+  return C->shouldBeRandomizedOrPooled();
+}
+
 template <typename TraitsType> void TargetX86Base<TraitsType>::translateO2() {
   TimerMarker T(TimerStack::TT_O2, Func);
 
   if (SandboxingType != ST_None) {
     initRebasePtr();
   }
 
   genTargetHelperCalls();
   Func->dump("After target helper call insertion");
 
@@ skipping 459 matching lines @@
     // liveness validation errors for saving callee-save registers.
     Func->addImplicitArg(Reg);
     // Don't bother tracking the live range of a named physical register.
     Reg->setIgnoreLiveness();
   }
   assert(Traits::getGprForType(Ty, RegNum) == RegNum);
   return Reg;
 }
 
 template <typename TraitsType>
-IceString TargetX86Base<TraitsType>::getRegName(RegNumT RegNum, Type Ty) const {
+const char *TargetX86Base<TraitsType>::getRegName(RegNumT RegNum,
+                                                  Type Ty) const {
   return Traits::getRegName(Traits::getGprForType(Ty, RegNum));
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emitVariable(const Variable *Var) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   if (Var->hasReg()) {
     const bool Is64BitSandboxing = Traits::Is64Bit && NeedSandboxing;
@@ skipping 4992 matching lines @@
         assert(Traits::Is64Bit);
         _mov(Index, RangeIndex); // trunc
       } else {
         _movzx(Index, RangeIndex);
       }
     } else {
       Index = legalizeToReg(RangeIndex);
     }
 
     constexpr RelocOffsetT RelocOffset = 0;
-    const IceString &FunctionName = Func->getFunctionName();
+    GlobalString FunctionName = Func->getFunctionName();
     constexpr Variable *NoBase = nullptr;
-    Constant *Offset = Ctx->getConstantSym(
-        RelocOffset, InstJumpTable::makeName(FunctionName, JumpTable->getId()));
+    auto JTName = GlobalString::createWithString(
+        Ctx, InstJumpTable::makeName(FunctionName, JumpTable->getId()));
+    Constant *Offset = Ctx->getConstantSym(RelocOffset, JTName);
     uint16_t Shift = typeWidthInBytesLog2(PointerType);
     constexpr auto Segment = X86OperandMem::SegmentRegisters::DefaultSegment;
 
     Variable *Target = nullptr;
     if (Traits::Is64Bit && NeedSandboxing) {
       assert(Index != nullptr && Index->getType() == IceType_i32);
     }
     auto *TargetInMemory = X86OperandMem::create(Func, PointerType, NoBase,
                                                  Offset, Index, Shift, Segment);
     _mov(Target, TargetInMemory);
@@ skipping 926 matching lines @@
       // Convert a scalar floating point constant into an explicit memory
       // operand.
       if (auto *ConstFloat = llvm::dyn_cast<ConstantFloat>(Const)) {
         if (Utils::isPositiveZero(ConstFloat->getValue()))
           return makeZeroedRegister(Ty, RegNum);
       } else if (auto *ConstDouble = llvm::dyn_cast<ConstantDouble>(Const)) {
         if (Utils::isPositiveZero(ConstDouble->getValue()))
           return makeZeroedRegister(Ty, RegNum);
       }
 
-      std::string Buffer;
-      llvm::raw_string_ostream StrBuf(Buffer);
-      llvm::cast<Constant>(From)->emitPoolLabel(StrBuf);
-      llvm::cast<Constant>(From)->setShouldBePooled(true);
-      Constant *Offset = Ctx->getConstantSym(0, StrBuf.str());
+      auto *CFrom = llvm::cast<Constant>(From);
+      assert(CFrom->getShouldBePooled());
+      Constant *Offset = Ctx->getConstantSym(0, CFrom->getLabelName());
       auto *Mem = X86OperandMem::create(Func, Ty, nullptr, Offset);
       From = Mem;
     }
 
     bool NeedsReg = false;
     if (!(Allowed & Legal_Imm) && !isScalarFloatingType(Ty))
       // Immediate specifically not allowed.
       NeedsReg = true;
     if (!(Allowed & Legal_Mem) && isScalarFloatingType(Ty))
       // On x86, FP constants are lowered to mem operands.
@@ skipping 196 matching lines @@
     Ostream &Str = Ctx->getStrEmit();
     Str << "$" << C->getValue();
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emit(const ConstantFloat *C) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
-  C->emitPoolLabel(Str);
+  Str << C->getLabelName();
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emit(const ConstantDouble *C) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
-  C->emitPoolLabel(Str);
+  Str << C->getLabelName();
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emit(const ConstantUndef *) const {
   llvm::report_fatal_error("undef value encountered by emitter.");
 }
 
 template <class Machine>
 void TargetX86Base<Machine>::emit(const ConstantRelocatable *C) const {
   if (!BuildDefs::dump())
     return;
-  assert(!Ctx->getFlags().getUseNonsfi() || C->getName() == GlobalOffsetTable);
+  assert(!Ctx->getFlags().getUseNonsfi() ||
+         C->getName().toString() == GlobalOffsetTable);
   Ostream &Str = Ctx->getStrEmit();
   Str << "$";
   emitWithoutPrefix(C);
 }
 
 /// Randomize or pool an Immediate.
 template <typename TraitsType>
 Operand *
 TargetX86Base<TraitsType>::randomizeOrPoolImmediate(Constant *Immediate,
                                                     RegNumT RegNum) {
   assert(llvm::isa<ConstantInteger32>(Immediate) ||
          llvm::isa<ConstantRelocatable>(Immediate));
   if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_None ||
       RandomizationPoolingPaused == true) {
     // Immediates randomization/pooling off or paused
     return Immediate;
   }
 
   if (Traits::Is64Bit && NeedSandboxing) {
     // Immediate randomization/pooling is currently disabled for x86-64
     // sandboxing for it could generate invalid memory operands.
     assert(false &&
            "Constant pooling/randomization is disabled for x8664 sandbox.");
     return Immediate;
   }
 
-  if (!Immediate->shouldBeRandomizedOrPooled(Ctx)) {
+  if (!Immediate->shouldBeRandomizedOrPooled()) {
     // the constant Immediate is not eligible for blinding/pooling
     return Immediate;
   }
   Ctx->statsUpdateRPImms();
   switch (Ctx->getFlags().getRandomizeAndPoolImmediatesOption()) {
   default:
     llvm::report_fatal_error("Unsupported -randomize-pool-immediates option");
   case RPI_Randomize: {
     // blind the constant
     // FROM:
@@ skipping 22 matching lines @@
     return TruncReg;
   }
   case RPI_Pool: {
     // pool the constant
     // FROM:
     //  imm
     // TO:
     //  insert: mov $label, Reg
     //  => Reg
     assert(Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_Pool);
-    Immediate->setShouldBePooled(true);
+    assert(Immediate->getShouldBePooled());
     // if we have already assigned a phy register, we must come from
     // advancedPhiLowering()=>lowerAssign(). In this case we should reuse the
     // assigned register as this assignment is that start of its use-def
     // chain. So we add RegNum argument here.
     Variable *Reg = makeReg(Immediate->getType(), RegNum);
-    IceString Label;
-    llvm::raw_string_ostream Label_stream(Label);
-    Immediate->emitPoolLabel(Label_stream);
     constexpr RelocOffsetT Offset = 0;
-    Constant *Symbol = Ctx->getConstantSym(Offset, Label_stream.str());
+    Constant *Symbol = Ctx->getConstantSym(Offset, Immediate->getLabelName());
     constexpr Variable *NoBase = nullptr;
     X86OperandMem *MemOperand =
         X86OperandMem::create(Func, Immediate->getType(), NoBase, Symbol);
     _mov(Reg, MemOperand);
     return Reg;
   }
   }
 }
 
 template <typename TraitsType>
@@ skipping 19 matching lines @@
   // again.
   if (MemOperand->getRandomized())
     return MemOperand;
 
   auto *C = llvm::dyn_cast_or_null<Constant>(MemOperand->getOffset());
 
   if (C == nullptr) {
     return MemOperand;
   }
 
-  if (!C->shouldBeRandomizedOrPooled(Ctx)) {
+  if (!C->shouldBeRandomizedOrPooled()) {
     return MemOperand;
   }
 
   // The offset of this mem operand should be blinded or pooled
   Ctx->statsUpdateRPImms();
   switch (Ctx->getFlags().getRandomizeAndPoolImmediatesOption()) {
   default:
     llvm::report_fatal_error("Unsupported -randomize-pool-immediates option");
   case RPI_Randomize: {
     // blind the constant offset
@@ skipping 40 matching lines @@
     //  =>[RegTemp, index, shift]
 
     // Memory operand should never exist as source operands in phi lowering
     // assignments, so there is no need to reuse any registers here. For
     // phi lowering, we should not ask for new physical registers in
     // general. However, if we do meet Memory Operand during phi lowering,
     // we should not blind or pool the immediates for now.
     if (RegNum.hasValue())
       return MemOperand;
     Variable *RegTemp = makeReg(IceType_i32);
-    IceString Label;
-    llvm::raw_string_ostream Label_stream(Label);
-    MemOperand->getOffset()->emitPoolLabel(Label_stream);
-    MemOperand->getOffset()->setShouldBePooled(true);
+    assert(MemOperand->getOffset()->getShouldBePooled());
     constexpr RelocOffsetT SymOffset = 0;
-    Constant *Symbol = Ctx->getConstantSym(SymOffset, Label_stream.str());
+    Constant *Symbol =
+        Ctx->getConstantSym(SymOffset, MemOperand->getOffset()->getLabelName());
     constexpr Variable *NoBase = nullptr;
     X86OperandMem *SymbolOperand = X86OperandMem::create(
         Func, MemOperand->getOffset()->getType(), NoBase, Symbol);
     _mov(RegTemp, SymbolOperand);
     // If we have a base variable here, we should add the lea instruction
     // to add the value of the base variable to RegTemp. If there is no
     // base variable, we won't need this lea instruction.
     if (MemOperand->getBase()) {
       X86OperandMem *CalculateOperand = X86OperandMem::create(
           Func, MemOperand->getType(), MemOperand->getBase(), nullptr, RegTemp,
           0, MemOperand->getSegmentRegister());
       _lea(RegTemp, CalculateOperand);
     }
     X86OperandMem *NewMemOperand = X86OperandMem::create(
         Func, MemOperand->getType(), RegTemp, nullptr, MemOperand->getIndex(),
         MemOperand->getShift(), MemOperand->getSegmentRegister());
     return NewMemOperand;
   }
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emitJumpTable(
     const Cfg *Func, const InstJumpTable *JumpTable) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   const bool UseNonsfi = Ctx->getFlags().getUseNonsfi();
-  const IceString &FunctionName = Func->getFunctionName();
-  const IceString Prefix = UseNonsfi ? ".data.rel.ro." : ".rodata.";
+  GlobalString FunctionName = Func->getFunctionName();
+  const char *Prefix = UseNonsfi ? ".data.rel.ro." : ".rodata.";
   Str << "\t.section\t" << Prefix << FunctionName
       << "$jumptable,\"a\",@progbits\n";
   Str << "\t.align\t" << typeWidthInBytes(getPointerType()) << "\n";
   Str << InstJumpTable::makeName(FunctionName, JumpTable->getId()) << ":";
 
   // On X86 ILP32 pointers are 32-bit hence the use of .long
   for (SizeT I = 0; I < JumpTable->getNumTargets(); ++I)
     Str << "\n\t.long\t" << JumpTable->getTarget(I)->getAsmName();
   Str << "\n";
 }
@@ skipping 32 matching lines @@
     // Use memcpy() to copy bits from Value into RawValue in a way that avoids
     // breaking strict-aliasing rules.
     typename T::PrimitiveIntType RawValue;
     memcpy(&RawValue, &Value, sizeof(Value));
     char buf[30];
     int CharsPrinted =
         snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue);
     assert(CharsPrinted >= 0);
     assert((size_t)CharsPrinted < llvm::array_lengthof(buf));
     (void)CharsPrinted; // avoid warnings if asserts are disabled
-    Const->emitPoolLabel(Str);
+    Str << Const->getLabelName();
     Str << ":\n\t" << T::AsmTag << "\t" << buf << "\t/* " << T::TypeName << " "
         << Value << " */\n";
   }
 }
 
 template <typename TraitsType>
 void TargetDataX86<TraitsType>::lowerConstants() {
   if (Ctx->getFlags().getDisableTranslation())
     return;
   switch (Ctx->getFlags().getOutFileType()) {
@@ skipping 30 matching lines @@
     for (const JumpTableData &JT : Ctx->getJumpTables())
       Writer->writeJumpTable(JT, Traits::FK_Abs, IsPIC);
   } break;
   case FT_Asm:
     // Already emitted from Cfg
     break;
   case FT_Iasm: {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Ctx->getStrEmit();
-    const IceString Prefix = IsPIC ? ".data.rel.ro." : ".rodata.";
+    const char *Prefix = IsPIC ? ".data.rel.ro." : ".rodata.";
     for (const JumpTableData &JT : Ctx->getJumpTables()) {
       Str << "\t.section\t" << Prefix << JT.getFunctionName()
           << "$jumptable,\"a\",@progbits\n";
       Str << "\t.align\t" << typeWidthInBytes(getPointerType()) << "\n";
       Str << InstJumpTable::makeName(JT.getFunctionName(), JT.getId()) << ":";
 
       // On X8664 ILP32 pointers are 32-bit hence the use of .long
       for (intptr_t TargetOffset : JT.getTargetOffsets())
         Str << "\n\t.long\t" << JT.getFunctionName() << "+" << TargetOffset;
       Str << "\n";
     }
   } break;
   }
 }
 
 template <typename TraitsType>
 void TargetDataX86<TraitsType>::lowerGlobals(
-    const VariableDeclarationList &Vars, const IceString &SectionSuffix) {
+    const VariableDeclarationList &Vars, const std::string &SectionSuffix) {
   const bool IsPIC = Ctx->getFlags().getUseNonsfi();
   switch (Ctx->getFlags().getOutFileType()) {
   case FT_Elf: {
     ELFObjectWriter *Writer = Ctx->getObjectWriter();
     Writer->writeDataSection(Vars, Traits::FK_Abs, SectionSuffix, IsPIC);
   } break;
   case FT_Asm:
   case FT_Iasm: {
-    const IceString &TranslateOnly = Ctx->getFlags().getTranslateOnly();
+    const std::string TranslateOnly = Ctx->getFlags().getTranslateOnly();
     OstreamLocker L(Ctx);
     for (const VariableDeclaration *Var : Vars) {
       if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H