Subzero: Remove IceString.

src/IceInstX86BaseImpl.h

 //===- subzero/src/IceInstX86BaseImpl.h - Generic X86 instructions -*- C++ -*=//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 76 matching lines @@
     : InstX86Base(Func, InstX86Base::Shrd, 3, Dest) {
   this->addSource(Dest);
   this->addSource(Source1);
   this->addSource(Source2);
 }
 
 template <typename TraitsType>
 InstImpl<TraitsType>::InstX86Label::InstX86Label(Cfg *Func,
                                                  TargetLowering *Target)
     : InstX86Base(Func, InstX86Base::Label, 0, nullptr),
-      Number(Target->makeNextLabelNumber()) {}
-
-template <typename TraitsType>
-IceString InstImpl<TraitsType>::InstX86Label::getName(const Cfg *Func) const {
-  // TODO(stichnot): Returning an empty string in a non-DUMP build can cause a
-  // huge degradation in ConstantRelocatable hashing.  Investigate and fix, but
-  // for now return something reasonably unique.
-  if (!BuildDefs::dump())
-    return Func->getFunctionName() + std::to_string(Number);
-  return ".L" + Func->getFunctionName() + "$local$__" + std::to_string(Number);
+      LabelNumber(Target->makeNextLabelNumber()) {
+  if (BuildDefs::dump()) {
+    Name = GlobalString::createWithString(
+        Func->getContext(), ".L" + Func->getFunctionName() + "$local$__" +
+                                std::to_string(LabelNumber));
+  } else {
+    Name = GlobalString::createWithoutString(Func->getContext());
+  }
 }
 
 template <typename TraitsType>
 InstImpl<TraitsType>::InstX86Br::InstX86Br(
     Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
     const InstImpl<TraitsType>::InstX86Label *Label, BrCond Condition,
     Mode Kind)
     : InstX86Base(Func, InstX86Base::Br, 0, nullptr), Condition(Condition),
       TargetTrue(TargetTrue), TargetFalse(TargetFalse), Label(Label),
       Kind(Kind) {}
@@ skipping 317 matching lines @@
   Ostream &Str = Func->getContext()->getStrDump();
   this->getDest()->dump(Func);
   Str << " = call getIP";
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Label::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
-  Str << getName(Func) << ":";
+  Str << getLabelName() << ":";
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Label::emitIAS(const Cfg *Func) const {
   Assembler *Asm = Func->getAssembler<Assembler>();
-  Asm->bindLocalLabel(Number);
+  Asm->bindLocalLabel(LabelNumber);
   if (OffsetReloc != nullptr) {
     Asm->bindRelocOffset(OffsetReloc);
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Label::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
-  Str << getName(Func) << ":";
+  Str << getLabelName() << ":";
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Br::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   Str << "\t";
 
   if (Condition == Cond::Br_None) {
     Str << "jmp";
   } else {
     Str << Traits::InstBrAttributes[Condition].EmitString;
   }
 
   if (Label) {
-    Str << "\t" << Label->getName(Func);
+    Str << "\t" << Label->getLabelName();
   } else {
     if (Condition == Cond::Br_None) {
       Str << "\t" << getTargetFalse()->getAsmName();
     } else {
       Str << "\t" << getTargetTrue()->getAsmName();
       if (getTargetFalse()) {
         Str << "\n\t"
                "jmp\t" << getTargetFalse()->getAsmName();
       }
     }
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Br::emitIAS(const Cfg *Func) const {
   Assembler *Asm = Func->getAssembler<Assembler>();
   if (Label) {
-    auto *L = Asm->getOrCreateLocalLabel(Label->getNumber());
+    auto *L = Asm->getOrCreateLocalLabel(Label->getLabelNumber());
     if (Condition == Cond::Br_None) {
       Asm->jmp(L, isNear());
     } else {
       Asm->j(Condition, L, isNear());
     }
   } else {
     if (Condition == Cond::Br_None) {
       auto *L = Asm->getOrCreateCfgNodeLabel(getTargetFalse()->getIndex());
       assert(!getTargetTrue());
       Asm->jmp(L, isNear());
     } else {
       auto *L = Asm->getOrCreateCfgNodeLabel(getTargetTrue()->getIndex());
       Asm->j(Condition, L, isNear());
       if (getTargetFalse()) {
         auto *L2 = Asm->getOrCreateCfgNodeLabel(getTargetFalse()->getIndex());
         Asm->jmp(L2, isNear());
       }
     }
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Br::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "br ";
 
   if (Condition == Cond::Br_None) {
-    Str << "label %"
-        << (Label ? Label->getName(Func) : getTargetFalse()->getName());
+    if (Label) {
+      Str << "label %" << Label->getLabelName();
+    } else {
+      Str << "label %" << getTargetFalse()->getName();
+    }
     return;
   }
 
   Str << Traits::InstBrAttributes[Condition].DisplayString;
   if (Label) {
-    Str << ", label %" << Label->getName(Func);
+    Str << ", label %" << Label->getLabelName();
   } else {
     Str << ", label %" << getTargetTrue()->getName();
     if (getTargetFalse()) {
       Str << ", label %" << getTargetFalse()->getName();
     }
   }
 
   Str << " // (" << (isNear() ? "near" : "far") << " jump)";
 }
 
@@ skipping 110 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (this->getDest()) {
     this->dumpDest(Func);
     Str << " = ";
   }
   Str << "call ";
   getCallTarget()->dump(Func);
 }
 
-// The this->Opcode parameter needs to be char* and not IceString because of
+// The this->Opcode parameter needs to be char* and not std::string because of
 // template issues.
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Base::emitTwoAddress(
     const Cfg *Func, const char *Opcode, const char *Suffix) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(getSrcSize() == 2);
   Operand *Dest = getDest();
   if (Dest == nullptr)
@@ skipping 52 matching lines @@
       Address SrcStackAddr = Target->stackVarToAsmOperand(SrcVar);
       (Asm->*(Emitter.GPRAddr))(Ty, VarReg, SrcStackAddr);
     }
   } else if (const auto *Mem = llvm::dyn_cast<X86OperandMem>(Src)) {
     Mem->emitSegmentOverride(Asm);
     (Asm->*(Emitter.GPRAddr))(Ty, VarReg,
                               Mem->toAsmAddress(Asm, Target, IsLea));
   } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Src)) {
     (Asm->*(Emitter.GPRImm))(Ty, VarReg, AssemblerImmediate(Imm->getValue()));
   } else if (const auto *Reloc = llvm::dyn_cast<ConstantRelocatable>(Src)) {
-    const auto FixupKind = Reloc->getName() == GlobalOffsetTable
+    const auto FixupKind = (Reloc->getName().hasStdString() &&
+                            Reloc->getName().toString() == GlobalOffsetTable)
                                ? Traits::FK_GotPC
                                : Traits::TargetLowering::getAbsFixup();
     AssemblerFixup *Fixup = Asm->createFixup(FixupKind, Reloc);
     (Asm->*(Emitter.GPRImm))(Ty, VarReg, AssemblerImmediate(Fixup));
   } else if (const auto *Split = llvm::dyn_cast<VariableSplit>(Src)) {
     (Asm->*(Emitter.GPRAddr))(Ty, VarReg, Split->toAsmAddress(Func));
   } else {
     llvm_unreachable("Unexpected operand type");
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::emitIASAddrOpTyGPR(const Cfg *Func, Type Ty,
                                               const Address &Addr,
                                               const Operand *Src,
                                               const GPREmitterAddrOp &Emitter) {
   Assembler *Asm = Func->getAssembler<Assembler>();
   // Src can only be Reg or AssemblerImmediate.
   if (const auto *SrcVar = llvm::dyn_cast<Variable>(Src)) {
     assert(SrcVar->hasReg());
     GPRRegister SrcReg = Traits::getEncodedGPR(SrcVar->getRegNum());
     (Asm->*(Emitter.AddrGPR))(Ty, Addr, SrcReg);
   } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Src)) {
     (Asm->*(Emitter.AddrImm))(Ty, Addr, AssemblerImmediate(Imm->getValue()));
   } else if (const auto *Reloc = llvm::dyn_cast<ConstantRelocatable>(Src)) {
-    const auto FixupKind = Reloc->getName() == GlobalOffsetTable
+    const auto FixupKind = (Reloc->getName().hasStdString() &&
+                            Reloc->getName().toString() == GlobalOffsetTable)
                                ? Traits::FK_GotPC
                                : Traits::TargetLowering::getAbsFixup();
     AssemblerFixup *Fixup = Asm->createFixup(FixupKind, Reloc);
     (Asm->*(Emitter.AddrImm))(Ty, Addr, AssemblerImmediate(Fixup));
   } else {
     llvm_unreachable("Unexpected operand type");
   }
 }
 
 template <typename TraitsType>
@@ skipping 1211 matching lines @@
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 1);
   assert(this->getDest()->hasReg());
   Str << "\t"
          "lea" << this->getWidthString(this->getDest()->getType()) << "\t";
   Operand *Src0 = this->getSrc(0);
   if (const auto *Src0Var = llvm::dyn_cast<Variable>(Src0)) {
     Type Ty = Src0Var->getType();
     // lea on x86-32 doesn't accept mem128 operands, so cast VSrc0 to an
     // acceptable type.
-    Src0Var->asType(isVectorType(Ty) ? IceType_i32 : Ty, RegNumT())->emit(Func);
+    Src0Var->asType(Func, isVectorType(Ty) ? IceType_i32 : Ty, RegNumT())
+        ->emit(Func);
   } else {
     Src0->emit(Func);
   }
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Mov::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
@@ skipping 20 matching lines @@
   // point value between a vector and a scalar (which movss is used for). Clean
   // this up.
   assert(InstX86Base::getTarget(Func)->typeWidthInBytesOnStack(DestTy) ==
          InstX86Base::getTarget(Func)->typeWidthInBytesOnStack(SrcTy));
   const Operand *NewSrc = Src;
   if (auto *SrcVar = llvm::dyn_cast<Variable>(Src)) {
     RegNumT NewRegNum;
     if (SrcVar->hasReg())
       NewRegNum = Traits::getGprForType(DestTy, SrcVar->getRegNum());
     if (SrcTy != DestTy)
-      NewSrc = SrcVar->asType(DestTy, NewRegNum);
+      NewSrc = SrcVar->asType(Func, DestTy, NewRegNum);
   }
   NewSrc->emit(Func);
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Mov::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 1);
   const Variable *Dest = this->getDest();
@@ skipping 257 matching lines @@
     if (Src->getType() == IceType_i32 && Dest->getType() == IceType_i64) {
       Ostream &Str = Func->getContext()->getStrEmit();
       if (mayBeElided(Dest, Src)) {
         Str << "\t/* elided movzx */";
       } else {
         Str << "\t"
                "mov"
                "\t";
         Src->emit(Func);
         Str << ", ";
-        Dest->asType(IceType_i32,
+        Dest->asType(Func, IceType_i32,
                      Traits::getGprForType(IceType_i32, Dest->getRegNum()))
             ->emit(Func);
         Str << " /* movzx */";
       }
       return;
     }
   }
   InstX86BaseUnaryopGPR<InstX86Base::Movzx>::emit(Func);
 }
 
@@ skipping 187 matching lines @@
       << Traits::TypeAttributes[this->getSrc(0)->getType()].PackString << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getSrc(0)->emit(Func);
   Str << ", ";
   Variable *Dest = this->getDest();
   // pextrw must take a register dest. There is an SSE4.1 version that takes a
   // memory dest, but we aren't using it. For uniformity, just restrict them
   // all to have a register dest for now.
   assert(Dest->hasReg());
-  Dest->asType(IceType_i32, Dest->getRegNum())->emit(Func);
+  Dest->asType(Func, IceType_i32, Dest->getRegNum())->emit(Func);
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Pextr::emitIAS(const Cfg *Func) const {
   assert(this->getSrcSize() == 2);
   // pextrb and pextrd are SSE4.1 instructions.
   const Variable *Dest = this->getDest();
   Type DispatchTy = Traits::getInVectorElementType(this->getSrc(0)->getType());
   // pextrw must take a register dest. There is an SSE4.1 version that takes a
   // memory dest, but we aren't using it. For uniformity, just restrict them
@@ skipping 16 matching lines @@
   assert(this->getSrcSize() == 3);
   Str << "\t" << this->Opcode
       << Traits::TypeAttributes[this->getDest()->getType()].PackString << "\t";
   this->getSrc(2)->emit(Func);
   Str << ", ";
   Operand *Src1 = this->getSrc(1);
   if (const auto *Src1Var = llvm::dyn_cast<Variable>(Src1)) {
     // If src1 is a register, it should always be r32.
     if (Src1Var->hasReg()) {
       const auto NewRegNum = Traits::getBaseReg(Src1Var->getRegNum());
-      const Variable *NewSrc = Src1Var->asType(IceType_i32, NewRegNum);
+      const Variable *NewSrc = Src1Var->asType(Func, IceType_i32, NewRegNum);
       NewSrc->emit(Func);
     } else {
       Src1Var->emit(Func);
     }
   } else {
     Src1->emit(Func);
   }
   Str << ", ";
   this->getDest()->emit(Func);
 }
@@ skipping 323 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_END";
 }
 
 } // end of namespace X86NAMESPACE
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H