[ELF] --cref: If -Map is specified, print to the map file

[MaskRay]

Summary

PR48282: This behavior matches GNU ld and gold.

[markj]

This looks right to me, for what it's worth. Thanks!

[MaskRay]

Add release note

lld/ELF/MapFile.h

 //===- MapFile.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_MAPFILE_H
 #define LLD_ELF_MAPFILE_H
 
 namespace lld {
 namespace elf {
-void writeMapFile();
+void writeMapAndCref();
 void writeWhyExtract();
-void writeCrossReferenceTable();
 void writeArchiveStats();
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/MapFile.cpp

static void printEhFrame(raw_ostream &os, const EhFrameSection *sec) {
   for (EhSectionPiece &p : pieces) {
     writeHeader(os, osec->addr + p.outputOff, osec->getLMA() + p.outputOff,
                 p.size, 1);
     os << indent8 << toString(p.sec->file) << ":(" << p.sec->name << "+0x"
        << Twine::utohexstr(p.inputOff) + ")\n";
   }
 }
 
-void elf::writeMapFile() {
-  if (config->mapFile.empty())
-    return;
-
-  llvm::TimeTraceScope timeScope("Write map file");
-
-  // Open a map file for writing.
-  std::error_code ec;
-  raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None);
-  if (ec) {
-    error("cannot open " + config->mapFile + ": " + ec.message());
-    return;
-  }
-
+static void writeMapFile(raw_fd_ostream &os) {
   // Collect symbol info that we want to print out.
   std::vector<Defined *> syms = getSymbols();
   SymbolMapTy sectionSyms = getSectionSyms(syms);
   DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms);
 
   // Print out the header line.
   int w = config->is64 ? 16 : 8;
   os << right_justify("VMA", w) << ' ' << right_justify("LMA", w)
void elf::writeWhyExtract() {
 
   os << "reference\textracted\tsymbol\n";
   for (auto &entry : whyExtract) {
     os << std::get<0>(entry) << '\t' << toString(std::get<1>(entry)) << '\t'
        << toString(std::get<2>(entry)) << '\n';
   }
 }
 
-static void print(StringRef a, StringRef b) {
-  lld::outs() << left_justify(a, 49) << " " << b << "\n";
-}
-
 // Output a cross reference table to stdout. This is for --cref.
 //
 // For each global symbol, we print out a file that defines the symbol
 // followed by files that uses that symbol. Here is an example.
 //
 //     strlen     /lib/x86_64-linux-gnu/libc.so.6
 //                tools/lld/tools/lld/CMakeFiles/lld.dir/lld.cpp.o
 //                lib/libLLVMSupport.a(PrettyStackTrace.cpp.o)
 //
 // In this case, strlen is defined by libc.so.6 and used by other two
 // files.
-void elf::writeCrossReferenceTable() {
-  if (!config->cref)
-    return;
-
+static void writeCref(raw_fd_ostream &os) {
   // Collect symbols and files.
   MapVector<Symbol *, SetVector<InputFile *>> map;
   for (InputFile *file : objectFiles) {
     for (Symbol *sym : file->getSymbols()) {
       if (isa<SharedSymbol>(sym))
         map[sym].insert(file);
       if (auto *d = dyn_cast<Defined>(sym))
         if (!d->isLocal() && (!d->section || d->section->isLive()))
           map[d].insert(file);
     }
   }
 
-  // Print out a header.
-  lld::outs() << "Cross Reference Table\n\n";
+  auto print = [&](StringRef a, StringRef b) {
+    os << left_justify(a, 49) << ' ' << b << '\n';
+  };
+
+  // Print a blank line and a header. The format matches GNU ld.
+  os << "\nCross Reference Table\n\n";
   print("Symbol", "File");
 
   // Print out a table.
   for (auto kv : map) {
     Symbol *sym = kv.first;
     SetVector<InputFile *> &files = kv.second;
 
     print(toString(*sym), toString(sym->file));
     for (InputFile *file : files)
       if (file != sym->file)
         print("", toString(file));
   }
 }
 
+void elf::writeMapAndCref() {
+  if (config->mapFile.empty() && !config->cref)
+    return;
+
+  llvm::TimeTraceScope timeScope("Write map file");
+
+  // Open a map file for writing.
+  std::error_code ec;
+  StringRef mapFile = config->mapFile.empty() ? "-" : config->mapFile;
+  raw_fd_ostream os(mapFile, ec, sys::fs::OF_None);
+  if (ec) {
+    error("cannot open " + mapFile + ": " + ec.message());
+    return;
+  }
+
+  if (!config->mapFile.empty())
+    writeMapFile(os);
+  if (config->cref)
+    writeCref(os);
+}
+
 void elf::writeArchiveStats() {
   if (config->printArchiveStats.empty())
     return;
 
   std::error_code ec;
   raw_fd_ostream os(config->printArchiveStats, ec, sys::fs::OF_None);
   if (ec) {
     error("--print-archive-stats=: cannot open " + config->printArchiveStats +

lld/ELF/Options.td

 
 defm color_diagnostics: B<"color-diagnostics",
   "Alias for --color-diagnostics=always",
   "Alias for --color-diagnostics=never">;
 def color_diagnostics_eq: J<"color-diagnostics=">,
   HelpText<"Use colors in diagnostics (default: auto)">,
   MetaVarName<"[auto,always,never]">;
 
-def cref: FF<"cref">, HelpText<"Output cross reference table">;
+def cref: FF<"cref">,
+  HelpText<"Output cross reference table. If -Map is specified, print to the map file">;
 
 defm define_common: B<"define-common",
     "Assign space to common symbols",
     "Do not assign space to common symbols">;
 
 defm demangle: B<"demangle",
     "Demangle symbol names (default)",
     "Do not demangle symbol names">;

lld/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   if (config->relocatable)
     for (OutputSection *sec : outputSections)
       sec->addr = 0;
 
   // Handle --print-map(-M)/--Map, --why-extract=, --cref and
   // --print-archive-stats=. Dump them before checkSections() because the files
   // may be useful in case checkSections() or openFile() fails, for example, due
   // to an erroneous file size.
-  writeMapFile();
+  writeMapAndCref();
   writeWhyExtract();
-  writeCrossReferenceTable();
   writeArchiveStats();
 
   if (config->checkSections)
     checkSections();
 
   // It does not make sense try to open the file if we have error already.
   if (errorCount())
     return;

lld/docs/ReleaseNotes.rst

 
 * ``--export-dynamic-symbol-list`` has been added.
   (`D107317 <https://reviews.llvm.org/D107317>`_)
 * ``--why-extract`` has been added to query why archive members/lazy object files are extracted.
   (`D109572 <https://reviews.llvm.org/D109572>`_)
 * ``e_entry`` no longer falls back to the address of ``.text`` if the entry symbol does not exist.
   Instead, a value of 0 will be written.
   (`D110014 <https://reviews.llvm.org/D110014>`_)
+* If ``-Map`` is specified, ``--cref`` will be printted to the specified file.
+  (`D114663 <https://reviews.llvm.org/D114663>`_)
 
 Architecture specific changes:
 
 * The x86-32 port now supports TLSDESC (``-mtls-dialect=gnu2``).
   (`D112582 <https://reviews.llvm.org/D112582>`_)
 * The x86-64 port now handles non-RAX/non-adjacent ``R_X86_64_GOTPC32_TLSDESC``
   and ``R_X86_64_TLSDESC_CALL`` (``-mtls-dialect=gnu2``).
   (`D114416 <https://reviews.llvm.org/D114416>`_)

lld/docs/ld.lld.1

 or
 .Cm zlib .
 The default compression level is 1 (fastest) as the debug info usually
 compresses well at that level, but if you want to compress it more,
 you can specify
 .Fl O2
 to set the compression level to 6.
 .It Fl -cref
-Output cross reference table.
+Output cross reference table. If
+.Fl Map
+is specified, print to the map file.
 .It Fl -define-common , Fl d
 Assign space to common symbols.
 .It Fl -defsym Ns = Ns Ar symbol Ns = Ns Ar expression
 Define a symbol alias.
 .Ar expression
 may be another symbol or a linker script expression.
 For example,
 .Ql --defsym=foo=bar

lld/test/ELF/cref.s

 // REQUIRES: x86
 
 // RUN: echo '.global foo; foo:' | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %t1.o
 // RUN: echo '.global foo, bar; bar:' | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %t2.o
 // RUN: echo '.global zed; zed:' | llvm-mc -filetype=obj -triple=x86_64-pc-linux - -o %ta.o
 // RUN: rm -f %t.a
 // RUN: llvm-ar rcs %t.a %ta.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t3.o
 // RUN: ld.lld -shared -o %t1.so %t1.o
 // RUN: ld.lld -o /dev/null %t1.so %t2.o %t3.o %t.a --gc-sections --cref | FileCheck -strict-whitespace %s
 
-//      CHECK: Symbol                                            File
+/// If -Map is specified, print to the map file.
+// RUN: ld.lld -o /dev/null %t1.so %t2.o %t3.o %t.a --gc-sections -Map=%t.map --cref
+// RUN: FileCheck --input-file=%t.map %s --check-prefix=CHECK2
+
+// CHECK:      {{^$}}
+// CHECK-NEXT: Cross Reference Table
+// CHECK-EMPTY:
+// CHECK-NEXT: Symbol                                            File
 // CHECK-NEXT: foo                                               {{.*}}1.so
 // CHECK-NEXT:                                                   {{.*}}2.o
 // CHECK-NEXT:                                                   {{.*}}3.o
 // CHECK-NEXT: bar                                               {{.*}}2.o
 // CHECK-NEXT:                                                   {{.*}}3.o
 // CHECK-NEXT: _start                                            {{.*}}3.o
 // CHECK-NEXT: baz                                               {{.*}}3.o
 // CHECK-NEXT: zed                                               {{.*}}.a({{.*}}a.o)
 // CHECK-NEXT:                                                   {{.*}}3.o
 // CHECK-NOT:  discarded
 
+// CHECK2:         VMA              LMA     Size Align Out     In      Symbol
+// CHECK2:      .strtab
+// CHECK2-NEXT:         <internal>:(.strtab)
+
+/// There is a blank line before the "Cross Reference Table" header.
+// CHECK2-EMPTY:
+// CHECK2-NEXT: Cross Reference Table
+
 .global _start, foo, bar, baz, discarded
 _start:
   call foo
   call bar
   call zed
 localsym:
 baz:
 
 .section .text.a,"ax",@progbits
 discarded: