[lld-macho][nfc] Add absolute-vs-non-absolute symbol test for ICF

[int3]

Summary

Make sure we don't wrongly fold two sections that refer to
symbols with the same value if they are not both absolute /
non-absolute.

[gkm]

LGTM!

lld/test/MachO/icf.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/main.s -o %t/main.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin19.0.0 %t/abs.s -o %t/abs.o
 # RUN: %lld -lSystem --icf=all -o %t/main %t/main.o %t/abs.o
 # RUN: llvm-objdump -d --syms %t/main | FileCheck %s
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK:       [[#%x,MAIN:]] g   F __TEXT,__text _main
 # CHECK:       [[#%x,A:]]    g   F __TEXT,__text _a1
 # CHECK:       [[#%x,H:]]    g   F __TEXT,__text _h
 # CHECK:       [[#%x,A]]     g   F __TEXT,__text _a2
 # CHECK:       [[#%x,A]]     g   F __TEXT,__text _a3
 # CHECK:       [[#%x,B:]]    g   F __TEXT,__text _b
+# CHECK:       [[#%x,B2:]]   g   F __TEXT,__text _b2
 # CHECK:       [[#%x,C:]]    g   F __TEXT,__text _c
 # CHECK:       [[#%x,D:]]    g   F __TEXT,__text _d
 # CHECK:       [[#%x,E:]]    g   F __TEXT,__text _e
 # CHECK:       [[#%x,F:]]    g   F __TEXT,__text _f
 # CHECK:       [[#%x,G:]]    g   F __TEXT,__text _g
 # CHECK:       [[#%x,I:]]    g   F __TEXT,__text _i
 # CHECK:       [[#%x,J:]]    g   F __TEXT,__text _j
 # CHECK:       [[#%x,SR:]]   g   F __TEXT,__text _sr1
 # CHECK:       [[#%x,SR]]    g   F __TEXT,__text _sr2
 # CHECK:       [[#%x,MR:]]   g   F __TEXT,__text _mr1
 # CHECK:       [[#%x,MR]]    g   F __TEXT,__text _mr2
 ### FIXME: Mutually-recursive functions with identical bodies (see below)
 # COM:         [[#%x,XR:]]   g   F __TEXT,__text _xr1
 # COM:         [[#%x,XR]]    g   F __TEXT,__text _xr2
 
 # CHECK-LABEL: Disassembly of section __TEXT,__text:
 # CHECK:       [[#%x,MAIN]] <_main>:
 # CHECK-NEXT:  callq 0x[[#%x,A]]  <_a3>
 # CHECK-NEXT:  callq 0x[[#%x,A]]  <_a3>
 # CHECK-NEXT:  callq 0x[[#%x,A]]  <_a3>
 # CHECK-NEXT:  callq 0x[[#%x,B]]  <_b>
+# CHECK-NEXT:  callq 0x[[#%x,B2]] <_b2>
 # CHECK-NEXT:  callq 0x[[#%x,C]]  <_c>
 # CHECK-NEXT:  callq 0x[[#%x,D]]  <_d>
 # CHECK-NEXT:  callq 0x[[#%x,E]]  <_e>
 # CHECK-NEXT:  callq 0x[[#%x,F]]  <_f>
 # CHECK-NEXT:  callq 0x[[#%x,G]]  <_g>
 # CHECK-NEXT:  callq 0x[[#%x,H]]  <_h>
 # CHECK-NEXT:  callq 0x[[#%x,I]]  <_i>
 # CHECK-NEXT:  callq 0x[[#%x,J]]  <_j>
 # CHECK-NEXT:  callq 0x[[#%x,SR]] <_sr2>
 # CHECK-NEXT:  callq 0x[[#%x,SR]] <_sr2>
 # CHECK-NEXT:  callq 0x[[#%x,MR]] <_mr2>
 # CHECK-NEXT:  callq 0x[[#%x,MR]] <_mr2>
 ### FIXME: Mutually-recursive functions with identical bodies (see below)
 # COM-NEXT:    callq 0x[[#%x,XR]] <_xr2>
 # COM-NEXT:    callq 0x[[#%x,XR]] <_xr2>
 
 ### TODO:
 ### * Fold: funcs only differ in alignment
 ### * No fold: func is weak? preemptable?
+### * Test that we hash things appropriately w/ minimal collisions
 
 #--- abs.s
 .subsections_via_symbols
 
-.globl _abs1a, _abs1b, _abs2
-_abs1a = 0xfeedfac3
-_abs1b = 0xfeedfac3
-_abs2 =  0xfeedf00d
+.globl _abs1a, _abs1b, _abs2, _not_abs
+_abs1a = 0xfac3
+_abs1b = 0xfac3
+_abs2 =  0xf00d
+
+.data
+.space 0xfac3
+## _not_abs has the same Defined::value as _abs1{a,b}
+_not_abs:
 
 #--- main.s
 .subsections_via_symbols
 .text
 .globl _h
 .alt_entry _h
 
 ### Fold: _a1 & _a2 have identical bodies, flags, relocs

 _b:
   callq _d
   mov ___nan@GOTPCREL(%rip), %rax
   callq ___isnan
   movabs $_abs2, %rdx
   movl $0, %eax
   ret
 
+### No fold: _not_abs has the same value as _abs1{a,b}, but is not absolute.
+
+.globl _b2
+.p2align 2
+_b2:
+  callq _d
+  mov ___nan@GOTPCREL(%rip), %rax
+  callq ___isnan
+  movabs $_not_abs, %rdx
+  movl $0, %eax
+  ret
+
 ### No fold: _c has slightly different body from _a1 & _a2
 
 .globl _c
 .p2align 2
 _c:
   callq _d
   mov ___nan@GOTPCREL(%rip), %rax
   callq ___isnan

 
 .globl _main
 .p2align 2
 _main:
   callq _a1
   callq _a2
   callq _a3
   callq _b
+  callq _b2
   callq _c
   callq _d
   callq _e
   callq _f
   callq _g
   callq _h
   callq _i
   callq _j