[WebAssembly] add memory map file support for wasm-ld

[quantum]

Summary

Add the option to generate a memory map file showing the memory location
of all external global variables.

[tlively]

This would require a test before it is merged.

lld/wasm/MapFile.cpp

18

It might be good to give the hex values an 0x prefix

[ruiu]

I'd rename this patch to avoid "memory map file" because that term is overloaded and can be interpreted in a different way. I'd say implementing -print-map.

lld/wasm/MapFile.cpp

14

This format is different from lld/ELF. I think we have a column for input files, input sections and output sections. Is this an intentional change?

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 {
   uint32_t MaxMemory;
   uint32_t ZStackSize;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned 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) {
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
 
   Config->InitialMemory = args::getInteger(Args, OPT_initial_memory, 0);
   Config->GlobalBase = args::getInteger(Args, OPT_global_base, 1024);
   Config->MaxMemory = args::getInteger(Args, OPT_max_memory, 0);
   Config->ZStackSize =
       args::getZOptionValue(Args, OPT_z, "stack-size", WasmPageSize);
 
+  if (Args.hasArg(OPT_print_map))
+    Config->MapFile = "-";
+
   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(S);
   }
 }
 

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
+
+namespace lld {
+namespace wasm {
+void writeMapFile();
+void writeCrossReferenceTable();
+} // 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 -print-map option. It shows a list of global data
+// symbols in the generated wasm file in increasing order of linear memory
+// address:
+//
+//   Address     Size Align Symbol
+//       400      fa0     1 p
+//      13a0        4     1 q
+//      13a8       40     1 __libc
+//      13f4        4     1 __stdin_used
+//      13f4        4     1 __stdout_used
+//
+//===----------------------------------------------------------------------===//
+
+#include "MapFile.h"
+#include "SymbolTable.h"
+#include "Symbols.h"
+#include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Strings.h"
+#include "lld/Common/Threads.h"
+#include "llvm/ADT/MapVector.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+using namespace lld;
+using namespace lld::wasm;
+
+// Print out the first three columns of a line.
+static void writeHeader(raw_ostream &OS, uint32_t VMA, uint32_t Size) {
+  OS << format("%8llx %8llx ", VMA, Size);
+}
+
+// Returns a list of all symbols that we want to print out.
+static std::vector<DefinedData *> getSymbols() {
+  std::vector<DefinedData *> V;
+  for (Symbol *B : Symtab->getSymbols())
+    if (auto *DR = dyn_cast<DefinedData>(B))
+      if (DR->isLive())
+        V.push_back(DR);
+  return V;
+}
+
+// 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<DefinedData *, std::string>
+getSymbolStrings(ArrayRef<DefinedData *> Syms) {
+  std::vector<std::string> Str(Syms.size());
+  parallelForEachN(0, Syms.size(), [&](size_t I) {
+    raw_string_ostream OS(Str[I]);
+    uint32_t VMA = Syms[I]->getVirtualAddress();
+    writeHeader(OS, VMA, Syms[I]->getSize());
+    OS << toString(*Syms[I]);
+  });
+
+  DenseMap<DefinedData *, 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::wasm::writeMapFile() {
+  if (Config->MapFile.empty())
+    return;
+
+  // Open a map file for writing.
+  std::error_code EC;
+  raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
+  if (EC) {
+    error("cannot open " + Config->MapFile + ": " + EC.message());
+    return;
+  }
+
+  // Collect symbol info that we want to print out.
+  std::vector<DefinedData *> Syms = getSymbols();
+  DenseMap<DefinedData *, std::string> SymStr = getSymbolStrings(Syms);
+
+  std::sort(Syms.begin(), Syms.end(), [](DefinedData *A, DefinedData *B) {
+    return A->getVirtualAddress() < B->getVirtualAddress();
+  });
+
+  // Print out the header line.
+  OS << " Address     Size Symbol\n";
+
+  for (DefinedData *Sym : Syms) {
+    OS << SymStr[Sym] << '\n';
+  }
+}

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">;
 
+def print_map: F<"print-map">,
+  HelpText<"Print a link map to the standard output">;
+
 def no_threads: F<"no-threads">,
   HelpText<"Do not run the linker multi-threaded">;
 
 def no_color_diagnostics: F<"no-color-diagnostics">,
   HelpText<"Do not use colors in diagnostics">;
 
 def no_fatal_warnings: F<"no-fatal-warnings">;
 

 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<print_map>;
 def: Flag<["-"], "m">, Alias<max_memory>;
 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>;
 

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"
void Writer::run() {
 
   writeHeader();
 
   log("-- writeSections");
   writeSections();
   if (errorCount())
     return;
 
+  writeMapFile();
+
   if (Error E = Buffer->commit())
     fatal("failed to write the output file: " + toString(std::move(E)));
 }
 
 // Open a result file.
 void Writer::openFile() {
   log("writing: " + Config->OutputFile);