X86MachObjectWriter: Allow subtractors with undefined targets.

[jckarter]

Summary

This appears to work and be supported by ld64 on Darwin. The subtraction is represented symbolically in the Mach-O object format, and ld64 relocates the offset when the target is a weak or coalesced definition and appears to still do so when the target is undefined. (Possibly it even works with an undefined base, but I don't need that for my use case and didn't thoroughly test it.)

lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp

if (Target.isAbsolute()) { // constant
     // single SIGNED relocation); reject it for now.  Except the case where both
     // symbols don't have a base, equal but both NULL.
     if (A_Base == B_Base && A_Base) {
       Asm.getContext().reportError(
           Fixup.getLoc(), "unsupported relocation with identical base");
       return;
     }
 
-    // A subtraction expression where either symbol is undefined is a
+    // A subtraction expression where the base is undefined is a
     // non-relocatable expression.
-    if (A->isUndefined() || B->isUndefined()) {
-      StringRef Name = A->isUndefined() ? A->getName() : B->getName();
+    if (B->isUndefined()) {
+      StringRef Name = B->getName();
       Asm.getContext().reportError(Fixup.getLoc(),
         "unsupported relocation with subtraction expression, symbol '" +
         Name + "' can not be undefined in a subtraction expression");
       return;
     }
 
+    if (!A->isUndefined())
       Value += Writer->getSymbolAddress(*A, Layout) -
                (!A_Base ? 0 : Writer->getSymbolAddress(*A_Base, Layout));
     Value -= Writer->getSymbolAddress(*B, Layout) -
              (!B_Base ? 0 : Writer->getSymbolAddress(*B_Base, Layout));
 
     if (!A_Base)
       Index = A->getFragment()->getParent()->getOrdinal() + 1;
     Type = MachO::X86_64_RELOC_UNSIGNED;
 
     MachO::any_relocation_info MRE;

test/MC/MachO/bad-darwin-x86_64-diff-relocs.s

 // RUN: not llvm-mc -triple x86_64-apple-darwin10 %s -filetype=obj -o - 2> %t.err > %t
 // RUN: FileCheck --check-prefix=CHECK-ERROR < %t.err %s
 
 .quad _foo - _bar
 // CHECK-ERROR: error: unsupported relocation with subtraction expression
 
 _Y:
 .long (_Y+4)-_b
 // CHECK-ERROR: error: unsupported relocation with subtraction expression, symbol '_b' can not be undefined in a subtraction expression
 
+// Undefined target is OK if the base is defined.
 _Z:
 .long (_a+4)-_Z
-// CHECK-ERROR: error: unsupported relocation with subtraction expression, symbol '_a' can not be undefined in a subtraction expression

test/MC/X86/macho-reloc-errors-x86_64.s

 // RUN: not llvm-mc -triple=x86_64-apple-darwin -filetype=obj -o /dev/null %s 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
 
         mov %rax, thing
         mov %rax, thing@GOT-thing2@GOT
         mov %rax, (thing-thing2)(%rip)
         mov %rax, thing-thing
         mov %rax, thing-thing2
         mov %rax, thing@PLT
         jmp thing@PLT
         mov %rax, thing@TLVP
 
 // CHECK-ERROR: 3:9: error: 32-bit absolute addressing is not supported in 64-bit mode
 // CHECK-ERROR: 4:9: error: unsupported subtraction of qualified symbol
 // CHECK-ERROR: 5:9: error: unsupported pc-relative relocation of difference
 // CHECK-ERROR: 6:9: error: unsupported relocation with identical base
-// CHECK-ERROR: 7:9: error: unsupported relocation with subtraction expression, symbol 'thing' can not be undefined in a subtraction expression
+// CHECK-ERROR: 7:9: error: unsupported relocation with subtraction expression, symbol 'thing2' can not be undefined in a subtraction expression
 // CHECK-ERROR: 8:9: error: unsupported symbol modifier in relocation
 // CHECK-ERROR: 9:9: error: unsupported symbol modifier in branch relocation
 // CHECK-ERROR: 10:9: error: TLVP symbol modifier should have been rip-rel