Subzero. Uses fixups to calculate addend to relocations.

src/IceFixups.cpp

 //===- subzero/src/IceFixups.cpp - Implementation of Assembler Fixups -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 22 matching lines @@
                                  const Assembler *Asm) const {
   std::string Buffer;
   llvm::raw_string_ostream Str(Buffer);
   const Constant *C = value_;
   assert(!isNullSymbol());
   if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(C)) {
     if (CR->getSuppressMangling())
       Str << CR->getName();
     else
       Str << Ctx->mangleName(CR->getName());
-    if (Asm && !Asm->fixupIsPCRel(kind()) && Ctx->getFlags().getUseNonsfi()) {
+    if (Asm && !Asm->fixupIsPCRel(kind()) && Ctx->getFlags().getUseNonsfi() &&
+        CR->getName() != GlobalOffsetTable) {
+      // TODO(jpp): remove the special GOT test.
       Str << "@GOTOFF";
     }
   } else {
     // NOTE: currently only float/doubles are put into constant pools. In the
     // future we may put integers as well.
     assert(llvm::isa<ConstantFloat>(C) || llvm::isa<ConstantDouble>(C));
     C->emitPoolLabel(Str, Ctx);
   }
   return Str.str();
 }
 
 size_t AssemblerFixup::emit(GlobalContext *Ctx, const Assembler &Asm) const {
   static constexpr const size_t FixupSize = 4;
   if (!BuildDefs::dump())
     return FixupSize;
   Ostream &Str = Ctx->getStrEmit();
   Str << "\t.long ";
-  if (isNullSymbol())
+  IceString Symbol;
+  if (isNullSymbol()) {
     Str << "__Sz_AbsoluteZero";
-  else
-    Str << symbol(Ctx, &Asm);
-  RelocOffsetT Offset = Asm.load<RelocOffsetT>(position());
-  if (Offset)
-    Str << " + " << Offset;
-  // For PCRel fixups, we write the pc-offset from a symbol into the Buffer
-  // (e.g., -4), but we don't represent that in the fixup's offset. Otherwise
-  // the fixup holds the true offset, and so does the Buffer. Just load the
-  // offset from the buffer.
-  if (Asm.fixupIsPCRel(kind()))
+  } else {
+    Symbol = symbol(Ctx, &Asm);
+    Str << Symbol;
+  }
+  // The old behavior was x86 specific: emit expected a relocatable addend to

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

I don't think it makes sense to document old behavior like this in the code. 
(It reminds me of when people put dates in comments without the year, or the
standard phone menu admonishment "Please listen carefully, as our options have
changed.")  It's better documented as a comment in the code review, so consider
that done. :)

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

Comment removed. assert left behind with an error message.

+  // "live" in the 4 bytes starting at position(). This is not portable (e.g.,
+  // ARM32 relocations are hardly ever 32-bits.)
+  //
+  // The new behavior: offset() contains the offset that used to be stored in
+  // the instruction stream, so we use it instead of the value at
+  // Asm.Buffer[position()].
+  //
+  // We leave an assert behind to detect any uses that still write anything but
+  // a zero in the instruction stream.
+  //
+  // TODO(jpp): this behavior is also not portable. Ideally, X86 should define
+  // its own sets of relocatables, and define emit as it pleases.
+  assert(Asm.load<RelocOffsetT>(position()) == 0);
+
+  RelocOffsetT Offset = offset();
+  if (Offset != 0) {
+    if (Offset > 0) {
+      Str << " + " << Offset;
+    } else {
+      assert(Offset != std::numeric_limits<RelocOffsetT>::lowest());
+      Str << " - " << -Offset;
+    }
+  }
+
+  // We need to emit the '- .' for PCRel fixups. Even if the relocation kind()
+  // is not PCRel, we emit the '- .' for the _GLOBAL_OFFSET_TABLE_.
+  // TODO(jpp): create fixups wrt the GOT with the right fixup kind.
+  if (Asm.fixupIsPCRel(kind()) || Symbol == GlobalOffsetTable)
     Str << " - .";
   Str << "\n";
   return FixupSize;
 }
 
+void AssemblerFixup::emitOffset(Assembler *Asm) const {
+  Asm->store(position(), offset());
+}
+
 size_t AssemblerTextFixup::emit(GlobalContext *Ctx, const Assembler &) const {
   Ctx->getStrEmit() << Message << "\n";
   return NumBytes;
 }
 
 } // end of namespace Ice