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

[sbc100]

clang format

[sbc100]

Fix test

[sbc100]

Remove comments

[ruiu]

lld/wasm/MapFile.cpp

127

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 ↗

(On Diff #259729)

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

234 ↗

(On Diff #259729)

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

234 ↗

(On Diff #259729)

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/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 -strict-whitespace %s
+// RUN: wasm-ld %t1.o -o %t -print-map | FileCheck -strict-whitespace %s
+// RUN: wasm-ld %t1.o -o %t -Map=%t.map
+// RUN: FileCheck -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:       0        8        6 TYPE
+// CHECK:       0        e        5 FUNCTION
+// CHECK:       0       13        7 TABLE
+// CHECK:       0       1a        5 MEMORY
+// CHECK:       0       1f        a GLOBAL
+// CHECK:       0       29       15 EXPORT
+// CHECK:       0       3e       15 CODE
+// CHECK:       0        0        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(bar)
+// CHECK:       0        0        9                 bar
+// CHECK:       0        0        9         {{.*}}{{/|\\}}map-file.s.tmp1.o:(_start)
+// CHECK:       1        0        9                 _start
+// CHECK:       0       53        d DATA
+// CHECK:     400        0        4         {{.*}}{{/|\\}}map-file.s.tmp1.o:(.data.somedata)
+// CHECK:     400        0        4                 somedata
+// CHECK:       0       60       12 CUSTOM(.debug_info)
+// CHECK:       0       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 /

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

 //===- Config.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
 //
 //===----------------------------------------------------------------------===//
 
struct Configuration {
   uint32_t maxMemory;
   uint32_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

 //===- Driver.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
 //
 //===----------------------------------------------------------------------===//
 
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) {
   // Parse and evaluate -mllvm options.
   std::vector<const char *> v;
   v.push_back("wasm-ld (LLVM option parsing)");
   for (auto *arg : args.filtered(OPT_mllvm))
     v.push_back(arg->getValue());
   cl::ParseCommandLineOptions(v.size(), v.data());
 
   errorHandler().errorLimit = args::getInteger(args, OPT_error_limit, 20);
-
   readConfigs(args);
   setConfigs();
   checkOptions(args);
 
   if (auto *arg = args.getLastArg(OPT_allow_undefined_file))
     readImportFile(arg->getValue());
 
   if (!args.hasArg(OPT_INPUT)) {

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
+//   00201000 00000015     10    .text
+//   00201000 0000000e     10            test.o:(.text)
+//   0020100e 00000000      5                    local
+//   0020100f 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>>;
+
+static constexpr char indent8[] = "        ";          // 8 spaces
+static constexpr char indent16[] = "                "; // 16 spaces
+
+// Print out the first three columns of a line.
+static void writeHeader(raw_ostream &os, uint64_t vma, uint64_t lma,
+                        uint64_t size) {
+  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]);
+    uint64_t vma = 0;
+    uint64_t size = 0;
+    if (auto *DD = dyn_cast<DefinedData>(syms[i])) {
+      vma = DD->getVirtualAddress();
+      size = DD->getSize();
+    }
+    if (auto *DF = dyn_cast<DefinedFunction>(syms[i])) {
+      vma = DF->getFunctionIndex();
+      size = DF->function->getSize();
+    }
+    writeHeader(os, vma, 0, size);
+    os << indent16 << 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.
+  int w = 8;
+  os << right_justify("Addr", w) << ' ' << right_justify("Off", w)
+     << "     Size Out     In      Symbol\n";
+
+  for (OutputSection *osec : outputSections) {
+    writeHeader(os, 0, osec->getOffset(), osec->getSize());
+    os << toString(*osec) << '\n';
+    if (auto *code = dyn_cast<CodeSection>(osec)) {
+      for (auto *chunk : code->functions) {
+        writeHeader(os, 0, 0, chunk->getSize());
+        os << indent8 << 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, oseg->sectionOffset, oseg->size);
+        os << oseg->name << '\n';
+        for (auto *chunk : oseg->inputSegments) {
+          writeHeader(os, oseg->startVA + chunk->outputSegmentOffset, 0,
+                      chunk->getSize());
+          os << indent8 << 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

 //===- OutputSections.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
 //
 //===----------------------------------------------------------------------===//
 
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/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");