| #!/usr/bin/env python3 |
| # Copyright 2021 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Runs dwarfdump on passed-in .so.""" |
| |
| import argparse |
| import bisect |
| import dataclasses |
| import logging |
| import os |
| import re |
| import subprocess |
| import typing |
| |
| import path_util |
| |
| |
| _DWARF_DUMP_FLAGS = ['--debug-info', '--recurse-depth=0'] |
| |
| # Matching and group examples: |
| # '0x00001234: DW_TAG_compile_unit' -> None |
| # ' DW_AT_low_pc (0x123)' -> ('DW_', None) |
| # ' DW_AT_name ("foo")' -> ('DW_', 'foo') |
| _RE_DW_AT_NAME = re.compile(r'\s+(DW_)(?:AT_name\s+\("(.*?)"\))?') |
| |
| |
| class _DwoNameLookup: |
| """Helper to look up name (source file) from .dwo files |
| |
| dwarfdump of an ELF file normally specifies source files in DW_AT_name fields. |
| However, debug fission can move debug info from ELF files to .dwo files. In |
| this case, dwarfdump would omit DW_AT_name of affected symbols, and use |
| DW_AT_GNU_dwo_name to specify the path (relative to output dir) of the |
| matching .dwo files, whose dwarfdump would then specify the matching source |
| file in DW_AT_name. |
| |
| This class performs cached lookup from .dwo to name (source file). |
| """ |
| |
| def __init__(self, any_path): |
| finder = path_util.OutputDirectoryFinder( |
| any_path_within_output_directory=any_path) |
| self._output_path = finder.Detect() # May be None. |
| self._dwarf_dump_path = path_util.GetDwarfdumpPath() |
| self._cache = {} |
| |
| def _ReadName(self, dwo_path): |
| """Runs dwarfdump on .dwo to extract name. |
| |
| If this is not possible then returns |dwo_path|. |
| """ |
| if self._output_path is None: |
| return dwo_path |
| # Assumption: |dwo_path| is relative to output path. |
| real_dwo_path = os.path.join(self._output_path, dwo_path) |
| cmd = [self._dwarf_dump_path, real_dwo_path] + _DWARF_DUMP_FLAGS |
| proc = subprocess.Popen(cmd, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.DEVNULL, |
| encoding='utf-8') |
| name = None |
| state = 0 |
| # Scan output line by line, exit and terminate as soon as possible. |
| for line in iter(proc.stdout.readline, ''): |
| if state == 0: # Scan for DW_TAG_compile_unit. |
| if 'DW_TAG_compile_unit' in line: |
| state = 1 |
| elif state == 1: # scan for DW_AT_name. |
| m = _RE_DW_AT_NAME.match(line) |
| if not m: # Not even matching prefix ' DW_'. |
| break |
| name = m.groups()[1] |
| if name is not None: # Extracted names. |
| break |
| # Else matches ' DW_': Continue scanning. |
| proc.kill() |
| return dwo_path if name is None else name |
| |
| def Lookup(self, dwo_path): |
| """Looks up name in .dwo, with caching.""" |
| if dwo_path in self._cache: |
| name = self._cache[dwo_path] |
| else: |
| name = self._ReadName(dwo_path) |
| self._cache[dwo_path] = name |
| return name |
| |
| def LogStats(self): |
| if self._cache: |
| num_success = sum(1 for k, v in self._cache.items() if k != v) |
| logging.info('Successful .dwo lookups: %d / %d', num_success, |
| len(self._cache)) |
| |
| |
| @dataclasses.dataclass(order=True) |
| class _AddressRange: |
| start: int |
| stop: int |
| |
| |
| class _SourceMapper: |
| def __init__(self, range_info_list): |
| self._range_info_list = range_info_list |
| self._largest_address = 0 |
| |
| if self._range_info_list: |
| self._largest_address = self._range_info_list[-1][0].stop |
| |
| def FindSourceForTextAddress(self, address): |
| """Returns source file path matching passed-in symbol address. |
| |
| Only symbols in the .text section of the elf file are supported. |
| """ |
| # Bisect against stop = self._largest_address + 1 to avoid bisecting against |
| # the "source path" tuple component. |
| bisect_index = bisect.bisect_right( |
| self._range_info_list, |
| (_AddressRange(address, self._largest_address + 1), '')) - 1 |
| if bisect_index >= 0: |
| info = self._range_info_list[bisect_index] |
| if info[0].start <= address < info[0].stop: |
| return info[1] |
| |
| return '' |
| |
| def NumberOfPaths(self): |
| return len(set(info[1] for info in self._range_info_list)) |
| |
| @property |
| def num_ranges(self): |
| return len(self._range_info_list) |
| |
| |
| def CreateAddressSourceMapper(elf_path): |
| """Runs dwarfdump. Returns object for querying source path given address.""" |
| return _SourceMapper(_Parse(elf_path)) |
| |
| |
| def CreateAddressSourceMapperForTest(lines, dwo_name_lookup=None): |
| return _SourceMapper(_ParseDumpOutput(lines, dwo_name_lookup)) |
| |
| |
| def ParseDumpOutputForTest(lines, dwo_name_lookup=None): |
| return _ParseDumpOutput(lines, dwo_name_lookup) |
| |
| |
| def _Parse(elf_path): |
| cmd = [path_util.GetDwarfdumpPath(), elf_path] + _DWARF_DUMP_FLAGS |
| logging.debug('Running: %s', ' '.join(cmd)) |
| stdout = subprocess.check_output(cmd, |
| stderr=subprocess.DEVNULL, |
| encoding='utf-8') |
| return _ParseDumpOutput(stdout.splitlines(), _DwoNameLookup(elf_path)) |
| |
| |
| def _ParseDumpOutput(lines, dwo_name_lookup=None): |
| """Parses passed-in dwarfdump stdout.""" |
| |
| # List of (_AddressRange, source path) tuples. |
| range_info_list = [] |
| |
| line_it = iter(lines) |
| line = next(line_it, None) |
| while line is not None: |
| if 'DW_TAG_compile_unit' not in line: |
| line = next(line_it, None) |
| continue |
| |
| line, address_ranges, source_path, dwo_path = _ParseCompileUnit(line_it) |
| if (source_path or dwo_path) and address_ranges: |
| for address_range in address_ranges: |
| if dwo_path: |
| source_path = (dwo_name_lookup.Lookup(dwo_path) |
| if dwo_name_lookup else dwo_path) |
| range_info_list.append((address_range, source_path)) |
| |
| if dwo_name_lookup: |
| dwo_name_lookup.LogStats() |
| |
| return sorted(range_info_list) |
| |
| |
| def _ParseCompileUnit(line_it): |
| """Parses DW_AT_compile_unit block. |
| |
| Example: |
| 0x000026: DW_AT_compile_unit |
| DW_AT_low_pc (0x02f) |
| DW_AT_high_pc (0x03f) |
| DW_AT_name ("foo.cc") |
| DW_AT_GNU_dwo_name ("foo.dwo") |
| """ |
| source_path = None |
| dwo_path = None |
| single_range = _AddressRange(0, 0) |
| range_addresses = [] |
| |
| while True: |
| line = next(line_it, None) |
| |
| dw_index = 0 if line is None else line.find('DW_') |
| if dw_index < 0: |
| continue |
| |
| if line is None or line.startswith('DW_TAG', dw_index): |
| if range_addresses: |
| # If compile unit specifies both DW_AT_ranges and DW_AT_low_pc, |
| # DW_AT_low_pc is base offset. Base offset is currently unsupported. |
| assert single_range.start == 0 |
| elif single_range.start > 0: |
| range_addresses.append(single_range) |
| return (line, range_addresses, source_path, dwo_path) |
| |
| if line.startswith('DW_AT_low_pc', dw_index): |
| single_range.start = int(_ExtractDwValue(line), 16) |
| if single_range.stop == 0: |
| single_range.stop = single_range.start + 1 |
| elif line.startswith('DW_AT_high_pc', dw_index): |
| single_range.stop = int(_ExtractDwValue(line), 16) |
| elif line.startswith('DW_AT_name', dw_index): |
| source_path = _ExtractDwValue(line) |
| elif line.startswith('DW_AT_GNU_dwo_name', dw_index): |
| dwo_path = _ExtractDwValue(line) |
| elif line.startswith('DW_AT_ranges', dw_index): |
| range_addresses = _ParseRanges(line_it) |
| |
| |
| def _ParseRanges(line_it): |
| """Parses DW_AT_ranges from dwarfdump stdout. |
| |
| Example: |
| [0x1, 0x2) |
| [0x5, 0x10)) |
| """ |
| range_addresses = [] |
| |
| line = next(line_it, None) |
| while line is not None: |
| num_opening_brackets = line.count('(') + line.count('[') |
| num_closing_brackets = line.count(')') + line.count(']') |
| |
| tokens = line.strip('([]) \t').split(',') |
| if len(tokens) == 2: |
| start_address = int(tokens[0], 16) |
| end_address = int(tokens[1], 16) |
| # Dwarf spec does not assign special meaning to empty ranges. |
| if start_address != end_address: |
| range_addresses.append(_AddressRange(start_address, end_address)) |
| |
| if num_closing_brackets > num_opening_brackets: |
| break |
| line = next(line_it, None) |
| |
| return range_addresses |
| |
| |
| def _ExtractDwValue(line): |
| """Extract DW_AT_ value from dwarfdump stdout. |
| |
| Examples: |
| DW_AT_name ("foo.cc") |
| DW_AT_decl_line (177) |
| DW_AT_low_pc (0x2) |
| """ |
| lparen_index = line.rfind('(') |
| if lparen_index < 0: |
| return None |
| rparen_index = line.find(')', lparen_index + 1) |
| if rparen_index < 0: |
| return None |
| if (lparen_index < rparen_index - 2 and line[lparen_index + 1] == '"' |
| and line[rparen_index - 1] == '"'): |
| lparen_index += 1 |
| rparen_index -= 1 |
| return line[lparen_index + 1:rparen_index] |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser() |
| group = parser.add_mutually_exclusive_group(required=True) |
| group.add_argument('--dwarf-dump-output', type=os.path.realpath) |
| group.add_argument('--elf-file', type=os.path.realpath) |
| |
| args = parser.parse_args() |
| logging.basicConfig(level=logging.DEBUG, |
| format='%(levelname).1s %(relativeCreated)6d %(message)s') |
| |
| if args.dwarf_dump_output: |
| dwo_name_lookup = _DwoNameLookup(args.dwarf_dump_output) |
| with open(args.dwarf_dump_output, 'r') as f: |
| source_mapper = CreateAddressSourceMapperForTest(f.read().splitlines(), |
| dwo_name_lookup) |
| else: |
| assert args.elf_file |
| source_mapper = CreateAddressSourceMapper(args.elf_file) |
| logging.warning('Found %d source paths across %d ranges', |
| source_mapper.NumberOfPaths(), source_mapper.num_ranges) |
| |
| |
| if __name__ == '__main__': |
| main() |
