Implement -Map

[• rafael]

Summary

This is not exactly the same format as bfd ld, but should serve a similar purpose.

[ruiu]

Is there any reason we can't print out in the exact same format as ld.bfd? Because LLD is basically a drop-in replacement, compatible output would be generally appreciated.

lld/ELF/MapFile.cpp

8

This needs a file comment. At least it should mention that this is for -Map and what kind of information is printed, at the granularity of the ld man page.

25–28

nit: maybe this style is more common?

OS << ...
   << ...;

as opposed to

OS << ...;
OS << ...;

100

Do you need this temporary variable?

106–113

This seems like a pretty common pattern. We probably should have a class that does this (open with a temporary file name and rename on close) automatically.

lld/ELF/MapFile.h

2

Not directly related to this patch, but we have many instances of this kind of "effectively one line" .h files in LLD. In some case, some declarations are piggy backed to a somewhat unrelated header (e.g. markLive's declaration is in Writer.h.)

I once wondered if we should create a header for miscellaneous functions, say, LLD.h, to aggregate them. What do you think?

[davide]

Take this with a grain of salt, Rui, but last I checked --map as emitted by bfd wasn't particularly informative.
I also personally don't think we should really stick with compatibility for debugging options, assuming we can provide a better output.

[ruiu]

Added pcc as he implemented a similar feature for COFF. It is good for us to make him take a look.

lld/ELF/MapFile.cpp

14

An example of an output would be appreciated. You can copy some part of the test here.

16

Add a blank line.

[pcc]

I have to say that I prefer this style of output to what I implemented for /lldmap in the COFF linker. At some point we should make the COFF linker use this format or something similar.

I wonder whether it would be worth making absolute symbols show up in the map file.

lld/test/ELF/map-file.s

33

You probably want to use regexes to match the paths here and below.

[ruiu]

LGTM with these changes as everybody seems happy with this output format.

lld/ELF/Driver.cpp

515

Move the definitions of -Map and -Map= in Options.td so that they are not under the comment saying that they are for compatibility and silently ignored.

lld/ELF/MapFile.cpp

38

For 64-bit output, you want to write Address in 64 bit.

39

This and in other write* functions probably should print out a trailing "\n" so that you don't need to do that in writeMapFile2.

[ruiu]

Why do you want this feature by the way? I wonder if you have a plan to use that soon.

[ruiu]

I wonder if printing out meta info (such as all command line options, time stamp, etc.) as a header of a map file is useful. What do you think?

[• espindola]

291958

lld/ELF/CMakeLists.txt

add_lld_library(lldELF
   EhFrame.cpp
   Error.cpp
   GdbIndex.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
+  MapFile.cpp
   MarkLive.cpp
   Mips.cpp
   OutputSections.cpp
   Relocations.cpp
   ScriptParser.cpp
   Strings.cpp
   SymbolTable.cpp
   Symbols.cpp

lld/ELF/Config.h

struct Configuration {
   llvm::StringMap<uint64_t> SectionStartMap;
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef LTOAAPipeline;
   llvm::StringRef LTONewPmPasses;
+  llvm::StringRef MapFile;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   llvm::StringSet<> RetainSymbolsFile;
   std::string RPath;
   std::vector<VersionDefinition> VersionDefinitions;
   std::vector<llvm::StringRef> AuxiliaryList;
   std::vector<llvm::StringRef> SearchPaths;

lld/ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->WarnCommon = Args.hasArg(OPT_warn_common);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->LTOAAPipeline = getString(Args, OPT_lto_aa_pipeline);
   Config->LTONewPmPasses = getString(Args, OPT_lto_newpm_passes);
+  Config->MapFile = getString(Args, OPT_Map);
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
   Config->Sysroot = getString(Args, OPT_sysroot);
 
   Config->Optimize = getInteger(Args, OPT_O, 1);
   Config->LTOO = getInteger(Args, OPT_lto_O, 2);
   if (Config->LTOO > 3)
     error("invalid optimization level for LTO: " + getString(Args, OPT_lto_O));

lld/ELF/MapFile.h

+//===- MapFile.h ------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_ELF_MAPFILE_H
+#define LLD_ELF_MAPFILE_H
+
+#include "OutputSections.h"
+
+namespace lld {
+namespace elf {
+template <class ELFT>
+void writeMapFile(llvm::ArrayRef<OutputSectionBase *> OutputSections);
+}
+}
+
+#endif

lld/ELF/MapFile.cpp

+//===- MapFile.cpp --------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the -Map option. It shows lists in order and
+// hierarchically the output sections, input sections, input files and
+// symbol:
+//
+// Address  Size     Align Out     In      File    Symbol
+// =================================================================
+// 00201000 00000015     4 .text
+// 00201000 0000000e     4         .text
+// 00201000 0000000e     4                 test.o
+// 0020100e 00000000     0                         local
+// 00201005 00000000     0                         f(int)
+//
+//===----------------------------------------------------------------------===//
+
+#include "MapFile.h"
+#include "InputFiles.h"
+#include "Strings.h"
+
+#include "llvm/Support/FileUtilities.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+using namespace lld;
+using namespace lld::elf;
+
+static void writeOutSecLine(raw_fd_ostream &OS, uint64_t Address, uint64_t Size,
+                            uint64_t Align, StringRef Name) {
+  OS << format_hex_no_prefix(Address, 8) << ' ' << format_hex_no_prefix(Size, 8)
+     << ' ' << format("%5x ", Align) << left_justify(Name, 7);
+}
+
+static void writeInSecLine(raw_fd_ostream &OS, uint64_t Address, uint64_t Size,
+                           uint64_t Align, StringRef Name) {
+  // Pass an empty name to align the text to the correct column.
+  writeOutSecLine(OS, Address, Size, Align, "");
+  OS << ' ' << left_justify(Name, 7);
+}
+
+static void writeFileLine(raw_fd_ostream &OS, uint64_t Address, uint64_t Size,
+                          uint64_t Align, StringRef Name) {
+  // Pass an empty name to align the text to the correct column.
+  writeInSecLine(OS, Address, Size, Align, "");
+  OS << ' ' << left_justify(Name, 7);
+}
+
+static void writeSymbolLine(raw_fd_ostream &OS, uint64_t Address, uint64_t Size,
+                            StringRef Name) {
+  // Pass an empty name to align the text to the correct column.
+  writeFileLine(OS, Address, Size, 0, "");
+  OS << ' ' << left_justify(Name, 7);
+}
+
+template <class ELFT>
+static void writeMapFile2(int FD,
+                          ArrayRef<OutputSectionBase *> OutputSections) {
+  typedef typename ELFT::uint uintX_t;
+  raw_fd_ostream OS(FD, true);
+  OS << "Address  Size     Align Out     In      File    Symbol\n"
+     << "=================================================================\n";
+  for (OutputSectionBase *Sec : OutputSections) {
+    uintX_t VA = Sec->Addr;
+    writeOutSecLine(OS, VA, Sec->Size, Sec->Addralign, Sec->getName());
+    OS << '\n';
+    StringRef PrevName = "";
+    Sec->forEachInputSection([&](InputSectionData *S) {
+      const auto *IS = dyn_cast<InputSection<ELFT>>(S);
+      if (!IS)
+        return;
+      StringRef Name = IS->Name;
+      if (Name != PrevName) {
+        writeInSecLine(OS, VA + IS->OutSecOff, IS->getSize(), IS->Alignment,
+                       Name);
+        OS << '\n';
+        PrevName = Name;
+      }
+      elf::ObjectFile<ELFT> *File = IS->getFile();
+      if (!File)
+        return;
+      writeFileLine(OS, VA + IS->OutSecOff, IS->getSize(), IS->Alignment,
+                    toString(File));
+      OS << '\n';
+      ArrayRef<SymbolBody *> Syms = File->getSymbols();
+      for (SymbolBody *Sym : Syms) {
+        auto *DR = dyn_cast<DefinedRegular<ELFT>>(Sym);
+        if (!DR)
+          continue;
+        if (DR->Section != IS)
+          continue;
+        if (DR->isSection())
+          continue;
+        writeSymbolLine(OS, Sym->getVA<ELFT>(), Sym->getSize<ELFT>(),
+                        toString(*Sym));
+        OS << '\n';
+      }
+    });
+  }
+}
+
+template <class ELFT>
+void elf::writeMapFile(ArrayRef<OutputSectionBase *> OutputSections) {
+  StringRef MapFile = Config->MapFile;
+  if (MapFile.empty())
+    return;
+
+  // Create new file in same directory but with random name.
+  SmallString<128> TempPath;
+  int FD;
+  std::error_code EC =
+      sys::fs::createUniqueFile(Twine(MapFile) + ".tmp%%%%%%%", FD, TempPath);
+  if (EC)
+    fatal(EC.message());
+  FileRemover RAII(TempPath);
+  writeMapFile2<ELFT>(FD, OutputSections);
+  EC = sys::fs::rename(TempPath, MapFile);
+  if (EC)
+    fatal(EC.message());
+}
+
+template void elf::writeMapFile<ELF32LE>(ArrayRef<OutputSectionBase *>);
+template void elf::writeMapFile<ELF32BE>(ArrayRef<OutputSectionBase *>);
+template void elf::writeMapFile<ELF64LE>(ArrayRef<OutputSectionBase *>);
+template void elf::writeMapFile<ELF64BE>(ArrayRef<OutputSectionBase *>);

lld/ELF/OutputSections.h

public:
   // also resides in. This field is used to correctly compute file offset
   // of a section. When two sections share the same load segment, difference
   // between their file offsets should be equal to difference between their
   // virtual addresses. To compute some section offset we use the following
   // formula: Off = Off_first + VA - VA_first.
   OutputSectionBase *FirstInPtLoad = nullptr;
 
   virtual void finalize() {}
+  virtual void forEachInputSection(std::function<void(InputSectionData *)> F) {}
   virtual void assignOffsets() {}
   virtual void writeTo(uint8_t *Buf) {}
   virtual ~OutputSectionBase() = default;
 
   StringRef Name;
 
   // The following fields correspond to Elf_Shdr members.
   uint64_t Size = 0;
public:
   typedef typename ELFT::uint uintX_t;
   OutputSection(StringRef Name, uint32_t Type, uintX_t Flags);
   void addSection(InputSectionData *C) override;
   void sort(std::function<int(InputSection<ELFT> *S)> Order);
   void sortInitFini();
   void sortCtorsDtors();
   void writeTo(uint8_t *Buf) override;
   void finalize() override;
+  void forEachInputSection(std::function<void(InputSectionData *)> F) override;
   void assignOffsets() override;
   Kind getKind() const override { return Regular; }
   static bool classof(const OutputSectionBase *B) {
     return B->getKind() == Regular;
   }
   std::vector<InputSection<ELFT> *> Sections;
 
   // Location in the output buffer.
template <class ELFT> class EhOutputSection final : public OutputSectionBase {
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
 
 public:
   EhOutputSection();
   void writeTo(uint8_t *Buf) override;
   void finalize() override;
   bool empty() const { return Sections.empty(); }
+  void forEachInputSection(std::function<void(InputSectionData *)> F) override;
 
   void addSection(InputSectionData *S) override;
   Kind getKind() const override { return EHFrame; }
   static bool classof(const OutputSectionBase *B) {
     return B->getKind() == EHFrame;
   }
 
   size_t NumFdes = 0;

lld/ELF/OutputSections.cpp

void OutputSection<ELFT>::addSection(InputSectionData *C) {
   S->OutSec = this;
   this->updateAlignment(S->Alignment);
   // Keep sh_entsize value of the input section to be able to perform merging
   // later during a final linking using the generated relocatable object.
   if (Config->Relocatable && (S->Flags & SHF_MERGE))
     this->Entsize = S->Entsize;
 }
 
+template <class ELFT>
+void OutputSection<ELFT>::forEachInputSection(
+    std::function<void(InputSectionData *)> F) {
+  for (InputSection<ELFT> *S : Sections)
+    F(S);
+}
+
 // This function is called after we sort input sections
 // and scan relocations to setup sections' offsets.
 template <class ELFT> void OutputSection<ELFT>::assignOffsets() {
   uintX_t Off = this->Size;
   for (InputSection<ELFT> *S : Sections) {
     Off = alignTo(Off, S->Alignment);
     S->OutSecOff = Off;
     Off += S->getSize();
template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
   // can write arbitrary bytes to the output. Process them if any.
   Script<ELFT>::X->writeDataBytes(this->Name, Buf);
 }
 
 template <class ELFT>
 EhOutputSection<ELFT>::EhOutputSection()
     : OutputSectionBase(".eh_frame", SHT_PROGBITS, SHF_ALLOC) {}
 
+template <class ELFT>
+void EhOutputSection<ELFT>::forEachInputSection(
+    std::function<void(InputSectionData *)> F) {
+  for (EhInputSection<ELFT> *S : Sections)
+    F(S);
+}
+
 // Search for an existing CIE record or create a new one.
 // CIE records from input object files are uniquified by their contents
 // and where their relocations point to.
 template <class ELFT>
 template <class RelTy>
 CieRecord *EhOutputSection<ELFT>::addCie(EhSectionPiece &Piece,
                                          ArrayRef<RelTy> Rels) {
   auto *Sec = cast<EhInputSection<ELFT>>(Piece.ID);

lld/ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "LinkerScript.h"
+#include "MapFile.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "llvm/ADT/StringMap.h"
template <class ELFT> void Writer<ELFT>::run() {
   }
 
   // Backfill .note.gnu.build-id section content. This is done at last
   // because the content is usually a hash value of the entire output file.
   writeBuildId();
   if (ErrorCount)
     return;
 
+  writeMapFile<ELFT>(OutputSections);
   if (auto EC = Buffer->commit())
     error(EC, "failed to write to the output file");
 
   // Flush the output streams and exit immediately. A full shutdown
   // is a good test that we are keeping track of all allocated memory,
   // but actually freeing it is a waste of time in a regular linker run.
   if (Config->ExitEarly)
     exitLld(0);

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

+foo:
+nop
+.global bar
+bar:
+nop
+.section .text.zed,"ax",@progbits
+.global zed
+zed:

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

+.global bah
+bah:

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

+.global baz
+baz:
+        retq

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 -Map=%t.map
+// RUN: FileCheck %s < %t.map
+
+.global _start
+_start:
+        call baz
+.global _Z1fi
+_Z1fi:
+.cfi_startproc
+.cfi_endproc
+nop
+.weak bar
+bar:
+.long bar - .
+.long zed - .
+local:
+.comm   common,4,4
+
+// CHECK:      Address  Size     Align Out     In      File    Symbol
+// CHECK-NEXT: =================================================================
+// CHECK-NEXT: 00200158 00000030     8 .eh_frame
+// CHECK-NEXT: 00201000 00000015     4 .text
+// CHECK-NEXT: 00201000 0000000e     4         .text
+// CHECK-NEXT: 00201000 0000000e     4                 {{.*}}/map-file.s.tmp1.o
+// CHECK-NEXT: 0020100e 00000000     0                         local
+// CHECK-NEXT: 00201005 00000000     0                         f(int)
+// CHECK-NEXT: 00201000 00000000     0                         _start
+// CHECK-NEXT: 00201010 00000002     4                 {{.*}}/map-file.s.tmp2.o
+// CHECK-NEXT: 00201010 00000000     0                         foo
+// CHECK-NEXT: 00201011 00000000     0                         bar
+// CHECK-NEXT: 00201012 00000000     1         .text.zed
+// CHECK-NEXT: 00201012 00000000     1                 {{.*}}/map-file.s.tmp2.o
+// CHECK-NEXT: 00201012 00000000     0                         zed
+// CHECK-NEXT: 00201014 00000000     4         .text
+// CHECK-NEXT: 00201014 00000000     4                 {{.*}}/map-file.s.tmp3.o
+// CHECK-NEXT: 00201014 00000000     0                         bah
+// CHECK-NEXT: 00201014 00000001     4                 {{.*}}/map-file.s.tmp4.a(map-file.s.tmp4.o)
+// CHECK-NEXT: 00201014 00000000     0                         baz
+// CHECK-NEXT: 00202000 00000004     4 .bss
+// CHECK-NEXT: 00202000 00000004     4         COMMON
+// CHECK-NEXT: 00000000 00000008     1 .comment
+// CHECK-NEXT: 00000000 000000f0     8 .symtab
+// CHECK-NEXT: 00000000 000000f0     8         .symtab
+// CHECK-NEXT: 00000000 00000039     1 .shstrtab
+// CHECK-NEXT: 00000000 00000039     1         .shstrtab
+// CHECK-NEXT: 00000000 0000002f     1 .strtab
+// CHECK-NEXT: 00000000 0000002f     1         .strtab