[lld][COFF] Add support for /map

[saudi]

Summary

We use an external (commercial) software package to modify the generated executable as a post-process.
That software requires a map file with the same format as generated by link.exe /MAP.

This implementation is based on observation from the output of link.exe's map files.
We didn't need support for the /MAPINFO option.

Enhancements from the lldmap counterpart:

• Removed duplicates of symbols (that is duplicate Symbol* values)
• Added output for thunk symbols for dllimport stubs

I've also modified the default file name for /lldmap to use the .lldmap extension (instead of .map). This is to avoid conflict if both /map and /lldmap are used.

[ruiu]

Thank you for the patch. Overall, I think it is a good thing to add link.exe-compatible /map file output to lld.

lld/COFF/CMakeLists.txt

19–20

Except a few features, everything in lld/COFF is Microsoft-compatible, so adding a MS suffix feels a bit odd to me. You probably should rename existing MapFile.cpp to LLDMapFile.cpp and then place your file as MapFile.cpp.

lld/COFF/Config.h

188

Ditto -- rename this to lldMapFile and name yours mapFile

lld/COFF/Driver.cpp

720

We should avoid changing the suffix because it breaks backward compatibility. Instead, you may want to add a warning if /map and /lldmap has the same filename as an output file.

lld/COFF/MapFileMS.cpp

9 ↗

(On Diff #230503)

It is a bit odd that we intend to print out in a format that is not exactly the same as Microsoft's. What is the difference? Can't we output the exact same output?

[saudi]

I changed the code quite a bit.

• Better match the map file format (added "entry point" line, separate list for static symbols, made header addresses relative to the section instead of absolute)
• Optimized (parallel sort of symbols etc...), added timers for feedback with /time option
• Applied fixes previously asked by Rui Ueyama (renaming mapFileMS to mapFile, ...)

[saudi]

lld/COFF/MapFileMS.cpp

9 ↗

(On Diff #230503)

I used the same format observed from MS generated map files.
The remaining differences are the "f" and "i" flags shown in some of the symbol lines from link.exe, I couldn't figure out what they mean.
I fixed the comment, as it is not supposed to be just "close to" the link format.

[saudi]

Ping! :)

[saudi]

Ping!

[rnk]

A couple of nits, but I think it looks pretty good, thanks!

lld/COFF/MapFile.cpp

62

Is v.erase(end, v.end()) not more idiomatic?

lld/test/COFF/map.test

28

Please add some absolute symbols with "negative" RVAs to the inputs, since those are an interesting edge case in the sorting.

[saudi]

For this update, I followed Reid's suggestions:

• replaced std::resize() -> std::erase()
• Modified the test to include symbol of type DefinedAbsolute

I also added a missing null-check

[ruiu]

Overall looking good.

lld/COFF/Driver.cpp

1571–1572

nit: You can omit !config->mapFile.empty() && because if A==B and A=="", B must not be empty.

another nit: we usually do A != "" instead of !A.empty if A is StringRef.

1575

config->lldmapFile == ""

lld/COFF/LLDMapFile.cpp

128

nit: please make sure that a source file ends with \n instead of some other byte.

lld/COFF/MapFile.cpp

68–69

If you are adding config->imageBase to both A and B before comparing A < B, you don't have to add that at all, do you?

239

TDS -> tds, but I guess you can remove this local variable and use config->timestamp directly.

240

FormattedTime -> formattedTime

241

strftime's %c is locale-aware, so the exact output string of the function is not predictable. It may be in your local language (e.g. 2020年3月15日) depending on the language settings, and even for US English, I believe it's different depending on libc. That's not suitable for machine processing.

What is the output of MSVC link in the US English setting? We should always format a timestamp in that format whatever the user's language setting is.

[saudi]

Implemented the fixes suggested by Rui Ueyama.

Notes on the timestamp:
I replaced the strftime call with a local implementation that reproduces what link.exe outputs.
Assuming link.exe was built using MSVC, I suspect that its implementation uses strftime("%c"), as it matches the format from Visual C++'s CRT library using the "C" locale.
I couldn't find a way on my machine to have link.exe output differently : my machine is configured as French, but link.exe's /map outputs english message (e.g. "Fri Mar 6 11:50:39 2020").

[saudi]

Updated diff for one missing fix

[saudi]

lld/COFF/MapFile.cpp

68–69

This was to support underflowing that happens with DefinedAbsolute symbols (RVA = VA - imageBase).

[ruiu]

LGTM

[amccarth]

Sorry, somehow I'd missed that I'd been added as a reviewer. This looks good to me. (Though I do have a couple questions in the inline comments.)

lld/COFF/LLDMapFile.cpp

69

Stupid question: Is it possible for two symbols to share an address? If so, should this be a std::stable_sort for deterministic build outputs?

lld/COFF/MapFile.cpp

61

Is the lambda necessary in this sort? Don't std::pairs naturally use lexicographic ordering?

Do all the Defined *s live inside a single object l(ike an array)? If not, then comparing pointers to individual ones is technically undefined behavior though it's very likely to work as expected.

[saudi]

lld/COFF/LLDMapFile.cpp

69

There definitely are symbols that share an address.
Note that LLDMapFile.cpp was previously MapFile.cpp which was renamed and mostly unchanged (just adapted for the rename).
But I don't mind fixing it on top, should I do that in this commit?

lld/COFF/MapFile.cpp

61

Indeed, the Define*s come from various ObjFiles so we can't expect them to come from the same array.

This sort is just to regroup entries with the same pointer value, for std::unique to work.
I just noticed:

• comparing the entire pair is not necessary here (we just need to regroup same pointers)
• we just need to compare the value of the pointers, so maybe converting to size_t would be more relevant?

I guess the sort could become :

parallelSort(v, [](const auto &a, const auto &b) {
  return (size_t)a.first < (size_t)b.first;
});

[amccarth]

Thanks for answering my questions.

lld/COFF/LLDMapFile.cpp

69

I think switching to stable_sort should probably be a separate commit. That way, if I'm wrong, it can be rolled back without affecting anything else.

lld/COFF/MapFile.cpp

61

Casting to size_t is fine, but I don't think it's necessary given how you answered the first question here.

I always get nervous when I see a custom comparator that ignores some of the fields--I worry that somehow it's not providing a strict weak total ordering. But I think it's fine here.

That said, you could just use std::lexicographical_compare rather than a lambda.

[ruiu]

lld/COFF/LLDMapFile.cpp

69

Good point. You can do either in this patch or in a follow-up patch, but this should definitely be stable_sort for build reproducibility. Our promise to users is that as long as you are using the exact same version of lld and feeding the exact same set of files and command line options, lld's outputs will be the same no matter what the host system is. For that reason we generally avoid unstable sort.

lld/COFF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(COFFOptionsTableGen)
 
 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldCOFF
   Chunks.cpp
   DebugTypes.cpp
   DLL.cpp
   Driver.cpp
   DriverUtils.cpp
   ICF.cpp
   InputFiles.cpp
+  LLDMapFile.cpp
   LTO.cpp
   MapFile.cpp
   MarkLive.cpp
   MinGW.cpp
   PDB.cpp
   SymbolTable.cpp
   Symbols.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}

lld/COFF/Config.h

struct Configuration {
 
   // Used for /alternatename.
   std::map<StringRef, StringRef> alternateNames;
 
   // Used for /order.
   llvm::StringMap<int> order;
 
   // Used for /lldmap.
+  std::string lldmapFile;
+
+  // Used for /map.
   std::string mapFile;
 
   // Used for /thinlto-index-only:
   llvm::StringRef thinLTOIndexOnlyArg;
 
   // Used for /thinlto-object-prefix-replace:
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOPrefixReplace;
 
   // Used for /thinlto-object-suffix-replace:

lld/COFF/Driver.cpp

static unsigned parseDebugTypes(const opt::InputArgList &args) {
   if (args.hasArg(OPT_driver))
     debugTypes |= static_cast<unsigned>(DebugType::PData);
   if (args.hasArg(OPT_profile))
     debugTypes |= static_cast<unsigned>(DebugType::Fixup);
 
   return debugTypes;
 }
 
-static std::string getMapFile(const opt::InputArgList &args) {
-  auto *arg = args.getLastArg(OPT_lldmap, OPT_lldmap_file);
+static std::string getMapFile(const opt::InputArgList &args,
+                              opt::OptSpecifier os, opt::OptSpecifier osFile) {
+  auto *arg = args.getLastArg(os, osFile);
   if (!arg)
     return "";
-  if (arg->getOption().getID() == OPT_lldmap_file)
+  if (arg->getOption().getID() == osFile.getID())
     return arg->getValue();
 
-  assert(arg->getOption().getID() == OPT_lldmap);
+  assert(arg->getOption().getID() == os.getID());
   StringRef outFile = config->outputFile;
   return (outFile.substr(0, outFile.rfind('.')) + ".map").str();
 }
 
 static std::string getImplibPath() {
   if (!config->implib.empty())
     return std::string(config->implib);
   SmallString<128> out = StringRef(config->outputFile);
   sys::path::replace_extension(out, ".lib");
   return std::string(out.str());
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   config->debugGHashes = debug == DebugKind::GHash;
   config->debugSymtab = debug == DebugKind::Symtab;
 
   // Don't warn about long section names, such as .debug_info, for mingw or when
   // -debug:dwarf is requested.
   if (config->mingw || config->debugDwarf)
     config->warnLongSectionNames = false;
 
-  config->mapFile = getMapFile(args);
+  config->lldmapFile = getMapFile(args, OPT_lldmap, OPT_lldmap_file);
+  config->mapFile = getMapFile(args, OPT_map, OPT_map_file);
+
+  if (config->lldmapFile != "" && config->lldmapFile == config->mapFile) {
+    warn("/lldmap and /map have the same output file '" + config->mapFile +
+         "'.\n>>> ignoring /lldmap");
+    config->lldmapFile.clear();
+  }
 
   if (config->incremental && args.hasArg(OPT_profile)) {
     warn("ignoring '/incremental' due to '/profile' specification");
     config->incremental = false;
   }
 
   if (config->incremental && args.hasArg(OPT_order)) {
     warn("ignoring '/incremental' due to '/order' specification");

lld/COFF/LLDMapFile.h

+//===- LLDMapFile.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_COFF_LLDMAPFILE_H
+#define LLD_COFF_LLDMAPFILE_H
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace lld {
+namespace coff {
+class OutputSection;
+void writeLLDMapFile(llvm::ArrayRef<OutputSection *> outputSections);
+}
+}
+
+#endif

lld/COFF/LLDMapFile.cpp

-//===- MapFile.cpp --------------------------------------------------------===//
+//===- LLDMapFile.cpp -----------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // 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     File    Symbol
 //   00201000 00000015     4 .text
 //   00201000 0000000e     4         test.o:(.text)
 //   0020100e 00000000     0                 local
 //   00201005 00000000     0                 f(int)
 //
 //===----------------------------------------------------------------------===//
 
-#include "MapFile.h"
+#include "LLDMapFile.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Threads.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;

 static SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> syms) {
   SymbolMapTy ret;
   for (DefinedRegular *s : syms)
     ret[s->getChunk()].push_back(s);
 
   // Sort symbols by address.
   for (auto &it : ret) {
     SmallVectorImpl<DefinedRegular *> &v = it.second;
-    std::sort(v.begin(), v.end(), [](DefinedRegular *a, DefinedRegular *b) {
+    std::stable_sort(v.begin(), v.end(), [](DefinedRegular *a, DefinedRegular *b) {
       return a->getRVA() < b->getRVA();
     });
   }
   return ret;
 }
 
 // Construct a map from symbols to their stringified representations.
 static DenseMap<DefinedRegular *, std::string>
 getSymbolStrings(ArrayRef<DefinedRegular *> syms) {
   std::vector<std::string> str(syms.size());
   parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
     writeHeader(os, syms[i]->getRVA(), 0, 0);
     os << indent16 << toString(*syms[i]);
   });
 
   DenseMap<DefinedRegular *, std::string> ret;
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     ret[syms[i]] = std::move(str[i]);
   return ret;
 }
 
-void lld::coff::writeMapFile(ArrayRef<OutputSection *> outputSections) {
-  if (config->mapFile.empty())
+void lld::coff::writeLLDMapFile(ArrayRef<OutputSection *> outputSections) {
+  if (config->lldmapFile.empty())
     return;
 
   std::error_code ec;
-  raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None);
+  raw_fd_ostream os(config->lldmapFile, ec, sys::fs::OF_None);
   if (ec)
-    fatal("cannot open " + config->mapFile + ": " + ec.message());
+    fatal("cannot open " + config->lldmapFile + ": " + ec.message());
 
   // Collect symbol info that we want to print out.
   std::vector<DefinedRegular *> syms = getSymbols();
   SymbolMapTy sectionSyms = getSectionSyms(syms);
   DenseMap<DefinedRegular *, std::string> symStr = getSymbolStrings(syms);
 
   // Print out the header line.
   os << "Address  Size     Align Out     In      Symbol\n";
for (Chunk *c : sec->chunks) {
 
       writeHeader(os, sc->getRVA(), sc->getSize(), sc->getAlignment());
       os << indent8 << sc->file->getName() << ":(" << sc->getSectionName()
          << ")\n";
       for (DefinedRegular *sym : sectionSyms[sc])
         os << symStr[sym] << '\n';
     }
   }
 }

lld/COFF/MapFile.cpp

 //===- MapFile.cpp --------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
-// 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     File    Symbol
-//   00201000 00000015     4 .text
-//   00201000 0000000e     4         test.o:(.text)
-//   0020100e 00000000     0                 local
-//   00201005 00000000     0                 f(int)
+// This file implements the /map option in the same format as link.exe
+// (based on observations)
 //
+// Header (program name, timestamp info, preferred load address)
+//
+// Section list (Start = Section index:Base address):
+// Start         Length     Name                   Class
+// 0001:00001000 00000015H .text                   CODE
+//
+// Symbols list:
+// Address        Publics by Value    Rva + Base          Lib:Object
+// 0001:00001000  main                 0000000140001000    main.obj
+// 0001:00001300  ?__scrt_common_main@@YAHXZ  0000000140001300 libcmt:exe_main.obj
+//
+// entry point at        0001:00000360
+//
+// Static symbols
+//
+// 0000:00000000  __guard_fids__       0000000140000000     libcmt : exe_main.obj
 //===----------------------------------------------------------------------===//
 
 #include "MapFile.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Threads.h"
+#include "lld/Common/Timer.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::coff;
 
-using SymbolMapTy =
-    DenseMap<const SectionChunk *, SmallVector<DefinedRegular *, 4>>;
+static Timer totalMapTimer("MAP emission (Cumulative)", Timer::root());
+static Timer symbolGatherTimer("Gather symbols", totalMapTimer);
+static Timer symbolStringsTimer("Build symbol strings", totalMapTimer);
+static Timer writeTimer("Write to file", totalMapTimer);
+
+// Print out the first two columns of a line.
+static void writeHeader(raw_ostream &os, uint32_t sec, uint64_t addr) {
+  os << format(" %04x:%08llx", sec, addr);
+}
+
+// Write the time stamp with the format used by link.exe
+// It seems identical to strftime with "%c" on msvc build, but we need a
+// locale-agnostic version.
+static void writeFormattedTimestamp(raw_ostream &os, time_t tds) {
+  constexpr const char *const days[7] = {"Sun", "Mon", "Tue", "Wed",
+                                         "Thu", "Fri", "Sat"};
+  constexpr const char *const months[12] = {"Jan", "Feb", "Mar", "Apr",
+                                            "May", "Jun", "Jul", "Aug",
+                                            "Sep", "Oct", "Nov", "Dec"};
+  tm *time = localtime(&tds);
+  os << format("%s %s %2d %02d:%02d:%02d %d", days[time->tm_wday],
+               months[time->tm_mon], time->tm_mday, time->tm_hour, time->tm_min,
+               time->tm_sec, time->tm_year + 1900);
+}
+
+static void sortUniqueSymbols(std::vector<Defined *> &syms) {
+  // Build helper vector
+  using SortEntry = std::pair<Defined *, size_t>;
+  std::vector<SortEntry> v;
+  v.resize(syms.size());
+  for (size_t i = 0, e = syms.size(); i < e; ++i)
+    v[i] = SortEntry(syms[i], i);
+
+  // Remove duplicate symbol pointers
+  parallelSort(v, std::less<SortEntry>());
+  auto end = std::unique(v.begin(), v.end(),
+                         [](const SortEntry &a, const SortEntry &b) {
+                           return a.first == b.first;
+                         });
+  v.erase(end, v.end());
 
-static constexpr char indent8[] = "        ";          // 8 spaces
-static constexpr char indent16[] = "                "; // 16 spaces
+  // Sort by RVA then original order
+  parallelSort(v, [](const SortEntry &a, const SortEntry &b) {
+    // Add config->imageBase to avoid comparing "negative" RVAs.
+    // This can happen with symbols of Absolute kind
+    uint64_t rvaa = config->imageBase + a.first->getRVA();
+    uint64_t rvab = config->imageBase + b.first->getRVA();
+    return rvaa < rvab || (rvaa == rvab && a.second < b.second);
+  });
 
-// Print out the first three columns of a line.
-static void writeHeader(raw_ostream &os, uint64_t addr, uint64_t size,
-                        uint64_t align) {
-  os << format("%08llx %08llx %5lld ", addr, size, align);
+  syms.resize(v.size());
+  for (size_t i = 0, e = v.size(); i < e; ++i)
+    syms[i] = v[i].first;
 }
 
-// Returns a list of all symbols that we want to print out.
-static std::vector<DefinedRegular *> getSymbols() {
-  std::vector<DefinedRegular *> v;
+// Returns the lists of all symbols that we want to print out.
+static void getSymbols(std::vector<Defined *> &syms,
+                       std::vector<Defined *> &staticSyms) {
+
   for (ObjFile *file : ObjFile::instances)
-    for (Symbol *b : file->getSymbols())
-      if (auto *sym = dyn_cast_or_null<DefinedRegular>(b))
-        if (sym && !sym->getCOFFSymbol().isSectionDefinition())
-          v.push_back(sym);
-  return v;
-}
-
-// Returns a map from sections to their symbols.
-static SymbolMapTy getSectionSyms(ArrayRef<DefinedRegular *> syms) {
-  SymbolMapTy ret;
-  for (DefinedRegular *s : syms)
-    ret[s->getChunk()].push_back(s);
-
-  // Sort symbols by address.
-  for (auto &it : ret) {
-    SmallVectorImpl<DefinedRegular *> &v = it.second;
-    std::sort(v.begin(), v.end(), [](DefinedRegular *a, DefinedRegular *b) {
-      return a->getRVA() < b->getRVA();
-    });
+    for (Symbol *b : file->getSymbols()) {
+      if (!b || !b->isLive())
+        continue;
+      if (auto *sym = dyn_cast<DefinedCOFF>(b)) {
+        COFFSymbolRef symRef = sym->getCOFFSymbol();
+        if (!symRef.isSectionDefinition() &&
+            symRef.getStorageClass() != COFF::IMAGE_SYM_CLASS_LABEL) {
+          if (symRef.getStorageClass() == COFF::IMAGE_SYM_CLASS_STATIC)
+            staticSyms.push_back(sym);
+          else
+            syms.push_back(sym);
         }
-  return ret;
+      } else if (auto *sym = dyn_cast<Defined>(b)) {
+        syms.push_back(sym);
+      }
+    }
+
+  for (ImportFile *file : ImportFile::instances) {
+    if (!file->live)
+      continue;
+
+    if (!file->thunkSym)
+      continue;
+
+    if (!file->thunkLive)
+      continue;
+
+    if (auto *thunkSym = dyn_cast<Defined>(file->thunkSym))
+      syms.push_back(thunkSym);
+
+    if (auto *impSym = dyn_cast_or_null<Defined>(file->impSym))
+      syms.push_back(impSym);
+  }
+
+  sortUniqueSymbols(syms);
+  sortUniqueSymbols(staticSyms);
 }
 
 // Construct a map from symbols to their stringified representations.
-static DenseMap<DefinedRegular *, std::string>
-getSymbolStrings(ArrayRef<DefinedRegular *> syms) {
+static DenseMap<Defined *, std::string>
+getSymbolStrings(ArrayRef<Defined *> syms) {
   std::vector<std::string> str(syms.size());
   parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
-    writeHeader(os, syms[i]->getRVA(), 0, 0);
-    os << indent16 << toString(*syms[i]);
+    Defined *sym = syms[i];
+
+    uint16_t sectionIdx = 0;
+    uint64_t address = 0;
+    SmallString<128> fileDescr;
+
+    if (auto *absSym = dyn_cast<DefinedAbsolute>(sym)) {
+      address = absSym->getVA();
+      fileDescr = "<absolute>";
+    } else if (isa<DefinedSynthetic>(sym)) {
+      fileDescr = "<linker-defined>";
+    } else if (isa<DefinedCommon>(sym)) {
+      fileDescr = "<common>";
+    } else if (Chunk *chunk = sym->getChunk()) {
+      address = sym->getRVA();
+      if (OutputSection *sec = chunk->getOutputSection())
+        address -= sec->header.VirtualAddress;
+
+      sectionIdx = chunk->getOutputSectionIdx();
+
+      InputFile *file;
+      if (auto *impSym = dyn_cast<DefinedImportData>(sym))
+        file = impSym->file;
+      else if (auto *thunkSym = dyn_cast<DefinedImportThunk>(sym))
+        file = thunkSym->wrappedSym->file;
+      else
+        file = sym->getFile();
+
+      if (file) {
+        if (!file->parentName.empty()) {
+          fileDescr = sys::path::filename(file->parentName);
+          sys::path::replace_extension(fileDescr, "");
+          fileDescr += ":";
+        }
+        fileDescr += sys::path::filename(file->getName());
+      }
+    }
+    writeHeader(os, sectionIdx, address);
+    os << "       ";
+    os << left_justify(sym->getName(), 26);
+    os << " ";
+    os << format_hex_no_prefix((config->imageBase + sym->getRVA()), 16);
+    if (!fileDescr.empty()) {
+      os << "     "; // FIXME : Handle "f" and "i" flags sometimes generated
+                     // by link.exe in those spaces
+      os << fileDescr;
+    }
   });
 
-  DenseMap<DefinedRegular *, std::string> ret;
+  DenseMap<Defined *, std::string> ret;
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     ret[syms[i]] = std::move(str[i]);
   return ret;
 }
 
 void lld::coff::writeMapFile(ArrayRef<OutputSection *> outputSections) {
   if (config->mapFile.empty())
     return;
 
   std::error_code ec;
   raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None);
   if (ec)
     fatal("cannot open " + config->mapFile + ": " + ec.message());
 
+  ScopedTimer t1(totalMapTimer);
+
   // Collect symbol info that we want to print out.
-  std::vector<DefinedRegular *> syms = getSymbols();
-  SymbolMapTy sectionSyms = getSectionSyms(syms);
-  DenseMap<DefinedRegular *, std::string> symStr = getSymbolStrings(syms);
+  ScopedTimer t2(symbolGatherTimer);
+  std::vector<Defined *> syms;
+  std::vector<Defined *> staticSyms;
+  getSymbols(syms, staticSyms);
+  t2.stop();
+
+  ScopedTimer t3(symbolStringsTimer);
+  DenseMap<Defined *, std::string> symStr = getSymbolStrings(syms);
+  DenseMap<Defined *, std::string> staticSymStr = getSymbolStrings(staticSyms);
+  t3.stop();
+
+  ScopedTimer t4(writeTimer);
+  SmallString<128> AppName = sys::path::filename(config->outputFile);
+  sys::path::replace_extension(AppName, "");
+
+  // Print out the file header
+  os << " " << AppName << "\n";
+  os << "\n";
+
+  os << " Timestamp is " << format_hex_no_prefix(config->timestamp, 8) << " (";
+  if (config->repro) {
+    os << "Repro mode";
+  } else {
+    writeFormattedTimestamp(os, config->timestamp);
+  }
+  os << ")\n";
 
-  // Print out the header line.
-  os << "Address  Size     Align Out     In      Symbol\n";
+  os << "\n";
+  os << " Preferred load address is "
+     << format_hex_no_prefix(config->imageBase, 16) << "\n";
+  os << "\n";
 
-  // Print out file contents.
-  for (OutputSection *sec : outputSections) {
-    writeHeader(os, sec->getRVA(), sec->getVirtualSize(), /*align=*/pageSize);
-    os << sec->name << '\n';
+  // Print out section table.
+  os << " Start         Length     Name                   Class\n";
 
+  for (OutputSection *sec : outputSections) {
+    // Merge display of chunks with same sectionName
+    std::vector<std::pair<SectionChunk *, SectionChunk *>> ChunkRanges;
     for (Chunk *c : sec->chunks) {
       auto *sc = dyn_cast<SectionChunk>(c);
       if (!sc)
         continue;
 
-      writeHeader(os, sc->getRVA(), sc->getSize(), sc->getAlignment());
-      os << indent8 << sc->file->getName() << ":(" << sc->getSectionName()
-         << ")\n";
-      for (DefinedRegular *sym : sectionSyms[sc])
-        os << symStr[sym] << '\n';
+      if (ChunkRanges.empty() ||
+          c->getSectionName() != ChunkRanges.back().first->getSectionName()) {
+        ChunkRanges.emplace_back(sc, sc);
+      } else {
+        ChunkRanges.back().second = sc;
+      }
+    }
+
+    const bool isCodeSection =
+        (sec->header.Characteristics & COFF::IMAGE_SCN_CNT_CODE) &&
+        (sec->header.Characteristics & COFF::IMAGE_SCN_MEM_READ) &&
+        (sec->header.Characteristics & COFF::IMAGE_SCN_MEM_EXECUTE);
+    StringRef SectionClass = (isCodeSection ? "CODE" : "DATA");
+
+    for (auto &cr : ChunkRanges) {
+      size_t size =
+          cr.second->getRVA() + cr.second->getSize() - cr.first->getRVA();
+
+      auto address = cr.first->getRVA() - sec->header.VirtualAddress;
+      writeHeader(os, sec->sectionIndex, address);
+      os << " " << format_hex_no_prefix(size, 8) << "H";
+      os << " " << left_justify(cr.first->getSectionName(), 23);
+      os << " " << SectionClass;
+      os << '\n';
+    }
+  }
+
+  // Print out the symbols table (without static symbols)
+  os << "\n";
+  os << "  Address         Publics by Value              Rva+Base"
+        "               Lib:Object\n";
+  os << "\n";
+  for (Defined *sym : syms)
+
+  // Print out the entry point.
+  os << "\n";
+
+  uint16_t entrySecIndex = 0;
+  uint64_t entryAddress = 0;
+
+  if (!config->noEntry) {
+    Defined *entry = dyn_cast_or_null<Defined>(config->entry);
+    if (entry) {
+      Chunk *chunk = entry->getChunk();
+      entrySecIndex = chunk->getOutputSectionIdx();
+      entryAddress =
+          entry->getRVA() - chunk->getOutputSection()->header.VirtualAddress;
     }
   }
+  os << " entry point at         ";
+  os << format("%04x:%08llx", entrySecIndex, entryAddress);
+  os << "\n";
+
+  // Print out the static symbols
+  os << "\n";
+  os << " Static symbols\n";
+  os << "\n";
+  for (Defined *sym : staticSyms)
+    os << staticSymStr[sym] << '\n';
+
+  t4.stop();
+  t1.stop();
 }

lld/COFF/Options.td

def dash_dash_version : Flag<["--"], "version">,
   HelpText<"Print version information">;
 defm threads: B<"threads",
     "Run the linker multi-threaded (default)",
     "Do not run the linker multi-threaded">;
 
 // Flags for debugging
 def lldmap : F<"lldmap">;
 def lldmap_file : Joined<["/", "-", "/?", "-?"], "lldmap:">;
+def map : F<"map">;
+def map_file : Joined<["/", "-", "/?", "-?"], "map:">;
 def show_timing : F<"time">;
 def summary : F<"summary">;
 
 //==============================================================================
 // The flags below do nothing. They are defined only for link.exe compatibility.
 //==============================================================================
 
 class QF<string name> : Joined<["/", "-", "/?", "-?"], name#":">;

lld/COFF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "DLL.h"
 #include "InputFiles.h"
+#include "LLDMapFile.h"
 #include "MapFile.h"
 #include "PDB.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Timer.h"
void Writer::run() {
   t1.stop();
 
   if (!config->pdbPath.empty() && config->debug) {
     assert(buildId);
     createPDB(symtab, outputSections, sectionTable, buildId->buildId);
   }
   writeBuildId();
 
+  writeLLDMapFile(outputSections);
   writeMapFile(outputSections);
 
   if (errorCount())
     return;
 
   ScopedTimer t2(diskCommitTimer);
   if (auto e = buffer->commit())
     fatal("failed to write the output file: " + toString(std::move(e)));

lld/test/COFF/Inputs/map.yaml

+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: []
+sections:
+  - Name:            .text
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       4
+    SectionData:     0000000000000000
+    Relocations:
+      - VirtualAddress:  0
+        SymbolName:      exportfn1
+        Type:            IMAGE_REL_AMD64_ADDR32NB
+      - VirtualAddress:  4
+        SymbolName:      exportfn2
+        Type:            IMAGE_REL_AMD64_ADDR32NB
+symbols:
+  - Name:            .text
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          8
+      NumberOfRelocations: 2
+      NumberOfLinenumbers: 0
+      CheckSum:        0
+      Number:          0
+  - Name:            main
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            exportfn1
+    Value:           0
+    SectionNumber:   0
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            exportfn2
+    Value:           0
+    SectionNumber:   0
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            absolute
+    Value:           0x00000042
+    SectionNumber:   -1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+  - Name:            staticdef
+    Value:           0x00000043
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+...

lld/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 -strict-whitespace %s < %T/foo.map
-# RUN: lld-link /out:%T/bar.exe /entry:main /lldmap %t.obj
-# RUN: FileCheck -strict-whitespace %s < %T/bar.map
-
-# CHECK:      Address  Size     Align Out     In      Symbol
-# CHECK-NEXT: 00001000 00000006  4096 .text
-# CHECK-NEXT: 00001000 00000006    16         {{.*}}lldmap.test.tmp.obj:(.text$mn)
-# CHECK-NEXT: 00001000 00000000     0                 main

lld/test/COFF/map.test

+# RUN: yaml2obj < %p/Inputs/export.yaml > %t-dll.obj
+# RUN: lld-link /out:%t.dll /dll %t-dll.obj /implib:%t-dll.lib \
+# RUN:   /export:exportfn1 /export:exportfn2
+# RUN: yaml2obj < %p/Inputs/map.yaml > %t.obj
+# RUN: lld-link /out:%t.exe /entry:main %t.obj %t-dll.lib /map:%T/foo.map  /lldmap
+# RUN: FileCheck -check-prefix=MAP -strict-whitespace %s < %T/foo.map
+# RUN: FileCheck -check-prefix=LLDMAP -strict-whitespace %s < %t.map
+# RUN: lld-link /out:%t.exe /entry:main %t.obj %t-dll.lib /map /lldmap:%T/foo-lld.map
+# RUN: FileCheck -check-prefix=MAP -strict-whitespace %s < %t.map
+# RUN: FileCheck -check-prefix=LLDMAP -strict-whitespace %s < %T/foo-lld.map
+
+# MAP: {{.*}}
+# MAP-EMPTY:
+# MAP-NEXT: Timestamp is {{.*}}
+# MAP-EMPTY:
+# MAP-NEXT: Preferred load address is 0000000140000000
+# MAP-EMPTY:
+# MAP-NEXT: Start         Length     Name                   Class
+# MAP-NEXT: 0001:00000000 00000008H .text                   CODE
+# MAP-EMPTY:
+# MAP-NEXT:  Address         Publics by Value              Rva+Base               Lib:Object
+# MAP-EMPTY:
+# MAP-NEXT: 0000:00000042       absolute                   0000000000000042     <absolute>
+# MAP-NEXT: 0001:00000000       main                       0000000140001000     map.test.tmp.obj
+# MAP-NEXT: 0001:00000010       exportfn1                  0000000140001010     map.test.tmp-dll:map.test.tmp.dll
+# MAP-NEXT: 0001:00000020       exportfn2                  0000000140001020     map.test.tmp-dll:map.test.tmp.dll
+# MAP-NEXT: 0002:00000040       __imp_exportfn1            0000000140002040     map.test.tmp-dll:map.test.tmp.dll
+# MAP-NEXT: 0002:00000048       __imp_exportfn2            0000000140002048     map.test.tmp-dll:map.test.tmp.dll
+# MAP-EMPTY:
+# MAP-NEXT: entry point at         0001:00000000
+# MAP-EMPTY:
+# MAP-NEXT: Static symbols
+# MAP-EMPTY:
+# MAP-NEXT: 0001:00000043       staticdef                  0000000140001043     map.test.tmp.obj
+
+
+# LLDMAP:      Address  Size     Align Out     In      Symbol
+# LLDMAP-NEXT: 00001000 00000026  4096 .text
+# LLDMAP-NEXT: 00001000 00000008     4         {{.*}}map.test.tmp.obj:(.text)
+# LLDMAP-NEXT: 00001000 00000000     0                 main