Subzero. Uses fixups to calculate addend to relocations.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 247 matching lines @@
 
 public:
   static RelocOffset *create(GlobalContext *Ctx) {
     return new (Ctx->allocate<RelocOffset>()) RelocOffset();
   }
 
   static RelocOffset *create(GlobalContext *Ctx, RelocOffsetT Value) {
     return new (Ctx->allocate<RelocOffset>()) RelocOffset(Value);
   }
 
+  void setSubtract(bool Value) { Subtract = Value; }
   bool hasOffset() const { return HasOffset; }
 
   RelocOffsetT getOffset() const {
     assert(HasOffset);
     return Offset;
   }
 
   void setOffset(const RelocOffsetT Value) {
     assert(!HasOffset);
-    Offset = Value;
+    if (Subtract) {
+      assert(Value != std::numeric_limits<RelocOffsetT>::lowest());
+      Offset = -Value;
+    } else {
+      Offset = Value;
+    }
     HasOffset = true;
   }
 
 private:
   RelocOffset() = default;
   explicit RelocOffset(RelocOffsetT Offset) { setOffset(Offset); }
 
+  bool Subtract = false;
   bool HasOffset = false;
   RelocOffsetT Offset;
 };
 
 /// RelocatableTuple bundles the parameters that are used to construct an
 /// ConstantRelocatable. It is done this way so that ConstantRelocatable can fit
 /// into the global constant pool template mechanism.
 class RelocatableTuple {
   RelocatableTuple() = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
@@ skipping 510 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H