[lld-macho][nfc] Add more tests + comments around ICF + unwind info interaction

[int3]

Summary

While working on D129830: [lld-macho] Support folding of functions with identical LSDAs, I realized that our handling of ICF +
eh_frame combined was untested. Additionally I realized that the comment
explaining why we were safely slicing away the functionAddress reloc
from our compact unwind entries was... insufficient and slightly
misleading. I've tried to clarify it.

[int3]

tweak comment

lld/MachO/InputFiles.cpp

for (auto it = isec->relocs.begin(); it != isec->relocs.end();) {
       // However, unwind info operates on a per-symbol basis, so we search for
       // the function symbol here.
       Defined *d = findSymbolAtOffset(referentIsec, add);
       if (!d) {
         ++it;
         continue;
       }
       d->unwindEntry = isec;
-      // Since we've sliced away the functionAddress, we should remove the
-      // corresponding relocation too. Given that clang emits relocations in
-      // reverse order of address, this relocation should be at the end of the
-      // vector for most of our input object files, so this is typically an O(1)
-      // operation.
+      // Now that the symbol points to the unwind entry, we can remove the reloc
+      // that points from the unwind entry back to the symbol.
+      //
+      // First, the symbol keeps the unwind entry alive (and not vice versa), so
+      // this keeps dead-stripping simple.
+      //
+      // Moreover, it reduces the work that ICF needs to do to figure out if
+      // functions with unwind info are foldable.
+      //
+      // However, this does make it possible for ICF to fold CUEs that point to
+      // distinct functions (if the CUEs are otherwise identical).
+      // UnwindInfoSection takes care of this by re-duplicating the CUEs so that
+      // each one can hold a distinct functionAddress value.
+      //
+      // Given that clang emits relocations in reverse order of address, this
+      // relocation should be at the end of the vector for most of our input
+      // object files, so this erase() is typically an O(1) operation.
       it = isec->relocs.erase(it);
     }
   }
 }
 
 struct CIE {
   macho::Symbol *personalitySymbol = nullptr;
   bool fdesHaveLsda = false;

lld/test/MachO/icf.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 
 ## Check that we fold identical function bodies correctly. Note: This test
 ## has many different functions; each group of similarly-named functions aim
 ## to test one aspect of ICF's logic. To prevent accidental folding across
 ## groups, we use `mov` instructions with a variety of immediates, with
 ## different immediate values for each group.
 
 # 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
+# RUN: llvm-objdump -d --syms --dwarf=frames %t/main | FileCheck %s
 
 # CHECK-LABEL: SYMBOL TABLE:
 # CHECK: [[#%x,ABS1B_REF:]]                 l     F __TEXT,__text _abs1a_ref
 # CHECK: [[#%x,ABS1B_REF]]                  l     F __TEXT,__text _abs1b_ref
 # CHECK: [[#%x,ABS1B_REF_WITH_ADDEND:]]     l     F __TEXT,__text _abs1a_ref_with_addend
 # CHECK: [[#%x,ABS1B_REF_WITH_ADDEND]]      l     F __TEXT,__text _abs1b_ref_with_addend
 # CHECK: [[#%x,ABS2_REF:]]                  l     F __TEXT,__text _abs2_ref
 # CHECK: [[#%x,NOT_ABS_REF:]]               l     F __TEXT,__text _not_abs_ref

 # CHECK: [[#%x,RECURSIVE:]]                 l     F __TEXT,__text _recursive
 # CHECK: [[#%x,CALL_RECURSIVE_2:]]          l     F __TEXT,__text _call_recursive_1
 # CHECK: [[#%x,CALL_RECURSIVE_2]]           l     F __TEXT,__text _call_recursive_2
 # CHECK: [[#%x,CHECK_LENGTH_1:]]            l     F __TEXT,__text _check_length_1
 # CHECK: [[#%x,CHECK_LENGTH_2:]]            l     F __TEXT,__text _check_length_2
 # CHECK: [[#%x,HAS_UNWIND_2:]]              l     F __TEXT,__text _has_unwind_1
 # CHECK: [[#%x,HAS_UNWIND_2]]               l     F __TEXT,__text _has_unwind_2
 # CHECK: [[#%x,HAS_UNWIND_3:]]              l     F __TEXT,__text _has_unwind_3
+# CHECK: [[#%x,HAS_EH_FRAME_1:]]            l     F __TEXT,__text _has_eh_frame_1
+# CHECK: [[#%x,HAS_EH_FRAME_2:]]            l     F __TEXT,__text _has_eh_frame_2
+# CHECK: [[#%x,HAS_EH_FRAME_3:]]            l     F __TEXT,__text _has_eh_frame_3
 # CHECK: [[#%x,MUTALLY_RECURSIVE_2:]]       l     F __TEXT,__text _mutually_recursive_1
 # CHECK: [[#%x,MUTALLY_RECURSIVE_2]]        l     F __TEXT,__text _mutually_recursive_2
 # CHECK: [[#%x,INIT_2:]]                    l     F __TEXT,__text _init_1
 # CHECK: [[#%x,INIT_2]]                     l     F __TEXT,__text _init_2
 # CHECK: [[#%x,INIT_3:]]                    l     O __TEXT,__foo  _init_3
 ### FIXME: Mutually-recursive functions with identical bodies (see below)
 # COM:   [[#%x,ASYMMETRIC_RECURSIVE_2:]]    l   F __TEXT,__text _asymmetric_recursive_1
 # COM:   [[#%x,ASYMMETRIC_RECURSIVE_2]]     l   F __TEXT,__text _asymmetric_recursive_2
 
+## Check that we don't accidentally dedup distinct EH frames.
+# CHECK: FDE {{.*}} pc=[[#%x,HAS_EH_FRAME_1]]
+# CHECK: FDE {{.*}} pc=[[#%x,HAS_EH_FRAME_2]]
+# CHECK: FDE {{.*}} pc=[[#%x,HAS_EH_FRAME_3]]
+
 # CHECK-LABEL: Disassembly of section __TEXT,__text:
 # CHECK:        <_main>:
 # CHECK: callq 0x[[#%x,ABS1B_REF]]                 <_abs1b_ref>
 # CHECK: callq 0x[[#%x,ABS1B_REF]]                 <_abs1b_ref>
 # CHECK: callq 0x[[#%x,ABS1B_REF_WITH_ADDEND]]     <_abs1b_ref_with_addend>
 # CHECK: callq 0x[[#%x,ABS1B_REF_WITH_ADDEND]]     <_abs1b_ref_with_addend>
 # CHECK: callq 0x[[#%x,ABS2_REF]]                  <_abs2_ref>
 # CHECK: callq 0x[[#%x,NOT_ABS_REF]]               <_not_abs_ref>

 # CHECK: callq 0x[[#%x,RECURSIVE]]                 <_recursive>
 # CHECK: callq 0x[[#%x,CALL_RECURSIVE_2]]          <_call_recursive_2>
 # CHECK: callq 0x[[#%x,CALL_RECURSIVE_2]]          <_call_recursive_2>
 # CHECK: callq 0x[[#%x,CHECK_LENGTH_1]]            <_check_length_1>
 # CHECK: callq 0x[[#%x,CHECK_LENGTH_2]]            <_check_length_2>
 # CHECK: callq 0x[[#%x,HAS_UNWIND_2]]              <_has_unwind_2>
 # CHECK: callq 0x[[#%x,HAS_UNWIND_2]]              <_has_unwind_2>
 # CHECK: callq 0x[[#%x,HAS_UNWIND_3]]              <_has_unwind_3>
+# CHECK: callq 0x[[#%x,HAS_EH_FRAME_1]]            <_has_eh_frame_1>
+# CHECK: callq 0x[[#%x,HAS_EH_FRAME_2]]            <_has_eh_frame_2>
+# CHECK: callq 0x[[#%x,HAS_EH_FRAME_3]]            <_has_eh_frame_3>
 # CHECK: callq 0x[[#%x,MUTALLY_RECURSIVE_2]]       <_mutually_recursive_2>
 # CHECK: callq 0x[[#%x,MUTALLY_RECURSIVE_2]]       <_mutually_recursive_2>
 ## FIXME Mutually-recursive functions with identical bodies (see below)
 # COM:   callq 0x[[#%x,ASYMMETRIC_RECURSIVE_2]]    <_asymmetric_recursive_2>
 # COM:   callq 0x[[#%x,ASYMMETRIC_RECURSIVE_2]]    <_asymmetric_recursive_2>
 # CHECK: callq 0x[[#%x,INIT_2]]                    <_init_2>
 # CHECK: callq 0x[[#%x,INIT_2]]                    <_init_2>
 # CHECK: callq 0x[[#%x,INIT_3]]                    <_init_3>

 ## should not be folded.
 _has_unwind_3:
   .cfi_startproc
   .cfi_personality 155, _my_personality
   .cfi_def_cfa_offset 8
   ret
   .cfi_endproc
 
+## In theory _has_eh_frame_{1, 2} can be dedup'ed, but we don't support this
+## yet.
+_has_eh_frame_1:
+  .cfi_startproc
+  .cfi_def_cfa_offset 8
+  ## cfi_escape cannot be encoded in compact unwind
+  .cfi_escape 0x2e, 0x10
+  ret
+  .cfi_endproc
+
+_has_eh_frame_2:
+  .cfi_startproc
+  .cfi_def_cfa_offset 8
+  ## cfi_escape cannot be encoded in compact unwind
+  .cfi_escape 0x2e, 0x10
+  ret
+  .cfi_endproc
+
+## The nop in this function body means that it cannot be folded with the
+## previous two, even though the unwind info is otherwise identical.
+_has_eh_frame_3:
+  .cfi_startproc
+  .cfi_def_cfa_offset 8
+  ## cfi_escape cannot be encoded in compact unwind
+  .cfi_escape 0x2e, 0x10
+  nop
+  ret
+  .cfi_endproc
+
 ## Fold: Mutually-recursive functions with symmetric bodies
 _mutually_recursive_1:
   callq _mutually_recursive_1 # call myself
   callq _mutually_recursive_2 # call my twin
 
 _mutually_recursive_2:
   callq _mutually_recursive_2 # call myself
   callq _mutually_recursive_1 # call my twin
_main:
   callq _recursive
   callq _call_recursive_1
   callq _call_recursive_2
   callq _check_length_1
   callq _check_length_2
   callq _has_unwind_1
   callq _has_unwind_2
   callq _has_unwind_3
+  callq _has_eh_frame_1
+  callq _has_eh_frame_2
+  callq _has_eh_frame_3
   callq _mutually_recursive_1
   callq _mutually_recursive_2
   callq _asymmetric_recursive_1
   callq _asymmetric_recursive_2
   callq _init_1
   callq _init_2
   callq _init_3