Subzero. Uses fixups to calculate addend to relocations.

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 385 matching lines @@
   Str << ", ";
   getData()->dump(Func);
   Str << ", beacon=";
   getBeacon()->dump(Func);
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86GetIP::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
+  const auto *Dest = this->getDest();
+  assert(Dest->hasReg());
   Ostream &Str = Func->getContext()->getStrEmit();
-  assert(this->getDest()->hasReg());
   Str << "\t"
-         "addl\t$_GLOBAL_OFFSET_TABLE_, ";
-  this->getDest()->emit(Func);
+         "call"
+         "\t";
+  auto *Target = static_cast<TargetLowering *>(Func->getTarget());
+  Target->emitWithoutPrefix(Target->createGetIPForRegister(Dest));
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86GetIP::emitIAS(const Cfg *Func) const {
-  if (Func->getContext()->getFlags().getOutFileType() == FT_Iasm) {
-    // TODO(stichnot): Find a workaround for llvm-mc's inability to handle
-    // something like ".long _GLOBAL_OFFSET_TABLE_ + ." .  One possibility is to
-    // just use hybrid iasm output for this add instruction.
-    llvm::report_fatal_error(
-        "Iasm support for _GLOBAL_OFFSET_TABLE_ not implemented");
-  }
+  const auto *Dest = this->getDest();
   Assembler *Asm = Func->getAssembler<Assembler>();
-  assert(this->getDest()->hasReg());
-  GPRRegister Reg = Traits::getEncodedGPR(this->getDest()->getRegNum());
-  Constant *GlobalOffsetTable =
-      Func->getContext()->getConstantExternSym("_GLOBAL_OFFSET_TABLE_");
-  AssemblerFixup *Fixup = Asm->createFixup(Traits::FK_GotPC, GlobalOffsetTable);
-  intptr_t OrigPos = Asm->getBufferSize();
-  constexpr int32_t TempDisp = 0;
-  constexpr int32_t ImmediateWidth = 4;
-  // Emit the add instruction once, in a preliminary fashion, to find its total
-  // size.  TODO(stichnot): IceType_i32 should really be something that
-  // represents the target's pointer type.
-  Asm->add(IceType_i32, Reg, AssemblerImmediate(TempDisp, Fixup));
-  const int32_t Disp = Asm->getBufferSize() - OrigPos - ImmediateWidth;
-  // Now roll back and emit the add instruction again, this time with the
-  // correct displacement.
-  Asm->setBufferSize(OrigPos);
-  Asm->add(IceType_i32, Reg, AssemblerImmediate(Disp, Fixup));
+  assert(Dest->hasReg());
+  Asm->call(static_cast<TargetLowering *>(Func->getTarget())
+                ->createGetIPForRegister(Dest));
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86GetIP::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   this->getDest()->dump(Func);
   Str << " = call getIP";
 }
@@ skipping 138 matching lines @@
       // encode, but it isn't a valid sandboxed instruction, and there
       // shouldn't be a register allocation issue to jump through a scratch
       // register, so we don't really need to bother implementing it.
       llvm::report_fatal_error("Assembler can't jmp to memory operand");
     }
   } else if (const auto *Mem = llvm::dyn_cast<X86OperandMem>(Target)) {
     (void)Mem;
     assert(Mem->getSegmentRegister() == X86OperandMem::DefaultSegment);
     llvm::report_fatal_error("Assembler can't jmp to memory operand");
   } else if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(Target)) {
-    assert(CR->getOffset() == 0 && "We only support jumping to a function");
     Asm->jmp(CR);
   } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(Target)) {
     // NaCl trampoline calls refer to an address within the sandbox directly.
     // This is usually only needed for non-IRT builds and otherwise not very
     // portable or stable. Usually this is only done for "calls" and not jumps.
     Asm->jmp(AssemblerImmediate(Imm->getValue()));
   } else {
     llvm::report_fatal_error("Unexpected operand type");
   }
 }
@@ skipping 37 matching lines @@
   if (const auto *Var = llvm::dyn_cast<Variable>(CallTarget)) {
     if (Var->hasReg()) {
       Asm->call(Traits::getEncodedGPR(Var->getRegNum()));
     } else {
       Asm->call(Target->stackVarToAsmOperand(Var));
     }
   } else if (const auto *Mem = llvm::dyn_cast<X86OperandMem>(CallTarget)) {
     assert(Mem->getSegmentRegister() == X86OperandMem::DefaultSegment);
     Asm->call(Mem->toAsmAddress(Asm, Target));
   } else if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(CallTarget)) {
-    assert(CR->getOffset() == 0 && "We only support calling a function");
     Asm->call(CR);
   } else if (const auto *Imm = llvm::dyn_cast<ConstantInteger32>(CallTarget)) {
     Asm->call(AssemblerImmediate(Imm->getValue()));
   } else {
     llvm_unreachable("Unexpected operand type");
   }
 }
 
 template <typename TraitsType>
 void InstImpl<TraitsType>::InstX86Call::dump(const Cfg *Func) const {
@@ skipping 74 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)) {
-    AssemblerFixup *Fixup =
-        Asm->createFixup(Traits::TargetLowering::getAbsFixup(), Reloc);
-    (Asm->*(Emitter.GPRImm))(Ty, VarReg,
-                             AssemblerImmediate(Reloc->getOffset(), Fixup));
+    const auto FixupKind = Reloc->getName() == 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)) {
-    AssemblerFixup *Fixup =
-        Asm->createFixup(Traits::TargetLowering::getAbsFixup(), Reloc);
-    (Asm->*(Emitter.AddrImm))(Ty, Addr,
-                              AssemblerImmediate(Reloc->getOffset(), Fixup));
+    const auto FixupKind = Reloc->getName() == 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>
 void InstImpl<TraitsType>::emitIASAsAddrOpTyGPR(
     const Cfg *Func, Type Ty, const Operand *Op0, const Operand *Op1,
     const GPREmitterAddrOp &Emitter) {
   auto *Target = InstX86Base::getTarget(Func);
@@ skipping 2116 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_END";
 }
 
 } // end of namespace X86NAMESPACE
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H