[lld/mac] Add explicit "no unwind info" entries for functions without unwind info

[thakis]

Summary

Fixes PR50529. With this, lld-linked Chromium base_unittests passes on arm macs.

Surprisingly, no measurable impact on link time.

[thakis]

upload correct diff

[thakis]

clang-format

[thakis]

more explicit test (_quux behavior matches ld64)

[int3]

Thanks!

lld/MachO/UnwindInfoSection.cpp

284

worth adding a comment about why we need this

300–302

I think this might not be necessary given that as far as code section symbols go, all of them can be found as we loop over in objFile->symbols below (supposing we remove the !isExternal() check). I think the SymtabSection loops over the symbol table only to ensure we emit the synthetic symbols

[thakis]

Thanks!

lld/MachO/UnwindInfoSection.cpp

300–302

It's also so we don't emit weak symbols that are in many files more than once. We already dedup'd them via the symbol table, might as well re-use that work.

lld/MachO/UnwindInfoSection.cpp

for (const Reloc &r : isec->relocs) {
       writeAddress(buf + r.offset, referentVA, r.length);
     }
   }
 }
 
 // There should only be a handful of unique personality pointers, so we can
 // encode them as 2-bit indices into a small array.
 template <class Ptr>
-void encodePersonalities(
-    const std::vector<CompactUnwindEntry<Ptr> *> &cuPtrVector,
+static void
+encodePersonalities(const std::vector<CompactUnwindEntry<Ptr> *> &cuPtrVector,
                     std::vector<uint32_t> &personalities) {
   for (CompactUnwindEntry<Ptr> *cu : cuPtrVector) {
     if (cu->personality == 0)
       continue;
     // Linear search is fast enough for a small array.
     auto it = find(personalities, cu->personality);
     uint32_t personalityIndex; // 1-based index
     if (it != personalities.end()) {
       personalityIndex = std::distance(personalities.begin(), it) + 1;
     } else {
       personalities.push_back(cu->personality);
       personalityIndex = personalities.size();
     }
     cu->encoding |=
         personalityIndex << countTrailingZeros(
             static_cast<compact_unwind_encoding_t>(UNWIND_PERSONALITY_MASK));
   }
   if (personalities.size() > 3)
     error("too many personalities (" + std::to_string(personalities.size()) +
           ") for compact unwind to encode");
 }
 
+template <class Ptr>
+static void addEntriesForFunctionsWithoutUnwindInfo(
+    std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
+  DenseSet<Ptr> hasUnwindInfo;
+  for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
+    if (cuEntry.functionAddress != UINT64_MAX)
+      hasUnwindInfo.insert(cuEntry.functionAddress);
+
+  // Add explicit "has no unwind info" entries for all global and local symbols
+  // without unwind info.
+  auto markNoUnwindInfo = [&cuVector, &hasUnwindInfo](const Defined *d) {
+    if (d->isLive() && isCodeSection(d->isec)) {
+      Ptr ptr = d->getVA();
+      if (!hasUnwindInfo.count(ptr))
+        cuVector.push_back({ptr, 0, 0, 0, 0});
+    }
+  };
+  for (Symbol *sym : symtab->getSymbols())
+    if (auto *d = dyn_cast<Defined>(sym))
+      markNoUnwindInfo(d);
+  for (const InputFile *file : inputFiles)
+    if (auto *objFile = dyn_cast<ObjFile>(file))
+      for (Symbol *sym : objFile->symbols)
+        if (auto *d = dyn_cast_or_null<Defined>(sym))
+          if (!d->isExternal())
+            markNoUnwindInfo(d);
+}
+
 // Scan the __LD,__compact_unwind entries and compute the space needs of
 // __TEXT,__unwind_info and __TEXT,__eh_frame
 template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
   if (compactUnwindSection == nullptr)
     return;
 
   // At this point, the address space for __TEXT,__text has been
   // assigned, so we can relocate the __LD,__compact_unwind entries
   // into a temporary buffer. Relocation is necessary in order to sort
   // the CU entries by function address. Sorting is necessary so that
   // we can fold adjacent CU entries with identical
   // encoding+personality+lsda. Folding is necessary because it reduces
   // the number of CU entries by as much as 3 orders of magnitude!
   compactUnwindSection->finalize();
   assert(compactUnwindSection->getSize() % sizeof(CompactUnwindEntry<Ptr>) ==
          0);
   size_t cuCount =
       compactUnwindSection->getSize() / sizeof(CompactUnwindEntry<Ptr>);
   cuVector.resize(cuCount);
   relocateCompactUnwind(compactUnwindSection, cuVector);
 
+  addEntriesForFunctionsWithoutUnwindInfo(cuVector);
+
   // Rather than sort & fold the 32-byte entries directly, we create a
   // vector of pointers to entries and sort & fold that instead.
   cuPtrVector.reserve(cuCount);
   for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
     cuPtrVector.emplace_back(&cuEntry);
   llvm::sort(cuPtrVector, [](const CompactUnwindEntry<Ptr> *a,
                              const CompactUnwindEntry<Ptr> *b) {
     return a->functionAddress < b->functionAddress;

lld/test/MachO/compact-unwind.s

 
 # SECOND:      Indirect symbols for (__DATA_CONST,__got)
 # SECOND-NEXT: address                    index name
 # SECOND-DAG:  0x[[#%x,GXX_PERSONALITY:]] [[#]] ___gxx_personality_v0
 # SECOND-DAG:  0x[[#%x,MY_PERSONALITY:]]  [[#]] _my_personality
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-DAG:  [[#%x,MAIN:]]       g  F __TEXT,__text _main
+# CHECK-DAG:  [[#%x,QUUX:]]       g  F __TEXT,__text _quux
 # CHECK-DAG:  [[#%x,FOO:]]        l  F __TEXT,__text _foo
+# CHECK-DAG:  [[#%x,BAZ:]]        l  F __TEXT,__text _baz
 # CHECK-DAG:  [[#%x,EXCEPTION0:]] g  O __TEXT,__gcc_except_tab _exception0
 # CHECK-DAG:  [[#%x,EXCEPTION1:]] g  O __TEXT,__gcc_except_tab _exception1
 
 # CHECK:      Contents of __unwind_info section:
 # CHECK:        Personality functions: (count = 2)
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#MY_PERSONALITY-BASE]]
 # CHECK-DAG:     personality[{{[0-9]+}}]: 0x{{0*}}[[#GXX_PERSONALITY-BASE]]
 # CHECK:        LSDA descriptors:
 # CHECK-DAG:     function offset=0x[[#%.8x,FOO-BASE]],  LSDA offset=0x[[#%.8x,EXCEPTION0-BASE]]
 # CHECK-DAG:     function offset=0x[[#%.8x,MAIN-BASE]], LSDA offset=0x[[#%.8x,EXCEPTION1-BASE]]
+# CHECK:        Second level indices:
+# CHECK-DAG:     function offset=0x[[#%.8x,MAIN-BASE]], encoding
+# CHECK-DAG:     function offset=0x[[#%.8x,FOO-BASE]], encoding
+# CHECK-DAG:     function offset=0x[[#%.8x,BAZ-BASE]], encoding
+# CHECK-DAG:     function offset=0x[[#%.8x,QUUX-BASE]], encoding{{.*}}=0x00000000
 
 ## Check that we do not add rebase opcodes to the compact unwind section.
 # CHECK:      Rebase table:
 # CHECK-NEXT: segment      section        address          type
 # CHECK-NEXT: __DATA_CONST __got          0x{{[0-9A-F]*}}  pointer
 # CHECK-NOT:  __TEXT
 
 #--- my-personality.s

 _my_personality:
   ret
 
 .section __TEXT,__gcc_except_tab
 _exception0:
   .space 1
 
 #--- main.s
-.globl _main, _my_personality, _exception1
+.globl _main, _quux, _my_personality, _exception1
 
 .text
 .p2align 2
 _main:
   .cfi_startproc
   .cfi_personality 155, ___gxx_personality_v0
   .cfi_lsda 16, _exception1
   .cfi_def_cfa_offset 16
   ret
   .cfi_endproc
 
+## _quux has no unwind information.
+## (In real life, it'd be part of a separate TU that was built with
+## -fno-exceptions, while the previous and next TU might be Objective-C++
+## which has unwind info for Objective-C).
+.p2align 2
+_quux:
+  ret
+
 .p2align 2
 _baz:
   .cfi_startproc
 ## This will generate a symbol relocation. Check that we reuse the personality
 ## referenced by the section relocation in my_personality.s.
   .cfi_personality 155, _my_personality
   .cfi_lsda 16, _exception1
   .cfi_def_cfa_offset 16
   ret
   .cfi_endproc
 
 
 .section __TEXT,__gcc_except_tab
 _exception1:
   .space 1

lld/test/MachO/tools/validate-unwind-info.py

re.findall(r"start:\s+0x%s+\s+(\w+)\s+" % hex +
                r"personality function:\s+0x(%s+)\s+\w+\s+" % hex +
                r"LSDA:\s+0x(%s+)\s+\w+(?: \+ 0x%s+)?)?" % (hex, hex),
                objdump_string, re.DOTALL)]
   object_encodings_map = {symbol:encoding
     for symbol, encoding, _, _ in object_encodings_list}
   if not object_encodings_map:
     sys.exit("no object encodings found in input")
 
+  # generate-cfi-funcs.py doesn't generate unwind info for _main.
+  object_encodings_map['_main'] = '00000000'
+
   program_symbols_map = {address:symbol
     for address, symbol in
-    re.findall(r"^%s(%s) g\s+F __TEXT,__text (x\1)$" % (hex8, hex8),
+    re.findall(r"^%s(%s) g\s+F __TEXT,__text (x\1|_main)$" % (hex8, hex8),
                objdump_string, re.MULTILINE)}
   if not program_symbols_map:
     sys.exit("no program symbols found in input")
 
   program_common_encodings = (
     re.findall(r"^\s+encoding\[(?:\d|\d\d|1[01]\d|12[0-6])\]: 0x(%s+)$" % hex,
                objdump_string, re.MULTILINE))
   if not program_common_encodings: