[lld-macho] Emit map file entries for more synthetic sections

[int3]

Summary

We now handle the GOT, TLV, and stubs/lazy pointer sections.

[thakis]

The test failure on windows looks real.

[int3]

fix tests

[thakis]

Still failing on windows :(

[int3]

try again

[int3]

Tests look good on Windows now. Sorry for the back-and-forth!

[thakis]

LG!

lld/MachO/MapFile.cpp

struct MapInfo {
   DenseMap<const OutputSection *,
            SmallVector<std::pair<uint64_t /*addr*/, CStringInfo>>>
       liveCStringsForSection;
   SmallVector<CStringInfo> deadCStrings;
 };
 
 static MapInfo gatherMapInfo() {
   MapInfo info;
-  for (InputFile *file : inputFiles)
+  for (InputFile *file : inputFiles) {
+    bool isReferencedFile = false;
+
     if (isa<ObjFile>(file) || isa<BitcodeFile>(file)) {
       uint32_t fileIndex = info.files.size() + 1;
-      bool isReferencedFile = false;
 
       // Gather the dead symbols. We don't have to bother with the live ones
       // because we will pick them up as we iterate over the OutputSections
       // later.
       for (Symbol *sym : file->symbols) {
         if (auto *d = dyn_cast_or_null<Defined>(sym))
           // Only emit the prevailing definition of a symbol. Also, don't emit
           // the symbol if it is part of a cstring section (we use the literal
if (isa<ObjFile>(file) || isa<BitcodeFile>(file)) {
                 info.deadCStrings.push_back({fileIndex, isec->getStringRef(i)});
               isReferencedFile = true;
             }
           } else {
             break;
           }
         }
       }
+    } else if (const auto *dylibFile = dyn_cast<DylibFile>(file)) {
+      isReferencedFile = dylibFile->isReferenced();
+    }
 
-      if (isReferencedFile)
-        info.files.push_back(file);
-    }
 
   // cstrings are not stored in sorted order in their OutputSections, so we sort
   // them here.
   for (auto &liveCStrings : info.liveCStringsForSection)
     parallelSort(liveCStrings.second, [](const auto &p1, const auto &p2) {
       return p1.first < p2.first;
     });
   return info;
 }
 
+// For printing the contents of the __stubs and __la_symbol_ptr sections.
+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,
+                                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() {
   if (config->mapFile.empty())
     return;
 
   TimeTraceScope timeScope("Write map file");
 
   // Open a map file for writing.
   std::error_code ec;
for (const OutputSection *osec : seg->getSections()) {
           lastAddr = addr;
           os << format("0x%08llX\t0x%08llX\t[%3u] literal string: ", addr, size,
                        info.fileIndex);
           os.write_escaped(info.str) << "\n";
         }
       } else if (osec == (void *)in.unwindInfo) {
         os << format("0x%08llX\t0x%08llX\t[  0] compact unwind info\n",
                      osec->addr, osec->getSize());
+      } else if (osec == in.stubs) {
+        printStubsEntries(os, readerToFileOrdinal, osec, target->stubSize);
+      } else if (osec == in.lazyPointers) {
+        printStubsEntries(os, readerToFileOrdinal, osec, target->wordSize);
+      } else if (osec == in.stubHelper) {
+        // yes, ld64 calls it "helper helper"...
+        os << format("0x%08llX\t0x%08llX\t[  0] helper helper\n", osec->addr,
+                     osec->getSize());
+      } else if (osec == in.got) {
+        printNonLazyPointerSection(os, in.got);
+      } else if (osec == in.tlvPointers) {
+        printNonLazyPointerSection(os, in.tlvPointers);
       }
       // TODO print other synthetic sections
     }
   }
 
   if (config->deadStrip) {
     os << "# Dead Stripped Symbols:\n";
     os << "#        \tSize    \tFile  Name\n";

lld/test/MachO/dead-strip.s

 # EXECDATA-DAG:   _no_dead_strip_globl
 # EXECDATA-DAG:   __mh_execute_header
 
 ## Check that dead stripped symbols get listed properly.
 # RUN: FileCheck --check-prefix=MAP %s < %t/map
 
 # MAP:        _main
 # MAP-LABEL: Dead Stripped Symbols
-# MAP-DAG:   <<dead>> 0x00000001 [ 1] _unref_com
-# MAP-DAG:   <<dead>> 0x00000008 [ 1] _unref_data
-# MAP-DAG:   <<dead>> 0x00000006 [ 1] _unref_extern
-# MAP-DAG:   <<dead>> 0x00000001 [ 1] _unref_local
-# MAP-DAG:   <<dead>> 0x00000007 [ 1] _unref_private_extern
-# MAP-DAG:   <<dead>> 0x00000008 [ 1] l_unref_data
+# MAP-DAG:   <<dead>> 0x00000001 [ 2] _unref_com
+# MAP-DAG:   <<dead>> 0x00000008 [ 2] _unref_data
+# MAP-DAG:   <<dead>> 0x00000006 [ 2] _unref_extern
+# MAP-DAG:   <<dead>> 0x00000001 [ 2] _unref_local
+# MAP-DAG:   <<dead>> 0x00000007 [ 2] _unref_private_extern
+# MAP-DAG:   <<dead>> 0x00000008 [ 2] l_unref_data
 
 ## Run dead stripping on code without any dead symbols.
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos \
 # RUN:     %t/no-dead-symbols.s -o %t/no-dead-symbols.o
 # RUN: %lld -lSystem -dead_strip -map %t/no-dead-symbols-map \
 # RUN:     %t/no-dead-symbols.o -o %t/no-dead-symbols
 ## Mark the end of the file with a string.
 # RUN: FileCheck --check-prefix=NODEADSYMBOLS %s < %t/no-dead-symbols-map

 # DUP-NEXT:   g F __TEXT,__text _main
 # DUP-NEXT:   g F __TEXT,__text __mh_execute_header
 # DUP-NEXT:   *UND* dyld_stub_binder
 
 ## Check that the duplicate dead stripped symbols get listed properly.
 # RUN: FileCheck --check-prefix=DUPMAP %s < %t/stripped-duplicate-map
 # DUPMAP: _main
 # DUPMAP-LABEL: Dead Stripped Symbols
-# DUPMAP: <<dead>> 0x00000001 [ 2] _foo
+# DUPMAP: <<dead>> 0x00000001 [ 3] _foo
 
 #--- duplicate1.s
 .text
 .globl _main, _foo
 _foo:
   retq
 
 _main:

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] {{.*}}{{/|\\}}map-file.ll.tmp/foo.thinlto.o
-; FOOBAR-NEXT: [  2] {{.*}}{{/|\\}}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]+}}  [  1] _foo
-; FOOBAR-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2] _bar
-; FOOBAR-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2] _maybe_weak
+; 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
 ; BARFOO-NEXT: # Arch: x86_64
 ; BARFOO-NEXT: # Object files:
 ; BARFOO-NEXT: [  0] linker synthesized
-; BARFOO-NEXT: [  1] {{.*}}{{/|\\}}map-file.ll.tmp/bar.thinlto.o
-; BARFOO-NEXT: [  2] {{.*}}{{/|\\}}map-file.ll.tmp/foo.thinlto.o
+; BARFOO-NEXT: [  1] {{.*}}{{/|\\}}usr/lib{{/|\\}}libSystem.tbd
+; BARFOO-NEXT: [  2] {{.*}}{{/|\\}}map-file.ll.tmp/bar.thinlto.o
+; BARFOO-NEXT: [  3] {{.*}}{{/|\\}}map-file.ll.tmp/foo.thinlto.o
 ; BARFOO-NEXT: # Sections:
 ; BARFOO:      # Symbols:
 ; BARFOO-NEXT: # Address        Size             File  Name
-; BARFOO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  1] _bar
-; BARFOO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  1] _maybe_weak
-; BARFOO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2] _foo
+; BARFOO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2] _bar
+; BARFOO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2] _maybe_weak
+; BARFOO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  3] _foo
 
 ; LTO:      # Path: {{.*}}{{/|\\}}map-file.ll.tmp/foobar
 ; LTO-NEXT: # Arch: x86_64
 ; LTO-NEXT: # Object files:
 ; LTO-NEXT: [  0] linker synthesized
-; LTO-NEXT: [  1] {{.*}}{{/|\\}}map-file.ll.tmp/foo.o
-; LTO-NEXT: [  2] {{.*}}{{/|\\}}map-file.ll.tmp/bar.o
+; LTO-NEXT: [  1] {{.*}}{{/|\\}}usr/lib{{/|\\}}libSystem.tbd
+; LTO-NEXT: [  2] {{.*}}{{/|\\}}map-file.ll.tmp/foo.o
+; LTO-NEXT: [  3] {{.*}}{{/|\\}}map-file.ll.tmp/bar.o
 ; LTO-NEXT: # Sections:
 ; LTO:      # Symbols:
 ; LTO-NEXT: # Address        Size             File   Name
-; LTO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  1]  _foo
-; LTO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2]  _bar
-; LTO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2]  _maybe_weak
+; LTO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  2]  _foo
+; LTO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  3]  _bar
+; LTO-NEXT: 0x{{[0-9A-F]+}}  0x{{[0-9A-F]+}}  [  3]  _maybe_weak
 
 ;--- foo.ll
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo() {
   ret void
 }

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: %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:   --time-trace -o %t/test
+# RUN:   %t/libbaz.dylib --time-trace -o %t/test
 # 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-NEXT: Idx  Name          Size           VMA               Type
-# CHECK-NEXT: 0    __text        {{[0-9a-f]+}}  [[#%x,TEXT:]]     TEXT
-# CHECK-NEXT: 1    __cstring     {{[0-9a-f]+}}  [[#%x,CSTR:]]     DATA
-# CHECK-NEXT: 2    __unwind_info {{[0-9a-f]+}}  [[#%x,UNWIND:]]   DATA
-# CHECK-NEXT: 3    __eh_frame    {{[0-9a-f]+}}  [[#%x,EH_FRAME:]] DATA
-# CHECK-NEXT: 4    __common      {{[0-9a-f]+}}  [[#%x,BSS:]]      BSS
+# CHECK:       Sections:
+# CHECK-NEXT:  Idx  Name         Size     VMA               Type
+# CHECK-NEXT:  0 __text          0000001b [[#%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:  9 __thread_ptrs   00000008 [[#%x,TLVP:]]     DATA
+# CHECK-NEXT: 10 __common        00000001 [[#%x,BSS:]]      BSS
 
 # CHECK:      SYMBOL TABLE:
+# CHECK-DAG:  [[#%x,DYLD:]]    l     O __DATA,__data __dyld_private
 # CHECK-DAG:  [[#%x,MAIN:]]    g     F __TEXT,__text _main
 # CHECK-DAG:  [[#%x,NUMBER:]]  g     O __DATA,__common _number
-# CHECK-DAG:  [[#%x,BAR:]]     g     F __TEXT,__text _bar
+# CHECK-DAG:  [[#%x,BAR:]]     w     F __TEXT,__text _bar
 # 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] {{.*}}{{/|\\}}map-file.s.tmp/test.o
-# CHECK-NEXT: [  2] {{.*}}{{/|\\}}map-file.s.tmp/foo.o
-# CHECK-NEXT: [  3] {{.*}}{{/|\\}}map-file.s.tmp/c-string-literal.o
+# 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: # Sections:
-# CHECK-NEXT: # Address           Size              Segment  Section
-# CHECK-NEXT: 0x[[#%X,TEXT]]      0x{{[0-9A-F]+}}   __TEXT   __text
-# 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,EH_FRAME]]  0x{{[0-9A-F]+}}   __TEXT   __eh_frame
-# CHECK-NEXT: 0x[[#%X,BSS]]       0x{{[0-9A-F]+}}   __DATA   __common
+# 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,EH_FRAME]]  0x{{[0-9A-F]+}} __TEXT  __eh_frame
+# CHECK-NEXT: 0x[[#%X,GOT]]       0x{{[0-9A-F]+}} __DATA_CONST  __got
+# CHECK-NEXT: 0x[[#%X,LAZY]]      0x{{[0-9A-F]+}} __DATA  __la_symbol_ptr
+# CHECK-NEXT: 0x[[#%X,DATA]]      0x{{[0-9A-F]+}} __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-DAG:  0x[[#%X,MAIN]]             0x00000001  [  1]  _main
-# CHECK-DAG:  0x[[#%X,BAR]]              0x00000001  [  1]  _bar
-# CHECK-DAG:  0x[[#%X,FOO]]              0x00000001  [  2]  __ZTIN3foo3bar4MethE
-# CHECK-DAG:  0x[[#%X,HIWORLD]]          0x0000000E  [  3]  literal string: Hello world!\n
-# CHECK-DAG:  0x[[#%X,HIITSME]]          0x0000000F  [  3]  literal string: Hello, it's me
-# CHECK-DAG:  0x[[#%X,HIITSME + 0xf]]    0x0000000E  [  3]  literal string: Hello world!\n
-# CHECK-DAG:  0x[[#%X,NUMBER]]           0x00000001  [  1]  _number
-# CHECK-DAG:  0x[[#%X,UNWIND]]           0x0000103C  [  0]  compact unwind info
+# 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,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-DAG:  0x[[#%X,EH_FRAME]]         0x00000018  [  1]  EH_Frame
-# CHECK-DAG:  0x[[#%X,EH_FRAME + 0x18]]  0x00000020  [  1]  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
 
 # MAPFILE: "name":"Total Write map file"
 
-# RUN: %lld -demangle -dead_strip -map %t/stripped-map %t/test.o %t/foo.o %t/c-string-literal.o -o %t/stripped
+# 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: FileCheck --check-prefix=STRIPPED %s < %t/stripped-map
 
-## C-string literals should be printed as "literal string: <C string literal>"
 # STRIPPED-LABEL: Dead Stripped Symbols:
-# STRIPPED-DAG:   <<dead>>  0x00000001  [  1] _bar
-# STRIPPED-DAG:   <<dead>>  0x00000001  [  1] _number
-# STRIPPED-DAG:   <<dead>>  0x00000001  [  2] __ZTIN3foo3bar4MethE
-# STRIPPED-DAG:   <<dead>>  0x0000000E  [  3] literal string: Hello world!\n
-# STRIPPED-DAG:   <<dead>>  0x0000000F  [  3] literal string: Hello, it's me
-# STRIPPED-DAG:   <<dead>>  0x0000000E  [  3] literal string: Hello world!\n
+# 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 -o %t/icf
+# 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: 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  [  2] __ZTIN3foo3bar4MethE
-# ICF-DAG: 0x[[#FOO]]         0x00000001  [  1] _bar
-# ICF-DAG: 0x[[#%X,HIWORLD:]] 0x0000000E  [  3]  literal string: Hello world!\n
-# ICF-DAG: 0x[[#%X,HIWORLD]]  0x00000000  [  3]  literal string: Hello world!\n
+# 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 C++ symbol makes it clear that we do not print the demangled name in
 ## the map file, even if `-demangle` is passed.
 __ZTIN3foo3bar4MethE:
   nop
 
 .subsections_via_symbols
 
 #--- test.s
 .comm _number, 1
 .globl _main, _bar
+.weak_definition _bar
 
 _main:
 .cfi_startproc
 .cfi_def_cfa_offset 16
+  callq _bar
+  callq _baz
+  movq _baz2@GOTPCREL(%rip), %rax
+  mov _baz_tlv@TLVP(%rip), %rax
   ret
 .cfi_endproc
 
 _bar:
   nop
 
 .subsections_via_symbols
 
 #--- c-string-literal.s
 .globl _hello_world, _hello_its_me
 
 .cstring
 
 _hello_world:
 .asciz "Hello world!\n"
 
 _hello_its_me:
 .asciz "Hello, it's me"
 
 .asciz "Hello world!\n"
 
 .subsections_via_symbols
+
+#--- baz.s
+.globl _baz, _baz2
+
+_baz:
+  nop
+
+_baz2:
+  nop
+
+.section __DATA,__thread_vars,thread_local_variables
+.globl _baz_tlv
+_baz_tlv:
+  nop