354 строки
12 KiB
Python
Executable File
354 строки
12 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# Copyright 2018 The Emscripten Authors. All rights reserved.
|
|
# Emscripten is available under two separate licenses, the MIT license and the
|
|
# University of Illinois/NCSA Open Source License. Both these licenses can be
|
|
# found in the LICENSE file.
|
|
|
|
"""Utility tools that extracts DWARF information encoded in a wasm output
|
|
produced by the LLVM tools, and encodes it as a wasm source map. Additionally,
|
|
it can collect original sources, change files prefixes, and strip debug
|
|
sections from a wasm file.
|
|
"""
|
|
|
|
import argparse
|
|
from collections import OrderedDict
|
|
import json
|
|
import logging
|
|
from math import floor, log
|
|
import os
|
|
import re
|
|
from subprocess import Popen, PIPE
|
|
import sys
|
|
|
|
sys.path.insert(1, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
|
|
logger = logging.getLogger('wasm-sourcemap')
|
|
|
|
|
|
def parse_args():
|
|
parser = argparse.ArgumentParser(prog='wasm-sourcemap.py', description=__doc__)
|
|
parser.add_argument('wasm', help='wasm file')
|
|
parser.add_argument('-o', '--output', help='output source map')
|
|
parser.add_argument('-p', '--prefix', nargs='*', help='replace source debug filename prefix for source map', default=[])
|
|
parser.add_argument('-s', '--sources', action='store_true', help='read and embed source files from file system into source map')
|
|
parser.add_argument('-l', '--load-prefix', nargs='*', help='replace source debug filename prefix for reading sources from file system (see also --sources)', default=[])
|
|
parser.add_argument('-w', nargs='?', help='set output wasm file')
|
|
parser.add_argument('-x', '--strip', action='store_true', help='removes debug and linking sections')
|
|
parser.add_argument('-u', '--source-map-url', nargs='?', help='specifies sourceMappingURL section contest')
|
|
parser.add_argument('--dwarfdump', help="path to llvm-dwarfdump executable")
|
|
parser.add_argument('--dwarfdump-output', nargs='?', help=argparse.SUPPRESS)
|
|
parser.add_argument('--basepath', help='base path for source files, which will be relative to this')
|
|
return parser.parse_args()
|
|
|
|
|
|
class Prefixes:
|
|
def __init__(self, args):
|
|
prefixes = []
|
|
for p in args:
|
|
if '=' in p:
|
|
prefix, replacement = p.split('=')
|
|
prefixes.append({'prefix': prefix, 'replacement': replacement})
|
|
else:
|
|
prefixes.append({'prefix': p, 'replacement': None})
|
|
self.prefixes = prefixes
|
|
self.cache = {}
|
|
|
|
def resolve(self, name):
|
|
if name in self.cache:
|
|
return self.cache[name]
|
|
|
|
for p in self.prefixes:
|
|
if name.startswith(p['prefix']):
|
|
if p['replacement'] is None:
|
|
result = name[len(p['prefix'])::]
|
|
else:
|
|
result = p['replacement'] + name[len(p['prefix'])::]
|
|
break
|
|
self.cache[name] = result
|
|
return result
|
|
|
|
|
|
# SourceMapPrefixes contains resolver for file names that are:
|
|
# - "sources" is for names that output to source maps JSON
|
|
# - "load" is for paths that used to load source text
|
|
class SourceMapPrefixes:
|
|
def __init__(self, sources, load):
|
|
self.sources = sources
|
|
self.load = load
|
|
|
|
def provided(self):
|
|
return bool(self.sources.prefixes or self.load.prefixes)
|
|
|
|
|
|
def encode_vlq(n):
|
|
VLQ_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
|
x = (n << 1) if n >= 0 else ((-n << 1) + 1)
|
|
result = ""
|
|
while x > 31:
|
|
result = result + VLQ_CHARS[32 + (x & 31)]
|
|
x = x >> 5
|
|
return result + VLQ_CHARS[x]
|
|
|
|
|
|
def read_var_uint(wasm, pos):
|
|
n = 0
|
|
shift = 0
|
|
b = ord(wasm[pos:pos + 1])
|
|
pos = pos + 1
|
|
while b >= 128:
|
|
n = n | ((b - 128) << shift)
|
|
b = ord(wasm[pos:pos + 1])
|
|
pos = pos + 1
|
|
shift += 7
|
|
return n + (b << shift), pos
|
|
|
|
|
|
def strip_debug_sections(wasm):
|
|
logger.debug('Strip debug sections')
|
|
pos = 8
|
|
stripped = wasm[:pos]
|
|
|
|
while pos < len(wasm):
|
|
section_start = pos
|
|
section_id, pos_ = read_var_uint(wasm, pos)
|
|
section_size, section_body = read_var_uint(wasm, pos_)
|
|
pos = section_body + section_size
|
|
if section_id == 0:
|
|
name_len, name_pos = read_var_uint(wasm, section_body)
|
|
name_end = name_pos + name_len
|
|
name = wasm[name_pos:name_end]
|
|
if name == "linking" or name == "sourceMappingURL" or name.startswith("reloc..debug_") or name.startswith(".debug_"):
|
|
continue # skip debug related sections
|
|
stripped = stripped + wasm[section_start:pos]
|
|
|
|
return stripped
|
|
|
|
|
|
def encode_uint_var(n):
|
|
result = bytearray()
|
|
while n > 127:
|
|
result.append(128 | (n & 127))
|
|
n = n >> 7
|
|
result.append(n)
|
|
return bytes(result)
|
|
|
|
|
|
def append_source_mapping(wasm, url):
|
|
logger.debug('Append sourceMappingURL section')
|
|
section_name = "sourceMappingURL"
|
|
section_content = encode_uint_var(len(section_name)) + section_name + encode_uint_var(len(url)) + url
|
|
return wasm + encode_uint_var(0) + encode_uint_var(len(section_content)) + section_content
|
|
|
|
|
|
def get_code_section_offset(wasm):
|
|
logger.debug('Read sections index')
|
|
pos = 8
|
|
|
|
while pos < len(wasm):
|
|
section_id, pos_ = read_var_uint(wasm, pos)
|
|
section_size, pos = read_var_uint(wasm, pos_)
|
|
if section_id == 10:
|
|
return pos
|
|
pos = pos + section_size
|
|
|
|
|
|
def remove_dead_entries(entries):
|
|
# Remove entries for dead functions. It is a heuristics to ignore data if the
|
|
# function starting address near to 0 (is equal to its size field length).
|
|
block_start = 0
|
|
cur_entry = 0
|
|
while cur_entry < len(entries):
|
|
if not entries[cur_entry]['eos']:
|
|
cur_entry += 1
|
|
continue
|
|
fn_start = entries[block_start]['address']
|
|
# Calculate the LEB encoded function size (including size field)
|
|
fn_size_length = floor(log(entries[cur_entry]['address'] - fn_start + 1, 128)) + 1
|
|
min_live_offset = 1 + fn_size_length # 1 byte is for code section entries
|
|
if fn_start < min_live_offset:
|
|
# Remove dead code debug info block.
|
|
del entries[block_start:cur_entry + 1]
|
|
cur_entry = block_start
|
|
continue
|
|
cur_entry += 1
|
|
block_start = cur_entry
|
|
|
|
|
|
def read_dwarf_entries(wasm, options):
|
|
if options.dwarfdump_output:
|
|
output = open(options.dwarfdump_output, 'rb').read()
|
|
elif options.dwarfdump:
|
|
logger.debug('Reading DWARF information from %s' % wasm)
|
|
if not os.path.exists(options.dwarfdump):
|
|
logger.error('llvm-dwarfdump not found: ' + options.dwarfdump)
|
|
sys.exit(1)
|
|
process = Popen([options.dwarfdump, '-debug-info', '-debug-line', '--recurse-depth=0', wasm], stdout=PIPE)
|
|
output, err = process.communicate()
|
|
exit_code = process.wait()
|
|
if exit_code != 0:
|
|
logger.error('Error during llvm-dwarfdump execution (%s)' % exit_code)
|
|
sys.exit(1)
|
|
else:
|
|
logger.error('Please specify either --dwarfdump or --dwarfdump-output')
|
|
sys.exit(1)
|
|
|
|
entries = []
|
|
debug_line_chunks = re.split(r"debug_line\[(0x[0-9a-f]*)\]", output.decode('utf-8'))
|
|
maybe_debug_info_content = debug_line_chunks[0]
|
|
for i in range(1, len(debug_line_chunks), 2):
|
|
stmt_list = debug_line_chunks[i]
|
|
comp_dir_match = re.search(r"DW_AT_stmt_list\s+\(" + stmt_list + r"\)\s+" +
|
|
r"DW_AT_comp_dir\s+\(\"([^\"]+)", maybe_debug_info_content)
|
|
comp_dir = comp_dir_match.group(1) if comp_dir_match is not None else ""
|
|
|
|
line_chunk = debug_line_chunks[i + 1]
|
|
|
|
# include_directories[ 1] = "/Users/yury/Work/junk/sqlite-playground/src"
|
|
# file_names[ 1]:
|
|
# name: "playground.c"
|
|
# dir_index: 1
|
|
# mod_time: 0x00000000
|
|
# length: 0x00000000
|
|
#
|
|
# Address Line Column File ISA Discriminator Flags
|
|
# ------------------ ------ ------ ------ --- ------------- -------------
|
|
# 0x0000000000000006 22 0 1 0 0 is_stmt
|
|
# 0x0000000000000007 23 10 1 0 0 is_stmt prologue_end
|
|
# 0x000000000000000f 23 3 1 0 0
|
|
# 0x0000000000000010 23 3 1 0 0 end_sequence
|
|
# 0x0000000000000011 28 0 1 0 0 is_stmt
|
|
|
|
include_directories = {'0': comp_dir}
|
|
for dir in re.finditer(r"include_directories\[\s*(\d+)\] = \"([^\"]*)", line_chunk):
|
|
include_directories[dir.group(1)] = dir.group(2)
|
|
|
|
files = {}
|
|
for file in re.finditer(r"file_names\[\s*(\d+)\]:\s+name: \"([^\"]*)\"\s+dir_index: (\d+)", line_chunk):
|
|
dir = include_directories[file.group(3)]
|
|
file_path = (dir + '/' if file.group(2)[0] != '/' else '') + file.group(2)
|
|
files[file.group(1)] = file_path
|
|
|
|
for line in re.finditer(r"\n0x([0-9a-f]+)\s+(\d+)\s+(\d+)\s+(\d+)(.*?end_sequence)?", line_chunk):
|
|
entry = {'address': int(line.group(1), 16), 'line': int(line.group(2)), 'column': int(line.group(3)), 'file': files[line.group(4)], 'eos': line.group(5) is not None}
|
|
if not entry['eos']:
|
|
entries.append(entry)
|
|
else:
|
|
# move end of function to the last END operator
|
|
entry['address'] -= 1
|
|
if entries[-1]['address'] == entry['address']:
|
|
# last entry has the same address, reusing
|
|
entries[-1]['eos'] = True
|
|
else:
|
|
entries.append(entry)
|
|
|
|
remove_dead_entries(entries)
|
|
|
|
# return entries sorted by the address field
|
|
return sorted(entries, key=lambda entry: entry['address'])
|
|
|
|
|
|
def normalize_path(path):
|
|
return path.replace('\\', '/').replace('//', '/')
|
|
|
|
|
|
def build_sourcemap(entries, code_section_offset, prefixes, collect_sources, base_path):
|
|
sources = []
|
|
sources_content = [] if collect_sources else None
|
|
mappings = []
|
|
sources_map = {}
|
|
last_address = 0
|
|
last_source_id = 0
|
|
last_line = 1
|
|
last_column = 1
|
|
for entry in entries:
|
|
line = entry['line']
|
|
column = entry['column']
|
|
# ignore entries with line 0
|
|
if line == 0:
|
|
continue
|
|
# start at least at column 1
|
|
if column == 0:
|
|
column = 1
|
|
address = entry['address'] + code_section_offset
|
|
file_name = entry['file']
|
|
file_name = normalize_path(file_name)
|
|
# if prefixes were provided, we use that; otherwise, we emit a relative
|
|
# path
|
|
if prefixes.provided():
|
|
source_name = prefixes.sources.resolve(file_name)
|
|
else:
|
|
try:
|
|
file_name = os.path.relpath(file_name, base_path)
|
|
except ValueError:
|
|
file_name = os.path.abspath(file_name)
|
|
file_name = normalize_path(file_name)
|
|
source_name = file_name
|
|
if source_name not in sources_map:
|
|
source_id = len(sources)
|
|
sources_map[source_name] = source_id
|
|
sources.append(source_name)
|
|
if collect_sources:
|
|
load_name = prefixes.load.resolve(file_name)
|
|
try:
|
|
with open(load_name, 'r') as infile:
|
|
source_content = infile.read()
|
|
sources_content.append(source_content)
|
|
except IOError:
|
|
print('Failed to read source: %s' % load_name)
|
|
sources_content.append(None)
|
|
else:
|
|
source_id = sources_map[source_name]
|
|
|
|
address_delta = address - last_address
|
|
source_id_delta = source_id - last_source_id
|
|
line_delta = line - last_line
|
|
column_delta = column - last_column
|
|
mappings.append(encode_vlq(address_delta) + encode_vlq(source_id_delta) + encode_vlq(line_delta) + encode_vlq(column_delta))
|
|
last_address = address
|
|
last_source_id = source_id
|
|
last_line = line
|
|
last_column = column
|
|
return OrderedDict([('version', 3),
|
|
('names', []),
|
|
('sources', sources),
|
|
('sourcesContent', sources_content),
|
|
('mappings', ','.join(mappings))])
|
|
|
|
|
|
def main():
|
|
options = parse_args()
|
|
|
|
wasm_input = options.wasm
|
|
with open(wasm_input, 'rb') as infile:
|
|
wasm = infile.read()
|
|
|
|
entries = read_dwarf_entries(wasm_input, options)
|
|
|
|
code_section_offset = get_code_section_offset(wasm)
|
|
|
|
prefixes = SourceMapPrefixes(sources=Prefixes(options.prefix), load=Prefixes(options.load_prefix))
|
|
|
|
logger.debug('Saving to %s' % options.output)
|
|
map = build_sourcemap(entries, code_section_offset, prefixes, options.sources, options.basepath)
|
|
with open(options.output, 'w') as outfile:
|
|
json.dump(map, outfile, separators=(',', ':'))
|
|
|
|
if options.strip:
|
|
wasm = strip_debug_sections(wasm)
|
|
|
|
if options.source_map_url:
|
|
wasm = append_source_mapping(wasm, options.source_map_url)
|
|
|
|
if options.w:
|
|
logger.debug('Saving wasm to %s' % options.w)
|
|
with open(options.w, 'wb') as outfile:
|
|
outfile.write(wasm)
|
|
|
|
logger.debug('Done')
|
|
return 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
logging.basicConfig(level=logging.DEBUG if os.environ.get('EMCC_DEBUG') else logging.INFO)
|
|
sys.exit(main())
|