Support names field in source maps

This adds support for `names` field in source maps, which contains
function names. Source map mappings are correspondingly updated and
emsymbolizer now can provide function name information only with source
maps.

While source maps don't provide the full inlined hierarchies, this
provides the name of the original (= pre-inlining) function, which may
not exist in the final binary because they were inlined. This is because
source maps are primarily intended for user debugging.

This also demangles C++ function names using `llvm-cxxfilt`, so the
printed names can be human-readable.

I tested with `wasm-opt.wasm` from Binaryen by `if (EMSCRIPTEN)` setup
here:
https://github.com/WebAssembly/binaryen/blob/95b2cf0a4ab2386f099568c5c61a02163770af32/CMakeLists.txt#L311-L372
with `-g -gsource-map`. With this PR and
WebAssembly/binaryen#8068, the source map file
size increases by 3.5x (8632423 -> 30070042) primarily due to the
function name strings.

From `llvm-dwarfdump` output, this also requires additional parsing of
`DW_TAG_subprogram` and `DW_TAG_inlined_subroutine` tags which can be at
any depths (because functions can be within nested namespaces or
classes), so we cannot use `--recurse-depth=0` (#9580) anymore. In case
of `wasm-opt.wasm` built with DWARF info, without `--recurse-depth=0` in
the command line, the size of its text output increased by 27.5x, but
with the `--filter-child-tag` / `-t` option
(llvm/llvm-project#165720), the text output
increased only (?) by 3.2x, which I think is tolerable. This disables
`names` field generation when `-t` option is not available in
`llvm-dwarfdump` because it was added recently. To avoid this text size
problem, we can consider using DWARF-parsing Python libraries like
https://github.com/eliben/pyelftools, but this will make another third
party dependency, so I'm not sure if it's worth it at this point.

This also increased running time of `wasm-sourcemap.py`, in case of the
`wasm-opt.wasm`, by 2.3x (6.6s -> 15.4s), but compared to the linking
time this was not very noticeable.

Fixes #20715 and closes #25116.

Author: aheejin

test/core/test_dwarf.cpp

@@ -0,0 +1,26 @@
+#include <emscripten.h>
+
+EM_JS(int, out_to_js, (int x), {})
+
+class MyClass {
+public:
+  void foo();
+  void bar();
+};
+
+void __attribute__((noinline)) MyClass::foo() {
+  out_to_js(0); // line 12
+  out_to_js(1);
+  out_to_js(2);
+}
+
+void __attribute__((always_inline)) MyClass::bar() {
+  out_to_js(3);
+  __builtin_trap(); // line 19
+}
+
+int main() {
+  MyClass mc;
+  mc.foo();
+  mc.bar();
+}

test/test_other.py

@@ -9639,12 +9639,50 @@ def check_dwarf_loc_info(address, funcs, locs):
       for loc in locs:
         self.assertIn(loc, out)
 
-    def check_source_map_loc_info(address, loc):
+    def check_source_map_loc_info(address, func, loc):
       out = self.run_process(
           [emsymbolizer, '-s', 'sourcemap', 'test_dwarf.wasm', address],
           stdout=PIPE).stdout
+      self.assertIn(func, out)
       self.assertIn(loc, out)
 
+    def do_tests(src):
+      # 1. Test DWARF + source map together
+      # For DWARF, we check for the full inlined info for both function names and
+      # source locations. Source maps does not provide inlined info. So we only
+      # check for the info of the outermost function.
+      self.run_process([EMCC, test_file(src), '-g', '-gsource-map', '-O1', '-o',
+                        'test_dwarf.js'])
+      check_dwarf_loc_info(out_to_js_call_addr, out_to_js_call_func,
+                           out_to_js_call_loc)
+      check_source_map_loc_info(out_to_js_call_addr, out_to_js_call_func[0],
+                                out_to_js_call_loc[0])
+      check_dwarf_loc_info(unreachable_addr, unreachable_func, unreachable_loc)
+      # Source map shows the original (inlined) source location with the original
+      # function name
+      check_source_map_loc_info(unreachable_addr, unreachable_func[0],
+                                unreachable_loc[0])
+
+      # 2. Test source map only
+      # The addresses, function names, and source locations are the same across
+      # the builds because they are relative offsets from the code section, so we
+      # don't need to recompute them
+      self.run_process([EMCC, test_file(src), '-gsource-map', '-O1', '-o',
+                        'test_dwarf.js'])
+      check_source_map_loc_info(out_to_js_call_addr, out_to_js_call_func[0],
+                                out_to_js_call_loc[0])
+      check_source_map_loc_info(unreachable_addr, unreachable_func[0],
+                                unreachable_loc[0])
+
+      # 3. Test DWARF only
+      self.run_process([EMCC, test_file(src), '-g', '-O1', '-o',
+                        'test_dwarf.js'])
+      check_dwarf_loc_info(out_to_js_call_addr, out_to_js_call_func,
+                           out_to_js_call_loc)
+      check_dwarf_loc_info(unreachable_addr, unreachable_func, unreachable_loc)
+
+
+    # -- C program test --
     # We test two locations within test_dwarf.c:
     # out_to_js(0);     // line 6
     # __builtin_trap(); // line 13
@@ -9667,31 +9705,32 @@ def check_source_map_loc_info(address, loc):
     # The first one corresponds to the innermost inlined location.
     unreachable_loc = ['test_dwarf.c:13:3', 'test_dwarf.c:18:3']
 
-    # 1. Test DWARF + source map together
-    # For DWARF, we check for the full inlined info for both function names and
-    # source locations. Source maps provide neither function names nor inlined
-    # info. So we only check for the source location of the outermost function.
-    check_dwarf_loc_info(out_to_js_call_addr, out_to_js_call_func,
-                         out_to_js_call_loc)
-    check_source_map_loc_info(out_to_js_call_addr, out_to_js_call_loc[0])
-    check_dwarf_loc_info(unreachable_addr, unreachable_func, unreachable_loc)
-    check_source_map_loc_info(unreachable_addr, unreachable_loc[0])
-
-    # 2. Test source map only
-    # The addresses, function names, and source locations are the same across
-    # the builds because they are relative offsets from the code section, so we
-    # don't need to recompute them
-    self.run_process([EMCC, test_file('core/test_dwarf.c'),
-                      '-gsource-map', '-O1', '-o', 'test_dwarf.js'])
-    check_source_map_loc_info(out_to_js_call_addr, out_to_js_call_loc[0])
-    check_source_map_loc_info(unreachable_addr, unreachable_loc[0])
+    do_tests('core/test_dwarf.c')
 
-    # 3. Test DWARF only
-    self.run_process([EMCC, test_file('core/test_dwarf.c'),
-                      '-g', '-O1', '-o', 'test_dwarf.js'])
-    check_dwarf_loc_info(out_to_js_call_addr, out_to_js_call_func,
-                         out_to_js_call_loc)
-    check_dwarf_loc_info(unreachable_addr, unreachable_func, unreachable_loc)
+    # -- C++ program test --
+    # We test two locations within test_dwarf.cpp:
+    # out_to_js(0);     // line 12
+    # __builtin_trap(); // line 19
+    self.run_process([EMCC, test_file('core/test_dwarf.cpp'),
+                      '-g', '-gsource-map', '-O1', '-o', 'test_dwarf.js'])
+    # Address of out_to_js(0) within MyClass::foo(), uninlined
+    out_to_js_call_addr = self.get_instr_addr('call\t0', 'test_dwarf.wasm')
+    # Address of __builtin_trap() within MyClass::bar(), inlined into main()
+    unreachable_addr = self.get_instr_addr('unreachable', 'test_dwarf.wasm')
+
+    # Function name of out_to_js(0) within MyClass::foo(), uninlined
+    out_to_js_call_func = ['MyClass::foo()']
+    # Function names of __builtin_trap() within MyClass::bar(), inlined into
+    # main(). The first one corresponds to the innermost inlined function.
+    unreachable_func = ['MyClass::bar()', 'main']
+
+    # Source location of out_to_js(0) within MyClass::foo(), uninlined
+    out_to_js_call_loc = ['test_dwarf.cpp:12:3']
+    # Source locations of __builtin_trap() within MyClass::bar(), inlined into
+    # main(). The first one corresponds to the innermost inlined location.
+    unreachable_loc = ['test_dwarf.cpp:19:3', 'test_dwarf.cpp:25:6']
+
+    do_tests('core/test_dwarf.cpp')
 
   def test_emsymbolizer_functions(self):
     'Test emsymbolizer use cases that only provide function-granularity info'

tools/emsymbolizer.py

@@ -118,6 +118,7 @@ class Location:
   def __init__(self):
     self.version = None
     self.sources = []
+    self.funcs = []
     self.mappings = {}
     self.offsets = []
 
@@ -129,6 +130,7 @@ def parse(self, filename):
 
     self.version = source_map_json['version']
     self.sources = source_map_json['sources']
+    self.funcs = source_map_json['names']
 
     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
     vlq_map = {c: i for i, c in enumerate(chars)}
@@ -156,6 +158,7 @@ def decodeVLQ(string):
     src = 0
     line = 1
     col = 1
+    func = 0
     for segment in source_map_json['mappings'].split(','):
       data = decodeVLQ(segment)
       info = []
@@ -170,7 +173,9 @@ def decodeVLQ(string):
       if len(data) >= 4:
         col += data[3]
         info.append(col)
-      # TODO: see if we need the name, which is the next field (data[4])
+      if len(data) == 5:
+        func += data[4]
+        info.append(func)
 
       self.mappings[offset] = WasmSourceMap.Location(*info)
       self.offsets.append(offset)
@@ -208,6 +213,7 @@ def lookup(self, offset, lower_bound=None):
         self.sources[info.source] if info.source is not None else None,
         info.line,
         info.column,
+        self.funcs[info.func] if info.func is not None else None,
       )