Subzero. Uses fixups to calculate addend to relocations.

src/IceAssemblerX86BaseImpl.h

 //===- subzero/src/IceAssemblerX86BaseImpl.h - base x86 assembler -*- C++ -*-=//
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 116 matching lines @@
   emitRex(RexTypeIrrelevant, address, RexRegIrrelevant);
   emitUint8(0xFF);
   emitOperand(2, address);
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::call(const ConstantRelocatable *label) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   intptr_t call_start = Buffer.getPosition();
   emitUint8(0xE8);
-  emitFixup(this->createFixup(Traits::FK_PcRel, label));
-  emitInt32(-4);
+  auto *Fixup = this->createFixup(Traits::FK_PcRel, label);

[Jim Stichnoth, 2016/02/03 23:18:27]

AssemblerFixup *Fixup
here and below

[John, 2016/02/04 18:28:50]

Discussed offline. Leaving as is.

+  Fixup->set_addend(-4);
+  emitFixup(Fixup);
+  emitInt32(0);
   assert((Buffer.getPosition() - call_start) == kCallExternalLabelSize);
   (void)call_start;
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::call(const Immediate &abs_address) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   intptr_t call_start = Buffer.getPosition();
   emitUint8(0xE8);
-  emitFixup(this->createFixup(Traits::FK_PcRel, AssemblerFixup::NullSymbol));
-  emitInt32(abs_address.value() - 4);
+  auto *Fixup = this->createFixup(Traits::FK_PcRel, AssemblerFixup::NullSymbol);
+  Fixup->set_addend(abs_address.value() - 4);
+  emitFixup(Fixup);
+  emitInt32(0);
   assert((Buffer.getPosition() - call_start) == kCallExternalLabelSize);
   (void)call_start;
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::pushl(GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitRexB(RexTypeIrrelevant, reg);
   emitUint8(0x50 + gprEncoding(reg));
 }
@@ skipping 2973 matching lines @@
   }
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::j(BrCond condition,
                                      const ConstantRelocatable *label) {
   llvm::report_fatal_error("Untested - please verify and then reenable.");
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0x0F);
   emitUint8(0x80 + condition);
-  emitFixup(this->createFixup(Traits::FK_PcRel, label));
-  emitInt32(-4);
+  auto *Fixup = this->createFixup(Traits::FK_PcRel, label);
+  Fixup->set_addend(-4);
+  emitFixup(Fixup);
+  emitInt32(0);
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::jmp(GPRRegister reg) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitRexB(RexTypeIrrelevant, reg);
   emitUint8(0xFF);
   emitRegisterOperand(4, gprEncoding(reg));
 }
 
@@ skipping 18 matching lines @@
   } else {
     emitUint8(0xE9);
     emitLabelLink(label);
   }
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::jmp(const ConstantRelocatable *label) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0xE9);
-  emitFixup(this->createFixup(Traits::FK_PcRel, label));
-  emitInt32(-4);
+  auto *Fixup = this->createFixup(Traits::FK_PcRel, label);
+  Fixup->set_addend(-4);
+  emitFixup(Fixup);
+  emitInt32(0);
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::jmp(const Immediate &abs_address) {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0xE9);
   AssemblerFixup *Fixup =
-      this->createFixup(Traits::FK_PcRel, AssemblerFixup::NullSymbol);
-  Fixup->set_addend(abs_address.value());
+      createFixup(Traits::FK_PcRel, AssemblerFixup::NullSymbol);
+  Fixup->set_addend(abs_address.value() - 4);
   emitFixup(Fixup);
-  emitInt32(abs_address.value() - 4);
+  emitInt32(0);
 }
 
 template <typename TraitsType> void AssemblerX86Base<TraitsType>::mfence() {
   AssemblerBuffer::EnsureCapacity ensured(&Buffer);
   emitUint8(0x0F);
   emitUint8(0xAE);
   emitUint8(0xF0);
 }
 
 template <typename TraitsType> void AssemblerX86Base<TraitsType>::lock() {
@@ skipping 178 matching lines @@
   // Emit the ModRM byte updated with the given RM value.
   assert((operand.encoding_[0] & 0x38) == 0);
   emitUint8(operand.encoding_[0] + (rm << 3));
   // Whenever the addressing mode is not register indirect, using esp == 0x4
   // as the register operation indicates an SIB byte follows.
   if (((operand.encoding_[0] & 0xc0) != 0xc0) &&
       ((operand.encoding_[0] & 0x07) == 0x04)) {
     emitUint8(operand.encoding_[1]);
     displacement_start = 2;
   }
-  // Emit the displacement and the fixup that affects it, if any.
+
   AssemblerFixup *Fixup = operand.fixup();
-  if (Fixup != nullptr) {
-    emitFixup(Fixup);
-    assert(length - displacement_start == 4);
-    if (fixupIsPCRel(Fixup->kind())) {
-      Fixup->set_addend(-Addend);
-      int32_t Offset;
-      memmove(&Offset, &operand.encoding_[displacement_start], sizeof(Offset));
-      Offset -= Addend;
-      emitInt32(Offset);
-      return;
+  if (Fixup == nullptr) {
+    for (intptr_t i = displacement_start; i < length; i++) {
+      emitUint8(operand.encoding_[i]);
     }
+    return;
   }
-  for (intptr_t i = displacement_start; i < length; i++) {
-    emitUint8(operand.encoding_[i]);
+
+  // Emit the fixup, and a dummy 4-byte immediate. Note that the Disp32 in
+  // operand.encoding_[i, i+1, i+2, i+3] is part of the constant relocatable
+  // used to create the fixup, so there's no need to add it to the addend.
+  assert(length - displacement_start == 4);
+  if (fixupIsPCRel(Fixup->kind())) {
+    Fixup->set_addend(Fixup->get_addend() - Addend);
+  } else {
+    Fixup->set_addend(Fixup->get_addend());
   }
+  emitFixup(Fixup);
+  emitInt32(0);
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::emitImmediate(Type Ty,
                                                  const Immediate &imm) {
   auto *const Fixup = imm.fixup();
   if (Ty == IceType_i16) {
     assert(Fixup == nullptr);
     emitInt16(imm.value());
     return;
   }
 
-  if (Fixup != nullptr) {
-    emitFixup(Fixup);
+  if (Fixup == nullptr) {
+    emitInt32(imm.value());
+    return;
   }
-  emitInt32(imm.value());
+
+  Fixup->set_addend(Fixup->get_addend() + imm.value());
+  emitFixup(Fixup);
+  emitInt32(0);
 }
 
 template <typename TraitsType>
 void AssemblerX86Base<TraitsType>::emitComplexI8(int rm, const Operand &operand,
                                                  const Immediate &immediate) {
   assert(rm >= 0 && rm < 8);
   assert(immediate.is_int8());
   if (operand.IsRegister(Traits::Encoded_Reg_Accumulator)) {
     // Use short form if the destination is al.
     emitUint8(0x04 + (rm << 3));
@@ skipping 90 matching lines @@
   (void)shifter;
   if (Ty == IceType_i16)
     emitOperandSizeOverride();
   emitRexB(Ty, operand.rm());
   emitUint8(isByteSizedArithType(Ty) ? 0xD2 : 0xD3);
   emitOperand(rm, operand);
 }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice