[lld-macho] Don't include zero-size private label symbols in map file

[int3]

Summary

This is also what ld64 does. This will make it easier to compare their
respective map files.

[int3]

add comments

[oontvoo]

Seems test failures are related :) PTAL

[int3]

Oh, I think I know what is happening -- this diff in my local repo is rebased upon D145455: [lld-macho] Coalesce local symbol aliases along with their aliased weak def, which switches up the order of the symbols. I will land them all EOW when I have had a chance to run benchmarks on the other diff

lld/MachO/InputFiles.cpp

if (isSubtrahend) {
             *sections[minuendInfo.r_symbolnum - 1], &referentOffset);
         p.addend = referentOffset;
       }
       subsec->relocs.push_back(p);
     }
   }
 }
 
-// Symbols with `l` or `L` as a prefix are linker-private and never appear in
-// the output.
-static bool isPrivateLabel(StringRef name) {
-  return name.startswith("l") || name.startswith("L");
-}
-
 template <class NList>
 static macho::Symbol *createDefined(const NList &sym, StringRef name,
                                     InputSection *isec, uint64_t value,
                                     uint64_t size, bool forceHidden) {
   // Symbol scope is determined by sym.n_type & (N_EXT | N_PEXT):
   // N_EXT: Global symbols. These go in the symbol table during the link,
   //        and also in the export table of the output so that the dynamic
   //        linker sees them.

lld/MachO/MapFile.cpp

void macho::writeMapFile() {
 
   os << "# Symbols:\n";
   os << "# Address\tSize    \tFile  Name\n";
   for (const OutputSegment *seg : outputSegments) {
     for (const OutputSection *osec : seg->getSections()) {
       if (auto *concatOsec = dyn_cast<ConcatOutputSection>(osec)) {
         for (const InputSection *isec : concatOsec->inputs) {
           for (Defined *sym : isec->symbols)
+            if (!(isPrivateLabel(sym->getName()) && sym->size == 0))
               os << format("0x%08llX\t0x%08llX\t[%3u] %s\n", sym->getVA(),
                            sym->size, readerToFileOrdinal[sym->getFile()],
                            sym->getName().str().data());
         }
       } else if (osec == in.cStringSection || osec == in.objcMethnameSection) {
         const auto &liveCStrings = info.liveCStringsForSection.lookup(osec);
         uint64_t lastAddr = 0; // strings will never start at address 0, so this
                                // is a sentinel value
         for (const auto &[addr, info] : liveCStrings) {
           uint64_t size = 0;
           if (addr != lastAddr)

lld/MachO/Symbols.h

 // Can a symbol's address only be resolved at runtime?
 inline bool needsBinding(const Symbol *sym) {
   if (isa<DylibSymbol>(sym))
     return true;
   if (const auto *defined = dyn_cast<Defined>(sym))
     return defined->isExternalWeakDef() || defined->interposable;
   return false;
 }
+
+// Symbols with `l` or `L` as a prefix are linker-private and never appear in
+// the output.
+inline bool isPrivateLabel(StringRef name) {
+  return name.startswith("l") || name.startswith("L");
+}
 } // namespace macho
 
 std::string toString(const macho::Symbol &);
 std::string toMachOString(const llvm::object::Archive::Symbol &);
 
 } // namespace lld
 
 #endif

lld/test/MachO/map-file.s

 ## Check that symbols in cstring sections aren't emitted
 ## Also check that we don't have redundant EH_Frame symbols (regression test)
 # RUN: cat %t/objdump %t/map | FileCheck %s --implicit-check-not _hello_world \
 # RUN:   --implicit-check-not EH_Frame
 # RUN: FileCheck %s --check-prefix=MAPFILE < %t/test.time-trace
 
 # CHECK:       Sections:
 # CHECK-NEXT:  Idx  Name         Size     VMA               Type
-# CHECK-NEXT:  0 __text          0000001b [[#%x,TEXT:]]     TEXT
+# CHECK-NEXT:  0 __text          0000001c [[#%x,TEXT:]]     TEXT
 # CHECK-NEXT:  1 __stubs         0000000c [[#%x,STUBS:]]    TEXT
 # CHECK-NEXT:  2 __stub_helper   0000001a [[#%x,HELPER:]]   TEXT
 # CHECK-NEXT:  3 __cstring       0000002b [[#%x,CSTR:]]     DATA
 # CHECK-NEXT:  4 __unwind_info   0000103c [[#%x,UNWIND:]]   DATA
 # CHECK-NEXT:  5 __eh_frame      00000038 [[#%x,EH_FRAME:]] DATA
 # CHECK-NEXT:  6 __got           00000010 [[#%x,GOT:]]      DATA
 # CHECK-NEXT:  7 __la_symbol_ptr 00000010 [[#%x,LAZY:]]     DATA
 # CHECK-NEXT:  8 __data          00000008 [[#%x,DATA:]]     DATA

 # CHECK-NEXT: 0x[[#%X,TLVP]]      0x{{[0-9A-F]+}} __DATA  __thread_ptrs
 # CHECK-NEXT: 0x[[#%X,BSS]]       0x{{[0-9A-F]+}} __DATA  __common
 
 # CHECK-NEXT: # Symbols:
 # CHECK-NEXT: # Address                Size        File   Name
 # CHECK-NEXT: 0x[[#%X,MAIN]]           0x00000019  [  2] _main
 # CHECK-NEXT: 0x[[#%X,BAR]]            0x00000001  [  2] _bar
 # CHECK-NEXT: 0x[[#%X,FOO]]            0x00000001  [  3] __ZTIN3foo3bar4MethE
+# CHECK-NEXT: 0x[[#%X,FOO+1]]          0x00000001  [  3] ltmp1
 # CHECK-NEXT: 0x[[#%X,STUBS]]          0x00000006  [  5] _baz
 # CHECK-NEXT: 0x[[#%X,STUBS+6]]        0x00000006  [  2] _bar
 # CHECK-NEXT: 0x[[#%X,HELPER]]         0x0000001A  [  0] helper helper
 # CHECK-NEXT: 0x[[#%X,HIWORLD]]        0x0000000E  [  4] literal string: Hello world!\n
 # CHECK-NEXT: 0x[[#%X,HIITSME]]        0x0000000F  [  4] literal string: Hello, it's me
 # CHECK-NEXT: 0x[[#%X,HIITSME+0xf]]    0x0000000E  [  4] literal string: Hello world!\n
 # CHECK-NEXT: 0x[[#%X,UNWIND]]         0x0000103C  [  0] compact unwind info
 ## Note: ld64 prints "CIE" and "FDE for: <function>" instead of "EH_Frame".
 # CHECK-NEXT: 0x[[#%X,EH_FRAME]]       0x00000018  [  2] EH_Frame
 # CHECK-NEXT: 0x[[#%X,EH_FRAME+0x18]]  0x00000020  [  2] EH_Frame
 # CHECK-NEXT: 0x[[#%X,GOT]]            0x00000008  [  0] non-lazy-pointer-to-local: _baz2
 # CHECK-NEXT: 0x[[#%X,GOT+8]]          0x00000008  [  0] non-lazy-pointer-to-local: dyld_stub_binder
 # CHECK-NEXT: 0x[[#%X,LAZY]]           0x00000008  [  5] _baz
 # CHECK-NEXT: 0x[[#%X,LAZY+8]]         0x00000008  [  2] _bar
 # CHECK-NEXT: 0x[[#%X,DYLD]]           0x00000000  [  0] __dyld_private
 # CHECK-NEXT: 0x[[#%X,TLVP]]           0x00000008  [  0] non-lazy-pointer-to-local: _baz_tlv
 # CHECK-NEXT: 0x[[#%X,BSS]]            0x00000001  [  2] _number
+# CHECK-EMPTY:
 
 # MAPFILE: "name":"Total Write map file"
 
 # RUN: %lld -demangle -dead_strip -map %t/stripped-map %t/test.o -force_load \
 # RUN:   %t/libfoo.a %t/c-string-literal.o %t/libbaz.dylib -o %t/stripped
 # RUN: FileCheck --check-prefix=STRIPPED %s < %t/stripped-map
 
 # STRIPPED-LABEL: Dead Stripped Symbols:

 # ICF:     Symbols:
 # ICF-DAG: 0x[[#%X,FOO:]]     0x00000000  [  3] __ZTIN3foo3bar4MethE
 # ICF-DAG: 0x[[#FOO]]         0x00000001  [  2] _bar
 # ICF-DAG: 0x[[#%X,HIWORLD:]] 0x0000000E  [  4]  literal string: Hello world!\n
 # ICF-DAG: 0x[[#%X,HIWORLD]]  0x00000000  [  4]  literal string: Hello world!\n
 
 #--- foo.s
 .globl __ZTIN3foo3bar4MethE
+## This should not appear in the map file since it is a zero-size private label
+## symbol.
+ltmp0:
 ## This C++ symbol makes it clear that we do not print the demangled name in
 ## the map file, even if `-demangle` is passed.
 __ZTIN3foo3bar4MethE:
   nop
 
+## This private label symbol will appear in the map file since it has nonzero
+## size.
+ltmp1:
+  nop
+
 .subsections_via_symbols
 
 #--- test.s
 .comm _number, 1
 .globl _main, _bar
 .weak_definition _bar
 
 _main: