[lld-macho] Print archive names in linker map

[int3]

Summary

If a symbol is pulled in from an archive, we should include the archive
name in the map file output. This is what ld64 does.

Note that we aren't using toString(InputFile*) here because it
includes the install name for dylibs in its output, and ld64's map file
does not contain those.

[int3]

make static

[smeenai]

Note that we aren't using toString(InputFile*) here because it

includes the install name for dylibs in its output, and ld64's map file
does not contain those.

Could you include this comment somewhere in the code as well, so that it's more easily accessible? Otherwise LGTM

lld/MachO/MapFile.cpp

static MapInfo gatherMapInfo() {
   // them here.
   for (auto &liveCStrings : info.liveCStringsForSection)
     parallelSort(liveCStrings.second, [](const auto &p1, const auto &p2) {
       return p1.first < p2.first;
     });
   return info;
 }
 
+// We use this instead of `toString(const InputFile *)` as we don't want to
+// include the dylib install name in our output.
+static void printFileName(raw_fd_ostream &os, const InputFile *f) {
+  if (f->archiveName.empty())
+    os << f->getName();
+  else
+    os << f->archiveName << "(" << path::filename(f->getName()) + ")";
+}
+
 // For printing the contents of the __stubs and __la_symbol_ptr sections.
-void printStubsEntries(
+static void printStubsEntries(
     raw_fd_ostream &os,
     const DenseMap<lld::macho::InputFile *, uint32_t> &readerToFileOrdinal,
     const OutputSection *osec, size_t entrySize) {
   for (const Symbol *sym : in.stubs->getEntries())
     os << format("0x%08llX\t0x%08zX\t[%3u] %s\n",
                  osec->addr + sym->stubsIndex * entrySize, entrySize,
                  readerToFileOrdinal.lookup(sym->getFile()),
                  sym->getName().str().data());
 }
 
-void printNonLazyPointerSection(raw_fd_ostream &os,
+static void printNonLazyPointerSection(raw_fd_ostream &os,
                                        NonLazyPointerSectionBase *osec) {
   // ld64 considers stubs to belong to particular files, but considers GOT
   // entries to be linker-synthesized. Not sure why they made that decision, but
   // I think we can follow suit unless there's demand for better symbol-to-file
   // associations.
   for (const Symbol *sym : osec->getEntries())
     os << format("0x%08llX\t0x%08zX\t[  0] non-lazy-pointer-to-local: %s\n",
                  osec->addr + sym->gotIndex * target->wordSize,
                  target->wordSize, sym->getName().str().data());
void macho::writeMapFile() {
 
   MapInfo info = gatherMapInfo();
 
   os << "# Object files:\n";
   os << format("[%3u] %s\n", 0, (const char *)"linker synthesized");
   uint32_t fileIndex = 1;
   DenseMap<lld::macho::InputFile *, uint32_t> readerToFileOrdinal;
   for (InputFile *file : info.files) {
-    os << format("[%3u] %s\n", fileIndex, file->getName().str().c_str());
+    os << format("[%3u] ", fileIndex);
+    printFileName(os, file);
+    os << "\n";
     readerToFileOrdinal[file] = fileIndex++;
   }
 
   os << "# Sections:\n";
   os << "# Address\tSize    \tSegment\tSection\n";
   for (OutputSegment *seg : outputSegments)
     for (OutputSection *osec : seg->getSections()) {
       if (osec->isHidden())

lld/test/MachO/map-file.ll

 ; RUN: llvm-as %t/bar.ll -o %t/bar.o
 ; RUN: %lld -dylib %t/foo.o %t/bar.o -o %t/foobar -map %t/foobar.map
 ; RUN: FileCheck %s --check-prefix=LTO < %t/foobar.map
 
 ; FOOBAR:      # Path: {{.*}}{{/|\\}}map-file.ll.tmp/foobar.thinlto
 ; FOOBAR-NEXT: # Arch: x86_64
 ; FOOBAR-NEXT: # Object files:
 ; FOOBAR-NEXT: [  0] linker synthesized
-; FOOBAR-NEXT: [  1] {{.*}}{{/|\\}}usr/lib{{/|\\}}libSystem.tbd
-; FOOBAR-NEXT: [  2] {{.*}}{{/|\\}}map-file.ll.tmp/foo.thinlto.o
-; FOOBAR-NEXT: [  3] {{.*}}{{/|\\}}map-file.ll.tmp/bar.thinlto.o
+; FOOBAR-NEXT: [  1] {{.*}}{{/|\\}}usr/lib{{/|\\}}libSystem.tbd{{$}}
+; FOOBAR-NEXT: [  2] {{.*}}{{/|\\}}map-file.ll.tmp/foo.thinlto.o{{$}}
+; FOOBAR-NEXT: [  3] {{.*}}{{/|\\}}map-file.ll.tmp/bar.thinlto.o{{$}}
 ; FOOBAR-NEXT: # Sections:
 ; FOOBAR:      # Symbols:
 ; FOOBAR-NEXT: # Address        Size             File  Name
 ; FOOBAR-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2] _foo
 ; FOOBAR-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  3] _bar
 ; FOOBAR-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  3] _maybe_weak
 
 ; BARFOO:      # Path: {{.*}}{{/|\\}}map-file.ll.tmp/barfoo.thinlto

lld/test/MachO/map-file.s

 # REQUIRES: x86
 # RUN: rm -rf %t; split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/foo.s -o %t/foo.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/c-string-literal.s -o %t/c-string-literal.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/baz.s -o %t/baz.o
 
+# RUN: llvm-ar --format=darwin crs %t/libfoo.a %t/foo.o
 # RUN: %lld -dylib %t/baz.o -o %t/libbaz.dylib
-# RUN: %lld -demangle -map %t/map %t/test.o %t/foo.o %t/c-string-literal.o \
-# RUN:   %t/libbaz.dylib --time-trace -o %t/test --no-deduplicate-strings
+# RUN: %lld -demangle -map %t/map %t/test.o -force_load %t/libfoo.a \
+# RUN:   %t/c-string-literal.o %t/libbaz.dylib --time-trace -o %t/test \
+# RUN:   --no-deduplicate-strings
 # RUN: llvm-objdump --syms --section-headers %t/test > %t/objdump
 ## 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-DAG:  [[#%x,FOO:]]     g     F __TEXT,__text __ZTIN3foo3bar4MethE
 # CHECK-DAG:  [[#%x,HIWORLD:]] g     O __TEXT,__cstring _hello_world
 # CHECK-DAG:  [[#%x,HIITSME:]] g     O __TEXT,__cstring _hello_its_me
 
 # CHECK:      # Path: {{.*}}{{/|\\}}map-file.s.tmp/test
 # CHECK-NEXT: # Arch: x86_64
 # CHECK-NEXT: # Object files:
 # CHECK-NEXT: [  0] linker synthesized
-# CHECK-NEXT: [  1] {{.*}}{{/|\\}}usr/lib{{/|\\}}libSystem.tbd
-# CHECK-NEXT: [  2] {{.*}}{{/|\\}}map-file.s.tmp/test.o
-# CHECK-NEXT: [  3] {{.*}}{{/|\\}}map-file.s.tmp/foo.o
-# CHECK-NEXT: [  4] {{.*}}{{/|\\}}map-file.s.tmp/c-string-literal.o
-# CHECK-NEXT: [  5] {{.*}}{{/|\\}}map-file.s.tmp/libbaz.dylib
+# CHECK-NEXT: [  1] {{.*}}{{/|\\}}usr/lib{{/|\\}}libSystem.tbd{{$}}
+# CHECK-NEXT: [  2] {{.*}}{{/|\\}}map-file.s.tmp/test.o{{$}}
+# CHECK-NEXT: [  3] {{.*}}{{/|\\}}map-file.s.tmp/libfoo.a(foo.o){{$}}
+# CHECK-NEXT: [  4] {{.*}}{{/|\\}}map-file.s.tmp/c-string-literal.o{{$}}
+# CHECK-NEXT: [  5] {{.*}}{{/|\\}}map-file.s.tmp/libbaz.dylib{{$}}
 
 # CHECK-NEXT: # Sections:
 # CHECK-NEXT: # Address           Size            Segment  Section
 # CHECK-NEXT: 0x[[#%X,TEXT]]      0x{{[0-9A-F]+}} __TEXT  __text
 # CHECK-NEXT: 0x[[#%X,STUBS]]     0x{{[0-9A-F]+}} __TEXT  __stubs
 # CHECK-NEXT: 0x[[#%X,HELPER]]    0x{{[0-9A-F]+}} __TEXT  __stub_helper
 # CHECK-NEXT: 0x[[#%X,CSTR]]      0x{{[0-9A-F]+}} __TEXT  __cstring
 # CHECK-NEXT: 0x[[#%X,UNWIND]]    0x{{[0-9A-F]+}} __TEXT  __unwind_info

 # 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
 
 # MAPFILE: "name":"Total Write map file"
 
-# RUN: %lld -demangle -dead_strip -map %t/stripped-map %t/test.o %t/foo.o \
-# RUN:   %t/c-string-literal.o %t/libbaz.dylib -o %t/stripped
+# 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:
 # STRIPPED-DAG:   <<dead>>  0x00000001  [  2] _number
 # STRIPPED-DAG:   <<dead>>  0x00000001  [  3] __ZTIN3foo3bar4MethE
 # STRIPPED-DAG:   <<dead>>  0x0000000E  [  4] literal string: Hello world!\n
 # STRIPPED-DAG:   <<dead>>  0x0000000F  [  4] literal string: Hello, it's me
 # STRIPPED-DAG:   <<dead>>  0x0000000E  [  4] literal string: Hello world!\n
 
-# RUN: %lld --icf=all -map %t/icf-map %t/test.o %t/foo.o %t/c-string-literal.o \
-# RUN:   %t/libbaz.dylib -o /dev/null
+# RUN: %lld --icf=all -map %t/icf-map %t/test.o -force_load %t/libfoo.a \
+# RUN:   %t/c-string-literal.o %t/libbaz.dylib -o /dev/null
 # RUN: FileCheck --check-prefix=ICF %s < %t/icf-map
 
 ## Verify that folded symbols and cstrings have size zero. Note that ld64 prints
 ## folded symbols but not folded cstrings; we print both.
 
 # ICF:     Symbols:
 # ICF-DAG: 0x[[#%X,FOO:]]     0x00000000  [  3] __ZTIN3foo3bar4MethE
 # ICF-DAG: 0x[[#FOO]]         0x00000001  [  2] _bar