[LLD][ARM] Garbage collection support for .ARM.exidx sections

[peter.smith]

Summary

The .ARM.exidx sections have a reverse dependency on the InputSections that they have a link order dependency to. In effect they should be live only if the InputSection they refer to via the sh_link field is live.

I've used a single pointer to InputSection rather than a vector as there is an InputSection can only have at most one InputSection (.ARM.exidx) with a SHF_LINK_ORDER dependency on it.

This has been split off from https://reviews.llvm.org/D25127 which contains the basic .ARM.exidx recognition and sorting. It implements Rui's suggestion of adding the reverse dependency to InputSections.

The lld changes don't depend on D25127 but the test case may do as it checks the contents of the .ARM.exidx section.

[ruiu]

ELF/InputFiles.cpp

259

Can you make this a separate function, say, initializeARMLinkOrderSection, and call it from ObjectFile::parse?

Please do this only when Config->GcSections is true.

ELF/InputSection.h

232

Variable names should start with uppercase letters.

Is it guaranteed that a section has at most one corresponding .ARM.exidx section?

test/ELF/arm-exidx-gc.s

13

I don't know much about ARM assembly, but do you actually need this amount of assembly code to test your feature?

[peter.smith]

Thanks for the comments. I've made the suggested review changes.

Yes it is guaranteed that there is a 1:1 mapping between a .ARM.exidx section and an executable section. It is stated in the exceptions spec[*] and if it weren't true then SHF_LINK_ORDER couldn't work reliably.

I've cut the assembly down a bit in the test. The difficulty often isn't the ARM assembly, it is provoking the assembler to generate the necessary exception tables. For example .cantunwind and .handlerdata need .fnstart and .fnend to be accepted.

• 4.4 The object producer interface (http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf)

An object producer must generate:

• One fragment of index table for each code section.
• One exception-handling table entry corresponding to each function that may need to be unwound.

Each fragment of index table (read-only data) must be generated in its own ELF section. It must contain an index entry for each non-leaf function in the associated code section, in the same order as that of the functions in the code section. The index table section name must be .ARM.exidx optionally followed by further characters. The section type must be SHT_ARM_EXIDX (see [AAELF]). It must have the SHF_LINK_ORDER flag set in the sh_flags field of its section header and be linked to its associated code section via the sh_link field of its section header.

[ruiu]

LGTM

ELF/InputFiles.cpp

148

clang-format-diff please.

287

Reverse the condition and continue earlier.

291

It is not expected to fail, so dyn_cast -> cast.

[• rafael]

Why do you need to store the dependency?

It seem that you should be able to just run mark sections live normally and then do one last pass over the sections. Any SHF_LINK_ORDER pointer to a live section makes the current one live too.

[peter.smith]

The initial patch did start that way. The SHF_LINK_ORDER sections that become live may make other sections that have further SHF_LINK_ORDER dependencies live so it ends up needing to converge. The move to adding the reverse dependency came from an earlier review comment.

I'll try and see what impact the extra field in InputSection has in terms of performance. I've not got a setup for benchmarking right now but I'll take a look at setting one up.

Another possibility is to store the reverse dependency in a map so that only the ARM Target pays the performance cost.

[ruiu]

We need to store reverse edges somewhere. It doesn't have to be InputSection, but I think this is a good place to add them.

[peter.smith]

Committed revision 283734 with Rui's final suggestions above.

ELF/InputFiles.cpp

template <class ELFT> uint32_t elf::ObjectFile<ELFT>::getMipsGp0() const {
   return 0;
 }
 
 template <class ELFT>
 void elf::ObjectFile<ELFT>::parse(DenseSet<StringRef> &ComdatGroups) {
   // Read section and symbol tables.
   initializeSections(ComdatGroups);
   initializeSymbols();
 }
 
 // Sections with SHT_GROUP and comdat bits define comdat section groups.
 // They are identified and deduplicated by group name. This function
 // returns a group name.
 template <class ELFT>
 StringRef elf::ObjectFile<ELFT>::getShtGroupSignature(const Elf_Shdr &Sec) {
   const ELFFile<ELFT> &Obj = this->ELFObj;
   const Elf_Shdr *Symtab = check(Obj.getSection(Sec.sh_link));
case SHT_SYMTAB_SHNDX:
       break;
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     default:
       Sections[I] = createInputSection(Sec);
     }
   }
