Subzero. Enables moar complex relocation offsets.

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 580 matching lines @@
     JumpTarget = T64;
   }
 
   _jmp(JumpTarget);
 }
 
 Inst *TargetX8664::emitCallToTarget(Operand *CallTarget, Variable *ReturnReg) {
   Inst *NewCall = nullptr;
   auto *CallTargetR = llvm::dyn_cast<Variable>(CallTarget);
   if (NeedSandboxing) {
+    // In NaCl sandbox, calls are replaced by a push/jmp pair:
+    //
+    //     push .after_call
+    //     jmp CallTarget
+    //     .align bundle_size
+    // after_call:
+    //
+    // In order to emit this sequence, we need a temporary label ("after_call",
+    // in this example.)
+    //
+    // The operand to push is a ConstantRelocatable. The easy way to implement
+    // this sequence is to create a ConstantRelocatable(0, "after_call"), but
+    // this ends up creating more relocations for the linker to resolve.
+    // Therefore, we create a ConstantRelocatable from the name of the function
+    // being compiled (i.e., ConstantRelocatable(after_call - Func, Func).
+    //
+    // By default, ConstantRelocatables are emitted (in textual output) as
+    //
+    //  ConstantName + Offset
+    //
+    // 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);
-    ReturnAddress->setIsReturnLocation(true);
+    auto *ReturnRelocOffset = RelocOffset::create(Ctx);
+    ReturnAddress->setRelocOffset(ReturnRelocOffset);
     constexpr bool SuppressMangling = true;
+    const IceString EmitString = ReturnAddress->getName(Func);
+    auto *ReturnReloc = llvm::cast<ConstantRelocatable>(Ctx->getConstantSym(
+        {ReturnRelocOffset}, Ctx->mangleName(Func->getFunctionName()),
+        EmitString, SuppressMangling));
     /* AutoBundle scoping */ {
       std::unique_ptr<AutoBundle> Bundler;
       if (CallTargetR == nullptr) {
         Bundler = makeUnique<AutoBundle>(this, InstBundleLock::Opt_PadToEnd);
-        _push(Ctx->getConstantSym(0, ReturnAddress->getName(Func),
-                                  SuppressMangling));
+        _push(ReturnReloc);
       } else {
         Variable *T = makeReg(IceType_i32);
         Variable *T64 = makeReg(IceType_i64);
         Variable *r15 =
             getPhysicalRegister(Traits::RegisterSet::Reg_r15, IceType_i64);
 
         _mov(T, CallTargetR);
         Bundler = makeUnique<AutoBundle>(this, InstBundleLock::Opt_PadToEnd);
-        _push(Ctx->getConstantSym(0, ReturnAddress->getName(Func),
-                                  SuppressMangling));
+        _push(ReturnReloc);
         const SizeT BundleSize =
             1 << Func->getAssembler<>()->getBundleAlignLog2Bytes();
         _and(T, Ctx->getConstantInt32(~(BundleSize - 1)));
         _movzx(T64, T);
         _add(T64, r15);
         CallTarget = T64;
       }
 
       NewCall = Context.insert<Traits::Insts::Jmp>(CallTarget);
     }
@@ skipping 148 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