[lld][WebAssembly] Add initial support for -Map/--print-map

[sbc100]

clang format

[sbc100]

Fix test

[sbc100]

Remove comments

[ruiu]

lld/wasm/MapFile.cpp

128

Since wasm functions don't have addresses, you decided to print out "0" as an address, right? I wonder if we should something other than "0" (like "-") since "0" is still a valid address.

[sbc100]

Improve address and file offset information

[sbc100]

ping..

[ruiu]

lld/test/wasm/map-file.s

28

Hmm, what is "Off"? It looks like it is monotonically increasing, but I'm not sure what these numbers are.

lld/wasm/MapFile.cpp

125–126

Since w is always 8, you can output a plain text instead of using right_justify.

[sbc100]

feedback

lld/test/wasm/map-file.s

28

These are the offset in the wasm module on disk.

lld/wasm/MapFile.cpp

125–126

Good point. Done.

[ruiu]

lld/test/wasm/map-file.s

28

Maybe a noob question, but is that significant? For ELF and COFF, we emit an offset within an output section for each input section, but we don't print out an offset within a file.

[sbc100]

lld/test/wasm/map-file.s

28

It hard to say what the most useful information to present is. Do you have rational for why offset within an output section for each input section is useful? I happy to modify this PR to display that information instead. I imagine we could change this based on consumer feedback in the future too.

[MaskRay]

lld/test/wasm/map-file.s

4

--match-full-lines --strip-whitespace

--strip-whitespace alone still ignores leading or trailing spaces.

See test/ELF/map-file-64bit.s for an example

[sbc100]

feedback

[sbc100]

lld/test/wasm/map-file.s

4

Sure thing.. I was copying lld/test/ELF/map-file.s which just uses -strict-whitespace.

At least it did until today when you changed it in cece7af58682a2122b108d7af270a31043ac1825 :)

Any reason you also changed all the comments from // to # in that change? I think we should try to be consistent across all the .s tests in lld so maybe we change all of them at once? (Assuming we prefer the hash mark).

Also, I looks like you didn't send it for review (or at least no here on phabicator)? Was that deliberate?

Sorry, I don't mean to sound picky.. happy for the feedback here.

[MaskRay]

lld/test/wasm/map-file.s

4

I think lld/test/ELF/map-file.s should have been fixed earlier before you copied it to wasm.

About // -> #, the description of that commit mentioned that since I had to change so many lines (adding leading spaces), just change the comments to use the more common way.

For other tests, it might just create churn if we do so. So I would not want to do that unless there is just motivation and I have to change a majority of lines (then optimizing for diff no longer counts)

Also, I looks like you didn't send it for review (or at least no here on phabicator)? Was that deliberate?

Sorry, I don't mean to sound picky.. happy for the feedback here.

Yes. It is NFC and likely community consensus plus I have made sufficient changes to lld/ELF. I probably would not want to do that if you did not copy it here.

[sbc100]

Use # over \\ is a comments in .s files

lld/test/wasm/map-file.s

28

Ping.

Would you prefer I output "offset with output section for each input section" ? Looking at test/ELF/map-file.s only see LMA and VMA (which I assume stands for virtual memory address?). I'm not sure what LMA has a logical correspondence in wasm. Is this what you call " offset with output section for each input section" ? For the test code LMA and VMA seems to be the same in all cases.

I'm happy to change this however you like but I also think its find to land as is and get feedback as to what information is the most useful to present.

[sbc100]

lld/test/wasm/map-file.s

4

I think lld/test/ELF/map-file.s should have been fixed earlier before you copied it to wasm.

It looks like lld/test/ELF/map-file.s was only fixed 2 days ago. This PR has been open a lot longer than that. Of course it makes no difference at all, I'm just pointing this out for the record to explain why this change started life like this and that it was based on an existing test in the ELF linker.

[MaskRay]

lld/test/wasm/map-file.s

4

I might mistake your last comment as questioning my change... so I was defending myself. Sorry as after I reread the comments if seems that you did not mean for that...

28

Use CHECK-NEXT: if applicable.

[sbc100]

feedback

[sbc100]

ping @ruiu , would you like to me to change the information that we print here?

[MaskRay]

lld/test/ELF/map-file.s

14

I know some people prefer the double-dash options for FileCheck now. If you are going to add new lines or touching existing lines, you may use the double-dash form.

lld/wasm/MapFile.cpp

133

os.indent(8) << toString(chunk) << '\n'

lld/wasm/OutputSections.cpp

233

This order shuffle is not needed.

lld/wasm/OutputSegment.h

41 ↗

(On Diff #259729)

Add a comment what this means. It seems that outputSec is purely for debugging purposes (-M).

[sbc100]

feedback

lld/wasm/OutputSections.cpp

233

This is to make it match the above two for loops where section->outputSec = this; is the first line.

lld/wasm/OutputSegment.h

41 ↗

(On Diff #259729)

On further inspection I was able to revert this part.

[sbc100]

• rebase

[dschuff]

Can we pick this up again?

It looks like the only unresolved issues are the question of whether we should print section offsets or file offsets, and whether to put "-" or "0" for function addresses. I don't really have any opinion on the latter.
For the former question in general it's unfortunately slightly annoying, because for sections like data and debug info, section offsets are more relevant. But for code, VMs tend to print code addresses as file offsets.
But for the view mentioned above, (printing the offsets of each output section especially the official known sections such as CODE, DATA, etc where there can be only one), file offset probably makes the most sense to me.

[dschuff]

@MaskRay ping

[MaskRay]

lld/wasm/MapFile.cpp

39

http://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

The public functions should use the style: void wasm::xxxxxxx

[sbc100]

feedback

[sbc100]

lld/wasm/MapFile.cpp

39

Interesting, thanks.

I guess I should update all the source files in lld/wasm to conform.

Sadly wasm:: is ambiguous so I had to use llvm::wasm::

lld/test/ELF/map-file.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %p/Inputs/map-file2.s -o %t2.o
 # RUN: echo '.global bah; bah:' | llvm-mc -filetype=obj -triple=x86_64 - -o %t3.o
 # RUN: echo '.global baz; baz: ret' | llvm-mc -filetype=obj -triple=x86_64 - -o %t4.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64 %p/Inputs/map-file5.s -o %t5.o
 # RUN: ld.lld -shared %t5.o -o %t5.so -soname dso
 # RUN: rm -f %t4.a
 # RUN: llvm-ar rc %t4.a %t4.o
 # RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t -M | FileCheck --match-full-lines --strict-whitespace %s
 # RUN: ld.lld %t1.o %t2.o %t3.o %t4.a %t5.so -o %t --print-map | FileCheck --match-full-lines -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
+# RUN: FileCheck -match-full-lines -strict-whitespace %s < %t.map
 
 .global _start
 _start:
 .cfi_startproc
 .cfi_endproc
  .quad sharedFoo
  .quad sharedBar
  .byte 0xe8

lld/test/wasm/early-exit-for-bad-paths.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t.o
 
 # RUN: not wasm-ld %t.o -o does_not_exist/output 2>&1 | \
 # RUN:   FileCheck %s -check-prefixes=NO-DIR-OUTPUT,CHECK
 # RUN: not wasm-ld %t.o -o %s/dir_is_a_file 2>&1 | \
 # RUN:   FileCheck %s -check-prefixes=DIR-IS-OUTPUT,CHECK
-# TODO(sbc): check similar check for -Map file once we add that option
+
+# RUN: not wasm-ld %t.o -o %t -Map=does_not_exist/output 2>&1 | \
+# RUN:   FileCheck %s -check-prefixes=NO-DIR-MAP,CHECK
+# RUN: not wasm-ld %t.o -o %t -Map=%s/dir_is_a_file 2>&1 | \
+# RUN:   FileCheck %s -check-prefixes=DIR-IS-MAP,CHECK
 
 # NO-DIR-OUTPUT: error: cannot open output file does_not_exist/output:
 # DIR-IS-OUTPUT: error: cannot open output file {{.*}}/dir_is_a_file:
+# NO-DIR-MAP: error: cannot open map file does_not_exist/output:
+# DIR-IS-MAP: error: cannot open map file {{.*}}/dir_is_a_file:
 
 # We should exit before doing the actual link. If an undefined symbol error is
 # discovered we haven't bailed out early as expected.
 # CHECK-NOT: undefined_symbol
 
 # RUN: not wasm-ld %t.o -o / 2>&1 | FileCheck %s -check-prefixes=ROOT,CHECK
 # ROOT: error: cannot open output file /
 
 _start:
     .functype _start () -> ()
     call undefined_symbol
     end_function

lld/test/wasm/map-file.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %s -o %t1.o
+# RUN: wasm-ld %t1.o -o %t -M | FileCheck --match-full-lines --strict-whitespace %s
+# RUN: wasm-ld %t1.o -o %t -print-map | FileCheck --match-full-lines --strict-whitespace %s
+# RUN: wasm-ld %t1.o -o %t -Map=%t.map
+# RUN: FileCheck --match-full-lines --strict-whitespace %s < %t.map
+
+bar:
+    .functype bar () -> ()
+    i32.const   somedata
+    end_function
+
+    .globl _start
+_start:
+    .functype _start () -> ()
+    call bar
+    end_function
+
+.section .data.somedata,"",@
+somedata:
+    .int32 123
+.size somedata, 4
+
+.section .debug_info,"",@
+    .int32 bar
+
+#      CHECK:    Addr      Off     Size Out     In      Symbol
+# CHECK-NEXT:       -        8        6 TYPE
+# CHECK-NEXT:       -        e        5 FUNCTION
+# CHECK-NEXT:       -       13        7 TABLE
+# CHECK-NEXT:       -       1a        5 MEMORY
+# CHECK-NEXT:       -       1f        a GLOBAL
+# CHECK-NEXT:       -       29       15 EXPORT
+# CHECK-NEXT:       -       3e       15 CODE
+# CHECK-NEXT:       -       3f        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(bar)
+# CHECK-NEXT:       -       3f        9                 bar
+# CHECK-NEXT:       -       48        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
+# CHECK-NEXT:       -       48        9                 _start
+# CHECK-NEXT:       -       53        d DATA
+# CHECK-NEXT:     400       54        4 .data
+# CHECK-NEXT:     400       5a        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
+# CHECK-NEXT:     400       5a        4                 somedata
+# CHECK-NEXT:       -       60       12 CUSTOM(.debug_info)
+# CHECK-NEXT:       -       72       17 CUSTOM(name)
+
+# RUN: not wasm-ld %t1.o -o /dev/null -Map=/ 2>&1 \
+# RUN:  | FileCheck -check-prefix=FAIL %s
+# FAIL: wasm-ld: error: cannot open map file /

lld/wasm/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(WasmOptionsTableGen)
 
 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldWasm
   Driver.cpp
   InputChunks.cpp
   InputFiles.cpp
   LTO.cpp
+  MapFile.cpp
   MarkLive.cpp
   OutputSections.cpp
   Relocations.cpp
   SymbolTable.cpp
   Symbols.cpp
   SyntheticSections.cpp
   Writer.cpp
   WriterUtils.cpp

lld/wasm/Config.h

struct Configuration {
   uint64_t maxMemory;
   uint64_t zStackSize;
   unsigned ltoPartitions;
   unsigned ltoo;
   unsigned optimize;
   llvm::StringRef thinLTOJobs;
 
   llvm::StringRef entry;
+  llvm::StringRef mapFile;
   llvm::StringRef outputFile;
   llvm::StringRef thinLTOCacheDir;
 
   llvm::StringSet<> allowUndefinedSymbols;
   llvm::StringSet<> exportedSymbols;
   std::vector<llvm::StringRef> searchPaths;
   llvm::CachePruningPolicy thinLTOCachePolicy;
   llvm::Optional<std::vector<std::string>> features;

lld/wasm/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->growableTable = args.hasArg(OPT_growable_table);
   errorHandler().fatalWarnings =
       args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   config->importMemory = args.hasArg(OPT_import_memory);
   config->sharedMemory = args.hasArg(OPT_shared_memory);
   config->importTable = args.hasArg(OPT_import_table);
   config->ltoo = args::getInteger(args, OPT_lto_O, 2);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
+  config->mapFile = args.getLastArgValue(OPT_Map);
   config->optimize = args::getInteger(args, OPT_O, 0);
   config->outputFile = args.getLastArgValue(OPT_o);
   config->relocatable = args.hasArg(OPT_relocatable);
   config->gcSections =
       args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !config->relocatable);
   config->mergeDataSegments =
       args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
                    !config->relocatable);
if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
     config->thinLTOJobs = arg->getValue();
 
   if (auto *arg = args.getLastArg(OPT_features)) {
     config->features =
         llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
     for (StringRef s : arg->getValues())
       config->features->push_back(std::string(s));
   }
+
+  if (args.hasArg(OPT_print_map))
+    config->mapFile = "-";
 }
 
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs() {
   config->isPic = config->pie || config->shared;
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   if (auto *arg = args.getLastArg(OPT_allow_undefined_file))
     readImportFile(arg->getValue());
 
   // Fail early if the output file or map file is not writable. If a user has a
   // long link, e.g. due to a large LTO link, they do not wish to run it and
   // find that it failed because there was a mistake in their command-line.
   if (auto e = tryCreateFile(config->outputFile))
     error("cannot open output file " + config->outputFile + ": " + e.message());
-  // TODO(sbc): add check for map file too once we add support for that.
+  if (auto e = tryCreateFile(config->mapFile))
+    error("cannot open map file " + config->mapFile + ": " + e.message());
   if (errorCount())
     return;
 
   // Handle --trace-symbol.
   for (auto *arg : args.filtered(OPT_trace_symbol))
     symtab->trace(arg->getValue());
 
   for (auto *arg : args.filtered(OPT_export))

lld/wasm/InputChunks.h

public:
   virtual uint32_t getComdat() const = 0;
   StringRef getComdatName() const;
   virtual uint32_t getInputSectionOffset() const = 0;
 
   size_t getNumRelocations() const { return relocations.size(); }
   void writeRelocations(llvm::raw_ostream &os) const;
 
   ObjFile *file;
+  OutputSection *outputSec = nullptr;
+  // Offset withing the output section
   int32_t outputOffset = 0;
 
   // Signals that the section is part of the output.  The garbage collector,
   // and COMDAT handling can set a sections' Live bit.
   // If GC is disabled, all sections start out as live by default.
   unsigned live : 1;
 
   // Signals the chunk was discarded by COMDAT handling.
InputSection(const WasmSection &s, ObjFile *f)
       : InputChunk(f, InputChunk::Section), section(s) {
     assert(section.Type == llvm::wasm::WASM_SEC_CUSTOM);
   }
 
   StringRef getName() const override { return section.Name; }
   StringRef getDebugName() const override { return StringRef(); }
   uint32_t getComdat() const override { return UINT32_MAX; }
 
-  OutputSection *outputSec = nullptr;
-
 protected:
   ArrayRef<uint8_t> data() const override { return section.Content; }
 
   // Offset within the input section.  This is only zero since this chunk
   // type represents an entire input section, not part of one.
   uint32_t getInputSectionOffset() const override { return 0; }
 
   const WasmSection &section;

lld/wasm/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_WASM_MAPFILE_H
+#define LLD_WASM_MAPFILE_H
+
+#include "llvm/ADT/ArrayRef.h"
+
+namespace lld {
+namespace wasm {
+class OutputSection;
+void writeMapFile(llvm::ArrayRef<OutputSection *> outputSections);
+} // namespace wasm
+} // namespace lld
+
+#endif

lld/wasm/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 -Map option. It shows lists in order and
+// hierarchically the output sections, input sections, input files and
+// symbol:
+//
+//       Addr      Off   Size    Out     In      Symbol
+//          - 00000015     10    .text
+//          - 0000000e     10            test.o:(.text)
+//          - 00000000      5                    local
+//          - 00000000      5                    f(int)
+//
+//===----------------------------------------------------------------------===//
+
+#include "MapFile.h"
+#include "InputFiles.h"
+#include "OutputSections.h"
+#include "OutputSegment.h"
+#include "SymbolTable.h"
+#include "Symbols.h"
+#include "SyntheticSections.h"
+#include "lld/Common/Strings.h"
+#include "lld/Common/Threads.h"
+#include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+namespace lld {
+namespace wasm {
+
+using SymbolMapTy = DenseMap<const InputChunk *, SmallVector<Symbol *, 4>>;
+
+// Print out the first three columns of a line.
+static void writeHeader(raw_ostream &os, int64_t vma, uint64_t lma,
+                        uint64_t size) {
+  // Not all entries in the map has a virtual memory address (e.g. functions)
+  if (vma == -1)
+    os << format("       - %8llx %8llx ", lma, size);
+  else
+    os << format("%8llx %8llx %8llx ", vma, lma, size);
+}
+
+// Returns a list of all symbols that we want to print out.
+static std::vector<Symbol *> getSymbols() {
+  std::vector<Symbol *> v;
+  for (InputFile *file : symtab->objectFiles)
+    for (Symbol *b : file->getSymbols())
+      if (auto *dr = dyn_cast<Symbol>(b))
+        if ((!isa<SectionSymbol>(dr)) && dr->isLive() &&
+            (dr->getFile() == file))
+          v.push_back(dr);
+  return v;
+}
+
+// Returns a map from sections to their symbols.
+static SymbolMapTy getSectionSyms(ArrayRef<Symbol *> syms) {
+  SymbolMapTy ret;
+  for (Symbol *dr : syms)
+    ret[dr->getChunk()].push_back(dr);
+  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<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]);
+    auto &chunk = *syms[i]->getChunk();
+    uint64_t fileOffset = chunk.outputSec->getOffset() + chunk.outputOffset;
+    uint64_t vma = -1;
+    uint64_t size = 0;
+    if (auto *DD = dyn_cast<DefinedData>(syms[i])) {
+      vma = DD->getVirtualAddress();
+      size = DD->getSize();
+      fileOffset += DD->offset;
+    }
+    if (auto *DF = dyn_cast<DefinedFunction>(syms[i])) {
+      size = DF->function->getSize();
+    }
+    writeHeader(os, vma, fileOffset, size);
+    os.indent(16) << toString(*syms[i]);
+  });
+
+  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 writeMapFile(ArrayRef<OutputSection *> outputSections) {
+  if (config->mapFile.empty())
+    return;
+
+  // 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;
+  }
+
+  // Collect symbol info that we want to print out.
+  std::vector<Symbol *> syms = getSymbols();
+  SymbolMapTy sectionSyms = getSectionSyms(syms);
+  DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms);
+
+  // Print out the header line.
+  os << "    Addr      Off     Size Out     In      Symbol\n";
+
+  for (OutputSection *osec : outputSections) {
+    writeHeader(os, -1, osec->getOffset(), osec->getSize());
+    os << toString(*osec) << '\n';
+    if (auto *code = dyn_cast<CodeSection>(osec)) {
+      for (auto *chunk : code->functions) {
+        writeHeader(os, -1, chunk->outputSec->getOffset() + chunk->outputOffset,
+                    chunk->getSize());
+        os.indent(8) << toString(chunk) << '\n';
+        for (Symbol *sym : sectionSyms[chunk])
+          os << symStr[sym] << '\n';
+      }
+    } else if (auto *data = dyn_cast<DataSection>(osec)) {
+      for (auto *oseg : data->segments) {
+        writeHeader(os, oseg->startVA, data->getOffset() + oseg->sectionOffset,
+                    oseg->size);
+        os << oseg->name << '\n';
+        for (auto *chunk : oseg->inputSegments) {
+          writeHeader(os, oseg->startVA + chunk->outputSegmentOffset,
+                      chunk->outputSec->getOffset() + chunk->outputOffset,
+                      chunk->getSize());
+          os.indent(8) << toString(chunk) << '\n';
+          for (Symbol *sym : sectionSyms[chunk])
+            os << symStr[sym] << '\n';
+        }
+      }
+    }
+  }
+}
+
+} // namespace wasm
+} // namespace lld

lld/wasm/Options.td

 def l: JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
 def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Add a directory to the library search path">;
 
 def mllvm: S<"mllvm">, HelpText<"Options to pass to LLVM">;
 
+defm Map: Eq<"Map", "Print a link map to the specified file">;
+
 def no_color_diagnostics: F<"no-color-diagnostics">,
   HelpText<"Do not use colors in diagnostics">;
 
 def no_fatal_warnings: F<"no-fatal-warnings">;
 
 def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def O: JoinedOrSeparate<["-"], "O">, HelpText<"Optimize output file size">;
 
 defm pie: B<"pie",
     "Create a position independent executable",
     "Do not create a position independent executable (default)">;
 
 defm print_gc_sections: B<"print-gc-sections",
     "List removed unused sections",
     "Do not list removed unused sections">;
 
+def print_map: F<"print-map">,
+  HelpText<"Print a link map to the standard output">;
+
 def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
 
 defm reproduce: Eq<"reproduce", "Dump linker invocation and input files for debugging">;
 
 defm rsp_quoting: Eq<"rsp-quoting", "Quoting style for response files">,
   MetaVarName<"[posix,windows]">;
 
 def shared: F<"shared">, HelpText<"Build a shared object">;
def features: CommaJoined<["--", "-"], "features=">,
   HelpText<"Comma-separated used features, inferred from input objects by default.">;
 
 // Aliases
 def: JoinedOrSeparate<["-"], "e">, Alias<entry>;
 def: J<"entry=">, Alias<entry>;
 def: Flag<["-"], "E">, Alias<export_dynamic>, HelpText<"Alias for --export-dynamic">;
 def: Flag<["-"], "i">, Alias<initial_memory>;
 def: Flag<["-"], "m">, Alias<max_memory>;
+def: Flag<["-"], "M">, Alias<print_map>, HelpText<"Alias for --print-map">;
 def: Flag<["-"], "r">, Alias<relocatable>;
 def: Flag<["-"], "s">, Alias<strip_all>, HelpText<"Alias for --strip-all">;
 def: Flag<["-"], "S">, Alias<strip_debug>, HelpText<"Alias for --strip-debug">;
 def: Flag<["-"], "t">, Alias<trace>, HelpText<"Alias for --trace">;
 def: JoinedOrSeparate<["-"], "y">, Alias<trace_symbol>, HelpText<"Alias for --trace-symbol">;
 def: JoinedOrSeparate<["-"], "u">, Alias<undefined>;
 
 // LTO-related options.

lld/wasm/OutputSections.h

public:
   StringRef getSectionName() const;
   void setOffset(size_t newOffset) {
     log("setOffset: " + toString(*this) + ": " + Twine(newOffset));
     offset = newOffset;
   }
   void createHeader(size_t bodySize);
   virtual bool isNeeded() const { return true; }
   virtual size_t getSize() const = 0;
+  virtual size_t getOffset() { return offset; }
   virtual void writeTo(uint8_t *buf) = 0;
   virtual void finalizeContents() = 0;
   virtual uint32_t getNumRelocations() const { return 0; }
   virtual void writeRelocations(raw_ostream &os) const {}
 
   std::string header;
   uint32_t type;
   uint32_t sectionIndex = UINT32_MAX;
   std::string name;
   OutputSectionSymbol *sectionSym = nullptr;
 
 protected:
   size_t offset = 0;
 };
 
 class CodeSection : public OutputSection {
 public:
   explicit CodeSection(ArrayRef<InputFunction *> functions)
       : OutputSection(llvm::wasm::WASM_SEC_CODE), functions(functions) {}
 
+  static bool classof(const OutputSection *sec) {
+    return sec->type == llvm::wasm::WASM_SEC_CODE;
+  }
+
   size_t getSize() const override { return header.size() + bodySize; }
   void writeTo(uint8_t *buf) override;
   uint32_t getNumRelocations() const override;
   void writeRelocations(raw_ostream &os) const override;
   bool isNeeded() const override { return functions.size() > 0; }
   void finalizeContents() override;
 
-protected:
   ArrayRef<InputFunction *> functions;
+
+protected:
   std::string codeSectionHeader;
   size_t bodySize = 0;
 };
 
 class DataSection : public OutputSection {
 public:
   explicit DataSection(ArrayRef<OutputSegment *> segments)
       : OutputSection(llvm::wasm::WASM_SEC_DATA), segments(segments) {}
 
+  static bool classof(const OutputSection *sec) {
+    return sec->type == llvm::wasm::WASM_SEC_DATA;
+  }
+
   size_t getSize() const override { return header.size() + bodySize; }
   void writeTo(uint8_t *buf) override;
   uint32_t getNumRelocations() const override;
   void writeRelocations(raw_ostream &os) const override;
   bool isNeeded() const override;
   void finalizeContents() override;
 
-protected:
   ArrayRef<OutputSegment *> segments;
+
+protected:
   std::string dataSectionHeader;
   size_t bodySize = 0;
 };
 
 // Represents a custom section in the output file.  Wasm custom sections are
 // used for storing user-defined metadata.  Unlike the core sections types
 // they are identified by their string name.
 // The linker combines custom sections that have the same name by simply
 // concatenating them.
 // Note that some custom sections such as "name" and "linking" are handled
 // separately and are instead synthesized by the linker.
 class CustomSection : public OutputSection {
 public:
   CustomSection(std::string name, ArrayRef<InputSection *> inputSections)
       : OutputSection(llvm::wasm::WASM_SEC_CUSTOM, name),
         inputSections(inputSections) {}
+
+  static bool classof(const OutputSection *sec) {
+    return sec->type == llvm::wasm::WASM_SEC_CUSTOM;
+  }
+
   size_t getSize() const override {
     return header.size() + nameData.size() + payloadSize;
   }
   void writeTo(uint8_t *buf) override;
   uint32_t getNumRelocations() const override;
   void writeRelocations(raw_ostream &os) const override;
   void finalizeContents() override;
 

lld/wasm/OutputSections.cpp

 
 void CodeSection::finalizeContents() {
   raw_string_ostream os(codeSectionHeader);
   writeUleb128(os, functions.size(), "function count");
   os.flush();
   bodySize = codeSectionHeader.size();
 
   for (InputFunction *func : functions) {
+    func->outputSec = this;
     func->outputOffset = bodySize;
     func->calculateSize();
     bodySize += func->getSize();
   }
 
   createHeader(bodySize);
 }
 
for (OutputSegment *segment : segments) {
     writeUleb128(os, segment->size, "segment size");
     os.flush();
 
     segment->sectionOffset = bodySize;
     bodySize += segment->header.size() + segment->size;
     log("Data segment: size=" + Twine(segment->size) + ", startVA=" +
         Twine::utohexstr(segment->startVA) + ", name=" + segment->name);
 
-    for (InputSegment *inputSeg : segment->inputSegments)
+    for (InputSegment *inputSeg : segment->inputSegments) {
+      inputSeg->outputSec = this;
       inputSeg->outputOffset = segment->sectionOffset + segment->header.size() +
                                inputSeg->outputSegmentOffset;
     }
+  }
 
   createHeader(bodySize);
 }
 
 void DataSection::writeTo(uint8_t *buf) {
   log("writing " + toString(*this) + " size=" + Twine(getSize()) +
       " body=" + Twine(bodySize));
   buf += offset;

 
 void CustomSection::finalizeContents() {
   raw_string_ostream os(nameData);
   encodeULEB128(name.size(), os);
   os << name;
   os.flush();
 
   for (InputSection *section : inputSections) {
-    section->outputOffset = payloadSize;
     section->outputSec = this;
+    section->outputOffset = payloadSize;
     payloadSize += section->getSize();
   }
 
   createHeader(payloadSize + nameData.size());
 }
 
 void CustomSection::writeTo(uint8_t *buf) {
   log("writing " + toString(*this) + " size=" + Twine(getSize()) +

lld/wasm/Symbols.h

public:
   void setVirtualAddress(uint32_t va);
 
   // Returns the offset of a defined data symbol within its OutputSegment.
   uint32_t getOutputSegmentOffset() const;
   uint32_t getOutputSegmentIndex() const;
   uint32_t getSize() const { return size; }
 
   InputSegment *segment = nullptr;
+  uint32_t offset = 0;
 
 protected:
-  uint32_t offset = 0;
   uint32_t size = 0;
 };
 
 class UndefinedData : public DataSymbol {
 public:
   UndefinedData(StringRef name, uint32_t flags, InputFile *file = nullptr)
       : DataSymbol(name, UndefinedDataKind, flags, file) {}
   static bool classof(const Symbol *s) {

lld/wasm/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 "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "MapFile.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
if (errorHandler().verbose) {
     for (ObjFile *file : symtab->objectFiles)
       file->dumpInfo();
   }
 
   createHeader();
   log("-- finalizeSections");
   finalizeSections();
 
+  log("-- writeMapFile");
+  writeMapFile(outputSections);
+
   log("-- openFile");
   openFile();
   if (errorCount())
     return;
 
   writeHeader();
 
   log("-- writeSections");