+  // .ARM.exidx sections have a reverse dependency on the InputSection they
+  // have a SHF_LINK_ORDER dependency, this is identified by the sh_link.
+  if (Config->EMachine == EM_ARM) {
+    I = -1;
+    for (const Elf_Shdr &Sec : Obj.sections()) {
+      ++I;
+      if (Sections[I] == &InputSection<ELFT>::Discarded)
+        continue;
+      if (Sec.sh_flags & SHF_LINK_ORDER) {
+        if (Sec.sh_link >= Sections.size())
+          fatal(getFilename(this) + ": invalid sh_link index: " +
+                Twine(Sec.sh_link));
+        auto *IS = dyn_cast<InputSection<ELFT>>(Sections[Sec.sh_link]);
+        IS->dependentSection = Sections[I];
+      }
+    }
+  }
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
   uint32_t Idx = Sec.sh_info;
   if (Idx >= Sections.size())
     fatal(getFilename(this) + ": invalid relocated section index: " +
           Twine(Idx));
   InputSectionBase<ELFT> *Target = Sections[Idx];
 
   // Strictly speaking, a relocation section must be included in the
   // group of the section it relocates. However, LLVM 3.3 and earlier
   // would fail to do so, so we gracefully handle that case.
   if (Target == &InputSection<ELFT>::Discarded)
     return nullptr;
 
   if (!Target)
     fatal(getFilename(this) + ": unsupported relocation reference");
   return Target;
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *

ELF/InputSection.h

public:
 
   // Relocation sections that refer to this one.
   llvm::TinyPtrVector<const Elf_Shdr *> RelocSections;
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
+  // InputSection that is dependent on us (reverse dependency for GC)
+  InputSectionBase<ELFT> *dependentSection = nullptr;
+
   static bool classof(const InputSectionBase<ELFT> *S);
 
   InputSectionBase<ELFT> *getRelocatedSection();
 
   // Register thunk related to the symbol. When the section is written
   // to a mmap'ed file, target is requested to write an actual thunk code.
   // Now thunks is supported for MIPS and ARM target only.
   void addThunk(const Thunk<ELFT> *T);

ELF/MarkLive.cpp

for (const typename ELFT::Shdr *RelSec : Sec.RelocSections) {
     if (RelSec->sh_type == SHT_RELA) {
       for (const typename ELFT::Rela &Rel : Obj.relas(RelSec))
         Fn(resolveReloc(Sec, Rel));
     } else {
       for (const typename ELFT::Rel &Rel : Obj.rels(RelSec))
         Fn(resolveReloc(Sec, Rel));
     }
   }
+  if (Sec.dependentSection)
+    Fn({Sec.dependentSection, 0});
 }
 
 // The .eh_frame section is an unfortunate special case.
 // The section is divided in CIEs and FDEs and the relocations it can have are
 // * CIEs can refer to a personality function.
 // * FDEs can refer to a LSDA
 // * FDEs refer to the function they contain information about
 // The last kind of relocation cannot keep the referred section alive, or they

