COFF: Change the /lldmap output format to be more like the ELF linker.

[ruiu]

lld/COFF/Chunks.h

190 ↗

(On Diff #84413)

Maybe we should just make File public?

lld/COFF/MapFile.cpp

37 ↗

(On Diff #84413)

It is unfortunate that you had to copy that much code, but honestly I have no good idea to avoid that because the code here is slightly different at a lot of places.

67 ↗

(On Diff #84413)

If you hard-code Width 8, please remove that variable and inline.

[pcc]

lld/COFF/MapFile.cpp

37 ↗

(On Diff #84413)

Right, the only real common part here is these 30 or so lines, and it didn't seem worth splitting that out into a library.

[pcc]

• Address review comments

[ruiu]

LGTM

lld/test/COFF/lldmap.test

10 ↗

(On Diff #84420)

You want to remove / so that this test isn't picky about path separator difference.

lld/trunk/COFF/CMakeLists.txt

add_lld_library(lldCOFF
   Chunks.cpp
   DLL.cpp
   Driver.cpp
   DriverUtils.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
   Librarian.cpp
+  MapFile.cpp
   MarkLive.cpp
   ModuleDef.cpp
   PDB.cpp
   Strings.cpp
   SymbolTable.cpp
   Symbols.cpp
   Writer.cpp
 

lld/trunk/COFF/Chunks.h

public:
   SectionChunk *Repl;
 
   // The CRC of the contents as described in the COFF spec 4.5.5.
   // Auxiliary Format 5: Section Definitions. Used for ICF.
   uint32_t Checksum = 0;
 
   const coff_section *Header;
 
-private:
-  // A file this chunk was created from.
+  // The file that this chunk was created from.
   ObjectFile *File;
 
+private:
   StringRef SectionName;
   std::vector<SectionChunk *> AssocChildren;
   llvm::iterator_range<const coff_relocation *> Relocs;
   size_t NumRelocs;
 
   // Used by the garbage collector.
   bool Live;
 

lld/trunk/COFF/Config.h

struct Configuration {
   StringRef ManifestFile;
 
   // Used for /failifmismatch.
   std::map<StringRef, StringRef> MustMatch;
 
   // Used for /alternatename.
   std::map<StringRef, StringRef> AlternateNames;
 
+  // Used for /lldmap.
+  std::string MapFile;
+
   uint64_t ImageBase = -1;
   uint64_t StackReserve = 1024 * 1024;
   uint64_t StackCommit = 4096;
   uint64_t HeapReserve = 1024 * 1024;
   uint64_t HeapCommit = 4096;
   uint32_t MajorImageVersion = 0;
   uint32_t MinorImageVersion = 0;
   uint32_t MajorOSVersion = 6;

lld/trunk/COFF/Driver.cpp

if (Args.hasArg(OPT_nxcompat_no))
     Config->NxCompat = false;
   if (Args.hasArg(OPT_tsaware_no))
     Config->TerminalServerAware = false;
   if (Args.hasArg(OPT_nosymtab))
     Config->WriteSymtab = false;
   Config->DumpPdb = Args.hasArg(OPT_dumppdb);
   Config->DebugPdb = Args.hasArg(OPT_debugpdb);
 
+  Config->MapFile = getMapFile(Args);
+
   // Create a list of input files. Files can be given as arguments
   // for /defaultlib option.
   std::vector<MemoryBufferRef> MBs;
   for (auto *Arg : Args.filtered(OPT_INPUT))
     if (Optional<StringRef> Path = findFile(Arg->getValue()))
       enqueuePath(*Path);
   for (auto *Arg : Args.filtered(OPT_defaultlib))
     if (Optional<StringRef> Path = findLib(Arg->getValue()))
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
 
   // Identify identical COMDAT sections to merge them.
   if (Config->DoICF)
     doICF(Symtab.getChunks());
 
   // Write the result.
   writeResult(&Symtab);
 
-  // Create a symbol map file containing symbol VAs and their names
-  // to help debugging.
-  std::string MapFile = getMapFile(Args);
-  if (!MapFile.empty()) {
-    std::error_code EC;
-    raw_fd_ostream Out(MapFile, EC, OpenFlags::F_Text);
-    if (EC)
-      fatal(EC, "could not create the symbol map " + MapFile);
-    Symtab.printMap(Out);
-  }
-
   // Call exit to avoid calling destructors.
   exit(0);
 }
 
 } // namespace coff
 } // namespace lld

lld/trunk/COFF/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_COFF_MAPFILE_H
+#define LLD_COFF_MAPFILE_H
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace lld {
+namespace coff {
+class OutputSection;
+void writeMapFile(llvm::ArrayRef<OutputSection *> OutputSections);
+}
+}
+
+#endif

lld/trunk/COFF/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 /lldmap 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 "Error.h"
+#include "Symbols.h"
+#include "Writer.h"
+
+#include "llvm/Support/FileUtilities.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+using namespace lld;
+using namespace lld::coff;
+
+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);
+}
+
+static void writeSectionChunk(raw_fd_ostream &OS, const SectionChunk *SC,
+                              StringRef &PrevName) {
+  StringRef Name = SC->getSectionName();
+  if (Name != PrevName) {
+    writeInSecLine(OS, SC->getRVA(), SC->getSize(), SC->getAlign(), Name);
+    OS << '\n';
+    PrevName = Name;
+  }
+  coff::ObjectFile *File = SC->File;
+  if (!File)
+    return;
+  writeFileLine(OS, SC->getRVA(), SC->getSize(), SC->getAlign(),
+                toString(File));
+  OS << '\n';
+  ArrayRef<SymbolBody *> Syms = File->getSymbols();
+  for (SymbolBody *Sym : Syms) {
+    auto *DR = dyn_cast<DefinedRegular>(Sym);
+    if (!DR || DR->getChunk() != SC ||
+        DR->getCOFFSymbol().isSectionDefinition())
+      continue;
+    writeSymbolLine(OS, DR->getRVA(), SC->getSize(), toString(*Sym));
+    OS << '\n';
+  }
+}
+
+static void writeMapFile2(int FD,
+                          ArrayRef<OutputSection *> OutputSections) {
+  raw_fd_ostream OS(FD, true);
+  OS << left_justify("Address", 8) << ' ' << left_justify("Size", 8)
+     << ' ' << left_justify("Align", 5) << ' ' << left_justify("Out", 7) << ' '
+     << left_justify("In", 7) << ' ' << left_justify("File", 7) << " Symbol\n";
+  for (OutputSection *Sec : OutputSections) {
+    uint32_t VA = Sec->getRVA();
+    writeOutSecLine(OS, VA, Sec->getVirtualSize(), /*Align=*/PageSize,
+                    Sec->getName());
+    OS << '\n';
+    StringRef PrevName = "";
+    for (Chunk *C : Sec->getChunks())
+      if (const auto *SC = dyn_cast<SectionChunk>(C))
+        writeSectionChunk(OS, SC, PrevName);
+  }
+}
+
+void coff::writeMapFile(ArrayRef<OutputSection *> 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(FD, OutputSections);
+  EC = sys::fs::rename(TempPath, MapFile);
+  if (EC)
+    fatal(EC.message());
+}

lld/trunk/COFF/SymbolTable.h

public:
 
   // Occasionally we have to resolve an undefined symbol to its
   // mangled symbol. This function tries to find a mangled name
   // for U from the symbol table, and if found, set the symbol as
   // a weak alias for U.
   void mangleMaybe(SymbolBody *B);
   StringRef findMangle(StringRef Name);
 
-  // Print a layout map to OS.
-  void printMap(llvm::raw_ostream &OS);
-
   // Build a set of COFF objects representing the combined contents of
   // BitcodeFiles and add them to the symbol table. Called after all files are
   // added and before the writer writes results to a file.
   void addCombinedLTOObjects();
 
   // The writer needs to handle DLL import libraries specially in
   // order to create the import descriptor table.
   std::vector<ImportFile *> ImportFiles;

lld/trunk/COFF/SymbolTable.cpp

void SymbolTable::mangleMaybe(SymbolBody *B) {
   if (!Alias.empty())
     U->WeakAlias = addUndefined(Alias);
 }
 
 SymbolBody *SymbolTable::addUndefined(StringRef Name) {
   return addUndefined(Name, nullptr, false)->body();
 }
 
-void SymbolTable::printMap(llvm::raw_ostream &OS) {
-  for (ObjectFile *File : ObjectFiles) {
-    OS << toString(File) << ":\n";
-    for (SymbolBody *Body : File->getSymbols())
-      if (auto *R = dyn_cast<DefinedRegular>(Body))
-        if (R->getChunk()->isLive())
-          OS << Twine::utohexstr(Config->ImageBase + R->getRVA())
-             << " " << R->getName() << "\n";
-  }
-}
-
 void SymbolTable::addCombinedLTOObjects() {
   if (BitcodeFiles.empty())
     return;
 
   // Create an object file and add it to the symbol table by replacing any
   // DefinedBitcode symbols with the definitions in the object file.
   LTOCodeGenerator CG(BitcodeFile::Context);
   CG.setOptLevel(Config->LTOOptLevel);

lld/trunk/COFF/Writer.h

 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_WRITER_H
 #define LLD_COFF_WRITER_H
 
+#include "Chunks.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Object/COFF.h"
+#include <cstdint>
 #include <vector>
 
 namespace lld {
 namespace coff {
 class SymbolTable;
 
+static const int PageSize = 4096;
+
 void writeResult(SymbolTable *T);
 
+// OutputSection represents a section in an output file. It's a
+// container of chunks. OutputSection and Chunk are 1:N relationship.
+// Chunks cannot belong to more than one OutputSections. The writer
+// creates multiple OutputSections and assign them unique,
+// non-overlapping file offsets and RVAs.
+class OutputSection {
+public:
+  OutputSection(llvm::StringRef N) : Name(N), Header({}) {}
+  void setRVA(uint64_t);
+  void setFileOffset(uint64_t);
+  void addChunk(Chunk *C);
+  llvm::StringRef getName() { return Name; }
+  std::vector<Chunk *> &getChunks() { return Chunks; }
+  void addPermissions(uint32_t C);
+  void setPermissions(uint32_t C);
+  uint32_t getPermissions() { return Header.Characteristics & PermMask; }
+  uint32_t getCharacteristics() { return Header.Characteristics; }
+  uint64_t getRVA() { return Header.VirtualAddress; }
+  uint64_t getFileOff() { return Header.PointerToRawData; }
+  void writeHeaderTo(uint8_t *Buf);
+
+  // Returns the size of this section in an executable memory image.
+  // This may be smaller than the raw size (the raw size is multiple
+  // of disk sector size, so there may be padding at end), or may be
+  // larger (if that's the case, the loader reserves spaces after end
+  // of raw data).
+  uint64_t getVirtualSize() { return Header.VirtualSize; }
+
+  // Returns the size of the section in the output file.
+  uint64_t getRawSize() { return Header.SizeOfRawData; }
+
+  // Set offset into the string table storing this section name.
+  // Used only when the name is longer than 8 bytes.
+  void setStringTableOff(uint32_t V) { StringTableOff = V; }
+
+  // N.B. The section index is one based.
+  uint32_t SectionIndex = 0;
+
+private:
+  llvm::StringRef Name;
+  llvm::object::coff_section Header;
+  uint32_t StringTableOff = 0;
+  std::vector<Chunk *> Chunks;
+};
+
 }
 }
 
 #endif

lld/trunk/COFF/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 "DLL.h"
 #include "Error.h"
 #include "InputFiles.h"
+#include "MapFile.h"
 #include "Memory.h"
 #include "PDB.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "lld/Core/Parallel.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"

 using namespace llvm;
 using namespace llvm::COFF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::coff;
 
-static const int PageSize = 4096;
 static const int SectorSize = 512;
 static const int DOSStubSize = 64;
 static const int NumberfOfDataDirectory = 16;
 
 namespace {
 
 class DebugDirectoryChunk : public Chunk {
 public:

 };
 } // anonymous namespace
 
 namespace lld {
 namespace coff {
 
 void writeResult(SymbolTable *T) { Writer(T).run(); }
 
-// OutputSection represents a section in an output file. It's a
-// container of chunks. OutputSection and Chunk are 1:N relationship.
-// Chunks cannot belong to more than one OutputSections. The writer
-// creates multiple OutputSections and assign them unique,
-// non-overlapping file offsets and RVAs.
-class OutputSection {
-public:
-  OutputSection(StringRef N) : Name(N), Header({}) {}
-  void setRVA(uint64_t);
-  void setFileOffset(uint64_t);
-  void addChunk(Chunk *C);
-  StringRef getName() { return Name; }
-  std::vector<Chunk *> &getChunks() { return Chunks; }
-  void addPermissions(uint32_t C);
-  void setPermissions(uint32_t C);
-  uint32_t getPermissions() { return Header.Characteristics & PermMask; }
-  uint32_t getCharacteristics() { return Header.Characteristics; }
-  uint64_t getRVA() { return Header.VirtualAddress; }
-  uint64_t getFileOff() { return Header.PointerToRawData; }
-  void writeHeaderTo(uint8_t *Buf);
-
-  // Returns the size of this section in an executable memory image.
-  // This may be smaller than the raw size (the raw size is multiple
-  // of disk sector size, so there may be padding at end), or may be
-  // larger (if that's the case, the loader reserves spaces after end
-  // of raw data).
-  uint64_t getVirtualSize() { return Header.VirtualSize; }
-
-  // Returns the size of the section in the output file.
-  uint64_t getRawSize() { return Header.SizeOfRawData; }
-
-  // Set offset into the string table storing this section name.
-  // Used only when the name is longer than 8 bytes.
-  void setStringTableOff(uint32_t V) { StringTableOff = V; }
-
-  // N.B. The section index is one based.
-  uint32_t SectionIndex = 0;
-
-private:
-  StringRef Name;
-  coff_section Header;
-  uint32_t StringTableOff = 0;
-  std::vector<Chunk *> Chunks;
-};
-
 void OutputSection::setRVA(uint64_t RVA) {
   Header.VirtualAddress = RVA;
   for (Chunk *C : Chunks)
     C->setRVA(C->getRVA() + RVA);
 }
 
 void OutputSection::setFileOffset(uint64_t Off) {
   // If a section has no actual data (i.e. BSS section), we want to
void Writer::run() {
   fixSafeSEHSymbols();
   writeSections();
   sortExceptionTable();
   writeBuildId();
 
   if (!Config->PDBPath.empty())
     createPDB(Config->PDBPath, Symtab, SectionTable, BuildId->DI);
 
+  writeMapFile(OutputSections);
+
   if (auto EC = Buffer->commit())
     fatal(EC, "failed to write the output file");
 }
 
 static StringRef getOutputSection(StringRef Name) {
   StringRef S = Name.split('$').first;
   auto It = Config->Merge.find(S);
   if (It == Config->Merge.end())

lld/trunk/test/COFF/lldmap.test

 # RUN: yaml2obj < %p/Inputs/ret42.yaml > %t.obj
 # RUN: lld-link /out:%t.exe /entry:main /lldmap:%T/foo.map %t.obj
 # RUN: FileCheck %s < %T/foo.map
 # RUN: lld-link /out:%T/bar.exe /entry:main /lldmap %t.obj
 # RUN: FileCheck %s < %T/bar.map
 
-# CHECK: .obj:
-# CHECK-NEXT: 140001000 .text$mn
-# CHECK-NEXT: 140001000 .data
-# CHECK-NEXT: 140001000 main
+# CHECK:      Address  Size     Align Out     In      File    Symbol
+# CHECK-NEXT: 00001000 00000006  1000 .text  
+# CHECK-NEXT: 00001000 00000006    10         .text$mn
+# CHECK-NEXT: 00001000 00000006    10                 {{.*}}lldmap.test.tmp.obj
+# CHECK-NEXT: 00001000 00000006     0                         main   

lld/trunk/test/COFF/lto-parallel.ll

 ; RUN: llvm-as -o %t.obj %s
 ; RUN: lld-link /out:%t.exe /entry:foo /include:bar /opt:lldltojobs=2 /subsystem:console /lldmap:%t.map %t.obj
 ; RUN: FileCheck %s < %t.map
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
-; CHECK: <lto object>:
-; CHECK: foo
+; CHECK: <lto object>
+; CHECK-NEXT: foo
 define void @foo() {
   call void @bar()
   ret void
 }
 
-; CHECK: <lto object>:
-; CHECK: bar
+; CHECK: <lto object>
+; CHECK-NEXT: bar
 define void @bar() {
   call void @foo()
   ret void
 }

lld/trunk/test/COFF/weak-external.test

 # RUN: yaml2obj %s > %t.obj
 # RUN: llvm-as -o %t.lto.obj %S/Inputs/weak-external.ll
 # RUN: lld-link /out:%t1.exe /entry:g /subsystem:console %t.obj
 # RUN: lld-link /out:%t2.exe /entry:g /subsystem:console /lldmap:%t2.map %t.obj %t.lto.obj
 # RUN: FileCheck %s < %t2.map
 
-# CHECK: <lto object>:
-# CHECK-NOT: :
-# CHECK: {{ g$}}
+# CHECK: <lto object>
+# CHECK-NEXT: 0 g
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: [  ]
 sections:
   - Name:            '.text'
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]

lld/trunk/test/COFF/weak-external3.test

 # RUN: yaml2obj %s > %t.obj
 # RUN: llvm-as -o %t.lto.obj %S/Inputs/weak-external3.ll
 # RUN: lld-link /out:%t1.exe /entry:f /subsystem:console /lldmap:%t1.map %t.lto.obj
 # RUN: FileCheck --check-prefix=CHECK1 %s < %t1.map
 # RUN: lld-link /out:%t2.exe /entry:f /subsystem:console /lldmap:%t2.map %t.obj %t.lto.obj
 # RUN: FileCheck --check-prefix=CHECK2 %s < %t2.map
 
-# CHECK1: <lto object>:
-# CHECK1-NOT: :
-# CHECK1: {{ g$}}
+# CHECK1: <lto object>
+# CHECK1-NEXT: 0 g
 
-# CHECK2: weak-external3{{.*}}:
-# CHECK2-NOT: :
-# CHECK2: {{ f$}}
+# CHECK2: weak-external3.test.tmp.obj
+# CHECK2-NEXT: 0 f
 
 --- !COFF
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: [  ]
 sections:
   - Name:            '.text'
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]