Subzero. Uses fixups to calculate addend to relocations.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 17 matching lines @@
       Ctx);
 }
 
 std::unique_ptr<::Ice::TargetHeaderLowering>
 createTargetHeaderLowering(::Ice::GlobalContext *Ctx) {
   return ::Ice::X8632::TargetHeaderX86::create(Ctx);
 }
 
 void staticInit(::Ice::GlobalContext *Ctx) {
   ::Ice::X8632::TargetX8632::staticInit(Ctx);
+  if (Ctx->getFlags().getUseNonsfi()) {
+    // In nonsfi, we need to reference the _GLOBAL_OFFSET_TABLE_ for accessing
+    // globals. The GOT is an external symbol (i.e., it is not defined in the
+    // pexe) so we need to register it as such so that ELF emission won't barf
+    // on an "unknown" symbol. The GOT is added to the External symbols list
+    // here because staticInit() is invoked in a single-thread context.
+    Ctx->getConstantExternSym(::Ice::GlobalOffsetTable);
+  }
 }
 } // end of namespace X8632
 
 namespace Ice {
 namespace X8632 {
 
 //------------------------------------------------------------------------------
 //      ______   ______     ______     __     ______   ______
 //     /\__  _\ /\  == \   /\  __ \   /\ \   /\__  _\ /\  ___\
 //     \/_/\ \/ \ \  __<   \ \  __ \  \ \ \  \/_/\ \/ \ \___  \
@@ skipping 178 matching lines @@
   }
   // Delete any existing InstX86GetIP instruction and reinsert it here.  Also,
   // insert the call to the helper function and the spill to the stack, to
   // simplify emission.
   if (GetIPInst) {
     GetIPInst->setDeleted();
     Variable *Dest = GetIPInst->getDest();
     Variable *CallDest =
         Dest->hasReg() ? Dest
                        : getPhysicalRegister(Traits::RegisterSet::Reg_eax);
-    // Call the getIP_<reg> helper.
-    IceString RegName = Traits::getRegName(CallDest->getRegNum());
-    Constant *CallTarget = Ctx->getConstantExternSym(H_getIP_prefix + RegName);
-    Context.insert<Traits::Insts::Call>(CallDest, CallTarget);
+    auto *BeforeAddReloc = RelocOffset::create(Ctx);
+    BeforeAddReloc->setSubtract(true);
+    auto *BeforeAdd = InstX86Label::create(Func, this);
+    BeforeAdd->setRelocOffset(BeforeAddReloc);
+
+    auto *AfterAddReloc = RelocOffset::create(Ctx);
+    auto *AfterAdd = InstX86Label::create(Func, this);
+    AfterAdd->setRelocOffset(AfterAddReloc);
+
+    auto *ImmSize = RelocOffset::create(Ctx, -typeWidthInBytes(IceType_i32));
+
+    auto *GotFromPc = llvm::cast<ConstantRelocatable>(
+        Ctx->getConstantSym({AfterAddReloc, BeforeAddReloc, ImmSize},
+                            GlobalOffsetTable, GlobalOffsetTable, true));
+
     // Insert a new version of InstX86GetIP.
     Context.insert<Traits::Insts::GetIP>(CallDest);
+
+    Context.insert(BeforeAdd);
+    _add(CallDest, GotFromPc);
+    Context.insert(AfterAdd);
+
     // Spill the register to its home stack location if necessary.
-    if (!Dest->hasReg()) {
+    if (Dest != CallDest) {
       _mov(Dest, CallDest);
     }
   }
 }
 
 void TargetX8632::lowerIndirectJump(Variable *JumpTarget) {
   AutoBundle _(this);
 
   if (NeedSandboxing) {
     const SizeT BundleSize =
@@ skipping 199 matching lines @@
 #define X(tag, sizeLog2, align, elts, elty, str, rcstr)                        \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace X8632
 } // end of namespace Ice