test/ELF/arm-exidx-gc.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
+// RUN: ld.lld %t -o %t2 --gc-sections 2>&1
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck %s
+// RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-EXIDX %s
+// REQUIRES: arm
+
+// Test the behavior of .ARM.exidx sections under garbage collection
+// A .ARM.exidx section is live if it has a relocation to a live executable
+// section.
+// A .ARM.exidx section may have a relocation to a .ARM.extab section, if the
+// .ARM.exidx is live then the .ARM.extab section is live
+
+ .syntax unified
+ .section .text.func1, "ax",%progbits
+ .align 2
+ .global func1
+ .type func1, %function
+func1:
+ .fnstart
+ bx lr
+ .save {r7, lr}
+ .setfp r7, sp, #0
+ .fnend
+
+ .section .text.unusedfunc1, "ax",%progbits
+ .align 2
+ .global unusedfunc1
+ .type unusedfunc1, %function
+unusedfunc1:
+ .fnstart
+ bx lr
+ .save {r7, lr}
+ .setfp r7, sp, #0
+ .fnend
+
+ // Unwinding instructions for .text2 too large for an inline entry ARM.exidx
+ // entry. A separate .ARM.extab section is created to hold the unwind entries
+ // The .ARM.exidx table entry has a reference to the .ARM.extab section.
+ .section .text.func2, "ax",%progbits
+ .align 2
+ .global func2
+ .type func2, %function
+func2:
+ .fnstart
+ .save {r7, lr}
+ .setfp r7, sp
+ bx lr
+ .personality __gxx_personality_v0
+ .handlerdata
+ .align 2
+ .byte 0xff
+ .byte 0x90
+ .uleb128 0x16
+ .byte 0x1
+ .uleb128 0x32
+ .uleb128 0
+ .byte 0x1
+ .byte 0
+ .section .text.func2
+ .fnend
+
+ // An unused function with a reference to a .ARM.extab section. Both should
+ // be removed by gc.
+ .section .text.unusedfunc2, "ax",%progbits
+ .align 2
+ .global unusedfunc2
+ .type unusedfunc2, %function
+unusedfunc2:
+ .fnstart
+ .save {r7, lr}
+ .setfp r7, sp
+ bx lr
+ .personality __gxx_personality_v0
+ .handlerdata
+ .align 2
+ .byte 0xff
+ .byte 0x90
+ .uleb128 0x16
+ .byte 0x1
+ .uleb128 0x32
+ .uleb128 0
+ .byte 0x1
+ .byte 0
+ .section .text.unusedfunc2
+ .fnend
+
+ // Dummy implementation of personality routines to satisfy reference from
+ // exception tables
+ .section .text.__gcc_personality_v0, "ax", %progbits
+ .global __gxx_personality_v0
+ .type __gxx_personality_v0, %function
+__gxx_personality_v0:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text.__aeabi_unwind_cpp_pr0, "ax", %progbits
+ .global __aeabi_unwind_cpp_pr0
+ .type __aeabi_unwind_cpp_pr0, %function
+__aeabi_unwind_cpp_pr0:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .text
+ .global _start
+ .type _start, %function
+_start:
+ .fnstart
+ .cantunwind
+ bl func1
+ bl func2
+ bx lr
+ .fnend
+
+// GC should have only removed unusedfunc1 and unusedfunc2 the personality
+// routines are kept alive by references from live .ARM.exidx and .ARM.extab
+// sections
+// CHECK: Disassembly of section .text:
+// CHECK-NEXT: _start:
+// CHECK-NEXT:   11000:       01 00 00 eb     bl      #4 <func1>
+// CHECK-NEXT:   11004:       01 00 00 eb     bl      #4 <func2>
+// CHECK-NEXT:   11008:       1e ff 2f e1     bx      lr
+// CHECK: func1:
+// CHECK-NEXT:   1100c:       1e ff 2f e1     bx      lr
+// CHECK: func2:
+// CHECK-NEXT:   11010:       1e ff 2f e1     bx      lr
+// CHECK: __gxx_personality_v0:
+// CHECK-NEXT:   11014:       1e ff 2f e1     bx      lr
+// CHECK: __aeabi_unwind_cpp_pr0:
+// CHECK-NEXT:   11018:       1e ff 2f e1     bx      lr
+
+// CHECK-NOT: unusedfunc1
+// CHECK-NOT: unusedfunc2
+
+// GC should have removed table entries for unusedfunc1 and unusedfunc2
+// CHECK-EXIDX: Contents of section .ARM.exidx:
+// 100d4 + f2c = 11000 = _start (cantunwind)
+// 100dc + f30 = 1100c = func1 (Inline unwind 80978408)
+// CHECK-EXIDX-NEXT: 100d4 2c0f0000 01000000 300f0000 08849780
+// 100e4 + f2c = 11010 = func2 (100e8 + 14 = 100fc = extab entry for func2)
+// 100ec + f28 = 11014 = __gxx_personality_v0
+// CHECK-EXIDX-NEXT: 100e4 2c0f0000 14000000 280f0000 01000000
+// 100f4 + f24 = 11018 = __aeabi_unwind_cpp_pr0
+// CHECK-EXIDX-NEXT: 100f4 240f0000 01000000
+
+
+// CHECK-EXIDX: Contents of section .ARM.extab.text.func2:
+// 100fc + f18 = 11018 = __aeabi_unwind_cpp_pr0 (cantunwind)
+// CHECK-EXIDX-NEXT: 100fc 180f0000 08849700 ff901601 32000100
+// CHECK-EXIDX-NOT: Contents of section .ARM.extab.text.unusedfunc2: