Include copy relocation symbols into the map file.

[ruiu]

Summary

Fixes https://bugs.llvm.org/show_bug.cgi?id=35471

lld/ELF/MapFile.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf;
 
-typedef DenseMap<const SectionBase *, SmallVector<Defined *, 4>> SymbolMapTy;
+typedef DenseMap<const SectionBase *, SmallVector<Symbol *, 4>> SymbolMapTy;
 
 // Print out the first three columns of a line.
 static void writeHeader(raw_ostream &OS, uint64_t Addr, uint64_t Size,
                         uint64_t Align) {
   int W = Config->Is64 ? 16 : 8;
   OS << format("%0*llx %0*llx %5lld ", W, Addr, W, Size, Align);
 }
 
 static std::string indent(int Depth) { return std::string(Depth * 8, ' '); }
 
 // Returns a list of all symbols that we want to print out.
-static std::vector<Defined *> getSymbols() {
-  std::vector<Defined *> V;
+static std::vector<Symbol *> getSymbols() {
+  std::vector<Symbol *> V;
+
   for (InputFile *File : ObjectFiles)
     for (Symbol *B : File->getSymbols())
       if (auto *DR = dyn_cast<Defined>(B))
         if (DR->File == File && !DR->isSection() && DR->Section &&
             DR->Section->Live)
           V.push_back(DR);
+
+  for (Symbol *B : Symtab->getSymbols())
+    if (auto *Sym = dyn_cast<SharedSymbol>(B))
+      if (Sym->CopyRelSec)
+        V.push_back(Sym);
+
   return V;
 }
 
 // Returns a map from sections to their symbols.
-static SymbolMapTy getSectionSyms(ArrayRef<Defined *> Syms) {
+static SymbolMapTy getSectionSyms(ArrayRef<Symbol *> Syms) {
   SymbolMapTy Ret;
-  for (Defined *S : Syms)
-    Ret[S->Section].push_back(S);
+  for (Symbol *S : Syms) {
+    if (auto *Sym = dyn_cast<Defined>(S))
+      Ret[Sym->Section].push_back(Sym);
+    else
+      Ret[cast<SharedSymbol>(S)->CopyRelSec].push_back(S);
+  }
 
   // Sort symbols by address. We want to print out symbols in the
   // order in the output file rather than the order they appeared
   // in the input files.
   for (auto &It : Ret) {
-    SmallVectorImpl<Defined *> &V = It.second;
+    SmallVectorImpl<Symbol *> &V = It.second;
     std::sort(V.begin(), V.end(),
-              [](Defined *A, Defined *B) { return A->getVA() < B->getVA(); });
+              [](Symbol *A, Symbol *B) { return A->getVA() < B->getVA(); });
   }
   return Ret;
 }
 
 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
-static DenseMap<Defined *, std::string>
-getSymbolStrings(ArrayRef<Defined *> Syms) {
+static DenseMap<Symbol *, std::string>
+getSymbolStrings(ArrayRef<Symbol *> Syms) {
   std::vector<std::string> Str(Syms.size());
   parallelForEachN(0, Syms.size(), [&](size_t I) {
     raw_string_ostream OS(Str[I]);
     writeHeader(OS, Syms[I]->getVA(), Syms[I]->getSize(), 0);
     OS << indent(2) << toString(*Syms[I]);
   });
 
-  DenseMap<Defined *, std::string> Ret;
+  DenseMap<Symbol *, std::string> Ret;
   for (size_t I = 0, E = Syms.size(); I < E; ++I)
     Ret[Syms[I]] = std::move(Str[I]);
   return Ret;
 }
 
 void elf::writeMapFile() {
   if (Config->MapFile.empty())
     return;
 
   // Open a map file for writing.
   std::error_code EC;
   raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
   if (EC) {
     error("cannot open " + Config->MapFile + ": " + EC.message());
     return;
   }
 
   // Collect symbol info that we want to print out.
-  std::vector<Defined *> Syms = getSymbols();
+  std::vector<Symbol *> Syms = getSymbols();
   SymbolMapTy SectionSyms = getSectionSyms(Syms);
-  DenseMap<Defined *, std::string> SymStr = getSymbolStrings(Syms);
+  DenseMap<Symbol *, std::string> SymStr = getSymbolStrings(Syms);
 
   // Print out the header line.
   int W = Config->Is64 ? 16 : 8;
   OS << left_justify("Address", W) << ' ' << left_justify("Size", W)
      << " Align Out     In      Symbol\n";
 
   // Print out file contents.
   for (OutputSection *OSec : OutputSections) {
     writeHeader(OS, OSec->Addr, OSec->Size, OSec->Alignment);
     OS << OSec->Name << '\n';
 
     // Dump symbols for each input section.
     for (BaseCommand *Base : OSec->SectionCommands) {
       auto *ISD = dyn_cast<InputSectionDescription>(Base);
       if (!ISD)
         continue;
       for (InputSection *IS : ISD->Sections) {
         writeHeader(OS, OSec->Addr + IS->OutSecOff, IS->getSize(),
                     IS->Alignment);
         OS << indent(1) << toString(IS) << '\n';
-        for (Defined *Sym : SectionSyms[IS])
+        for (Symbol *Sym : SectionSyms[IS])
           OS << SymStr[Sym] << '\n';
       }
     }
   }
 }

lld/test/ELF/Inputs/map-file5.s

+.global copy
+.type copy, @object
+copy:
+.size copy, 32

lld/test/ELF/map-file.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/map-file2.s -o %t2.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/map-file3.s -o %t3.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/map-file4.s -o %t4.o
 // RUN: rm -f %t4.a
 // RUN: llvm-ar rc %t4.a %t4.o
-// RUN: ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -M | FileCheck -strict-whitespace %s
-// RUN: ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -print-map | FileCheck -strict-whitespace %s
-// RUN: ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=%t.map
+
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/map-file5.s -o %t5.o
+// RUN: ld.lld -o %t5.so -shared %t5.o
+
+// RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -M | FileCheck -strict-whitespace %s
+// RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -print-map | FileCheck -strict-whitespace %s
+// RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -Map=%t.map
 // RUN: FileCheck -strict-whitespace %s < %t.map
 
 .global _start
 _start:
         call baz
+  .quad copy
 .global _Z1fi
 _Z1fi:
 .cfi_startproc
 .cfi_endproc
 nop
 .weak bar
 bar:
 .long bar - .
 .long zed - .
 local:
 .comm   common,4,16
 .global abs
 abs = 0xAB5
 labs = 0x1AB5
 
 // CHECK:      Address          Size             Align Out     In      Symbol
-// CHECK-NEXT: 0000000000200158 0000000000000030     8 .eh_frame
-// CHECK-NEXT: 0000000000200158 0000000000000030     8         <internal>:(.eh_frame)
-// CHECK-NEXT: 0000000000201000 0000000000000015     4 .text
-// CHECK-NEXT: 0000000000201000 000000000000000e     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
+// CHECK-NEXT: 00000000002001c8 0000000000000030     8 .dynsym
+// CHECK-NEXT: 00000000002001c8 0000000000000030     8         <internal>:(.dynsym)
+// CHECK-NEXT: 00000000002001f8 0000000000000020     8 .gnu.hash
+// CHECK-NEXT: 00000000002001f8 0000000000000020     8         <internal>:(.gnu.hash)
+// CHECK-NEXT: 0000000000200218 0000000000000018     4 .hash
+// CHECK-NEXT: 0000000000200218 0000000000000018     4         <internal>:(.hash)
+// CHECK-NEXT: 0000000000200230 000000000000003a     1 .dynstr
+// CHECK-NEXT: 0000000000200230 000000000000003a     1         <internal>:(.dynstr)
+// CHECK-NEXT: 0000000000200270 0000000000000018     8 .rela.dyn
+// CHECK-NEXT: 0000000000200270 0000000000000018     8         <internal>:(.rela.dyn)
+// CHECK-NEXT: 0000000000200288 0000000000000030     8 .eh_frame
+// CHECK-NEXT: 0000000000200288 0000000000000030     8         <internal>:(.eh_frame)
+// CHECK-NEXT: 0000000000201000 000000000000001d     4 .text
+// CHECK-NEXT: 0000000000201000 0000000000000016     4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.text)
 // CHECK-NEXT: 0000000000201000 0000000000000000     0                 _start
-// CHECK-NEXT: 0000000000201005 0000000000000000     0                 f(int)
-// CHECK-NEXT: 000000000020100e 0000000000000000     0                 local
-// CHECK-NEXT: 0000000000201010 0000000000000002     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
-// CHECK-NEXT: 0000000000201010 0000000000000000     0                 foo
-// CHECK-NEXT: 0000000000201011 0000000000000000     0                 bar
-// CHECK-NEXT: 0000000000201012 0000000000000000     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
-// CHECK-NEXT: 0000000000201012 0000000000000000     0                 zed
-// CHECK-NEXT: 0000000000201014 0000000000000000     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
-// CHECK-NEXT: 0000000000201014 0000000000000000     0                 bah
-// CHECK-NEXT: 0000000000201014 0000000000000001     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
-// CHECK-NEXT: 0000000000201014 0000000000000000     0                 baz
-// CHECK-NEXT: 0000000000202000 0000000000000004    16 .bss
-// CHECK-NEXT: 0000000000202000 0000000000000004    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
-// CHECK-NEXT: 0000000000202000 0000000000000004     0                 common
+// CHECK-NEXT: 000000000020100d 0000000000000000     0                 f(int)
+// CHECK-NEXT: 0000000000201016 0000000000000000     0                 local
+// CHECK-NEXT: 0000000000201018 0000000000000002     4         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text)
+// CHECK-NEXT: 0000000000201018 0000000000000000     0                 foo
+// CHECK-NEXT: 0000000000201019 0000000000000000     0                 bar
+// CHECK-NEXT: 000000000020101a 0000000000000000     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
+// CHECK-NEXT: 000000000020101a 0000000000000000     0                 zed
+// CHECK-NEXT: 000000000020101c 0000000000000000     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
+// CHECK-NEXT: 000000000020101c 0000000000000000     0                 bah
+// CHECK-NEXT: 000000000020101c 0000000000000001     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
+// CHECK-NEXT: 000000000020101c 0000000000000000     0                 baz
+// CHECK-NEXT: 0000000000202000 00000000000000c0     8 .dynamic
+// CHECK-NEXT: 0000000000202000 00000000000000c0     8         <internal>:(.dynamic)
+// CHECK-NEXT: 00000000002020c0 0000000000000020     4 .bss.rel.ro
+// CHECK-NEXT: 00000000002020c0 0000000000000020     4         <internal>:(.bss.rel.ro)
+// CHECK-NEXT: 00000000002020c0 0000000000000020     0                 copy
+// CHECK-NEXT: 0000000000203000 0000000000000004    16 .bss
+// CHECK-NEXT: 0000000000203000 0000000000000004    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
+// CHECK-NEXT: 0000000000203000 0000000000000004     0                 common
 // CHECK-NEXT: 0000000000000000 0000000000000008     1 .comment
 // CHECK-NEXT: 0000000000000000 0000000000000008     1         <internal>:(.comment)
-// CHECK-NEXT: 0000000000000000 0000000000000120     8 .symtab
-// CHECK-NEXT: 0000000000000000 0000000000000120     8         <internal>:(.symtab)
-// CHECK-NEXT: 0000000000000000 0000000000000039     1 .shstrtab
-// CHECK-NEXT: 0000000000000000 0000000000000039     1         <internal>:(.shstrtab)
-// CHECK-NEXT: 0000000000000000 0000000000000038     1 .strtab
-// CHECK-NEXT: 0000000000000000 0000000000000038     1         <internal>:(.strtab)
+// CHECK-NEXT: 0000000000000000 0000000000000150     8 .symtab
+// CHECK-NEXT: 0000000000000000 0000000000000150     8         <internal>:(.symtab)
+// CHECK-NEXT: 0000000000000000 0000000000000078     1 .shstrtab
+// CHECK-NEXT: 0000000000000000 0000000000000078     1         <internal>:(.shstrtab)
+// CHECK-NEXT: 0000000000000000 0000000000000046     1 .strtab
+// CHECK-NEXT: 0000000000000000 0000000000000046     1         <internal>:(.strtab)
 
-// RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=/ 2>&1 \
+// RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -Map=/ 2>&1 \
 // RUN:  | FileCheck -check-prefix=FAIL %s
 // FAIL: cannot open map file /