You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
248 lines
8.3 KiB
248 lines
8.3 KiB
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (C) 2019 The Android Open Source Project
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in
|
|
# the documentation and/or other materials provided with the
|
|
# distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
# SUCH DAMAGE.
|
|
|
|
# Scan an ELF file and its tree of DT_NEEDED ELF files, and dump out a JSON file listing:
|
|
# - each ELF file
|
|
# - its DT_NEEDED entries
|
|
# - its defined symbols
|
|
# - its relocations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import re
|
|
import shlex
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import textwrap
|
|
import typing
|
|
from enum import Enum
|
|
from typing import Any, Set, List, Dict, Optional
|
|
from subprocess import PIPE, DEVNULL
|
|
from pathlib import Path
|
|
|
|
from common_types import LoadedLibrary, SymBind, SymKind, DynSymbol, DynSymbols, Relocations, \
|
|
SymbolRef, bfs_walk, elf_tree_to_json
|
|
|
|
|
|
g_readelf_cache: Dict[str, str] = {}
|
|
g_path_to_soname_cache: Dict[Path, str] = {}
|
|
|
|
def do_readelf_query(arguments: List[str]) -> List[str]:
|
|
cmdline = ['llvm-readelf'] + arguments
|
|
key = repr(cmdline)
|
|
if key in g_readelf_cache: return g_readelf_cache[key].splitlines()
|
|
out = subprocess.run(cmdline, check=True, stdout=PIPE).stdout.decode()
|
|
g_readelf_cache[key] = out
|
|
return out.splitlines()
|
|
|
|
|
|
def get_elf_soname(path: Path) -> str:
|
|
if path in g_path_to_soname_cache: return g_path_to_soname_cache[path]
|
|
out = do_readelf_query(['-d', str(path)])
|
|
for line in out:
|
|
m = re.search(r'\(SONAME\)\s+Library soname: \[(.+)\]$', line)
|
|
if not m: continue
|
|
result = m.group(1)
|
|
break
|
|
else:
|
|
result = os.path.basename(path)
|
|
g_path_to_soname_cache[path] = result
|
|
return result
|
|
|
|
|
|
def get_elf_needed(path: Path) -> List[str]:
|
|
result = []
|
|
out = do_readelf_query(['-d', str(path)])
|
|
for line in out:
|
|
m = re.search(r'\(NEEDED\)\s+Shared library: \[(.+)\]$', line)
|
|
if not m: continue
|
|
result.append(m.group(1))
|
|
return result
|
|
|
|
|
|
kSymbolMatcher = re.compile(r'''
|
|
\s+ (\d+) : \s* # number
|
|
[0-9a-f]+ \s+ # value
|
|
[0-9a-f]+ \s+ # size
|
|
(FUNC|IFUNC|OBJECT|NOTYPE) \s+ # type
|
|
(GLOBAL|WEAK) \s+ # bind
|
|
\w+ \s+ # vis
|
|
(\d+|UND) \s+ # ndx
|
|
([\.\w]+) # name
|
|
(?:(@@?)(\w+))? # version
|
|
$
|
|
''', re.VERBOSE)
|
|
|
|
|
|
def get_dyn_symbols(path: Path) -> DynSymbols:
|
|
kind_lookup = {
|
|
'FUNC': SymKind.Func,
|
|
'IFUNC': SymKind.Func,
|
|
'OBJECT': SymKind.Var,
|
|
'NOTYPE': SymKind.Func,
|
|
}
|
|
bind_lookup = { 'GLOBAL': SymBind.Global, 'WEAK': SymBind.Weak }
|
|
|
|
result = {}
|
|
out = do_readelf_query(['--dyn-syms', str(path)])
|
|
for line in out:
|
|
m = kSymbolMatcher.match(line)
|
|
if not m:
|
|
# gLinux currently has a version of llvm-readelf whose output is very different from
|
|
# the current versions of llvm-readelf (or GNU readelf).
|
|
if 'Symbol table of .gnu.hash for image:' in line:
|
|
sys.exit(f'error: obsolete version of llvm-readelf')
|
|
continue
|
|
|
|
num, kind, bind, ndx, name, ver_type, ver_name = m.groups()
|
|
|
|
if name == '__cfi_check':
|
|
# The linker gives an error like:
|
|
# CANNOT LINK EXECUTABLE "/data/local/tmp/out-linker-bench/b_libandroid_servers": unaligned __cfi_check in the library "(null)"
|
|
# I am probably breaking some kind of CFI invariant, so strip these out for now.
|
|
continue
|
|
|
|
result[int(num)] = DynSymbol(name, kind_lookup[kind], bind_lookup[bind], ndx != 'UND',
|
|
ver_type, ver_name)
|
|
|
|
return result
|
|
|
|
|
|
kRelocationMatcher = re.compile(r'''
|
|
([0-9a-f]+) \s+ # offset
|
|
([0-9a-f]+) \s+ # info
|
|
(\w+) # type
|
|
(?:
|
|
\s+ [0-9a-f]+ \s+ # symbol value
|
|
([\.\w]+) # symbol name
|
|
(?: @@? ([\.\w]+) )? # version
|
|
)?
|
|
\b
|
|
''', re.VERBOSE)
|
|
|
|
|
|
def scan_relocations(path: Path, syms: DynSymbols) -> Relocations:
|
|
result: Relocations = Relocations()
|
|
out = do_readelf_query(['-r', str(path)])
|
|
for line in out:
|
|
m = kRelocationMatcher.match(line)
|
|
if not m: continue
|
|
|
|
offset_str, info_str, reloc_name, sym_name, ver = m.groups()
|
|
|
|
if len(offset_str) == 8:
|
|
offset = int(offset_str, 16) // 4
|
|
sym_idx = int(info_str, 16) >> 8
|
|
elif len(offset_str) == 16:
|
|
offset = int(offset_str, 16) // 8
|
|
sym_idx = int(info_str, 16) >> 32
|
|
else:
|
|
sys.exit(f'error: invalid offset length: {repr(offset_str)}')
|
|
|
|
# TODO: R_ARM_IRELATIVE doesn't work, so skip it.
|
|
if reloc_name == 'R_ARM_IRELATIVE': continue
|
|
|
|
if reloc_name in ['R_ARM_RELATIVE', 'R_AARCH64_RELATIVE']:
|
|
assert sym_name is None
|
|
result.relative.append(offset)
|
|
else:
|
|
if sym_name is None:
|
|
sys.exit(f'error: missing symbol for reloc {m.groups()} in {path}')
|
|
|
|
is_weak = syms[sym_idx].bind == SymBind.Weak
|
|
symbol = SymbolRef(sym_name, is_weak, ver)
|
|
|
|
if reloc_name in ['R_ARM_JUMP_SLOT', 'R_AARCH64_JUMP_SLOT']:
|
|
result.jump_slots.append(symbol)
|
|
elif reloc_name in ['R_ARM_GLOB_DAT', 'R_AARCH64_GLOB_DAT']:
|
|
result.got.append(symbol)
|
|
elif reloc_name in ['R_ARM_ABS32', 'R_AARCH64_ABS64']:
|
|
result.symbolic.append((offset, symbol))
|
|
else:
|
|
sys.exit(f'error: unrecognized reloc {m.groups()} in {path}')
|
|
|
|
return result
|
|
|
|
|
|
def load_elf_tree(search_path: List[Path], path: Path) -> LoadedLibrary:
|
|
|
|
libraries: Dict[str, LoadedLibrary] = {}
|
|
|
|
def find_library(needed: str) -> Optional[LoadedLibrary]:
|
|
nonlocal libraries
|
|
|
|
if needed in libraries: return libraries[needed]
|
|
|
|
for candidate_dir in search_path:
|
|
candidate_path = candidate_dir / needed
|
|
if candidate_path.exists():
|
|
return load(candidate_path)
|
|
|
|
sys.exit(f'error: missing DT_NEEDED lib {needed}!')
|
|
|
|
def load(path: Path) -> LoadedLibrary:
|
|
nonlocal libraries
|
|
|
|
lib = LoadedLibrary()
|
|
lib.soname = get_elf_soname(path)
|
|
if lib.soname in libraries: sys.exit(f'soname already loaded: {lib.soname}')
|
|
libraries[lib.soname] = lib
|
|
|
|
lib.syms = get_dyn_symbols(path)
|
|
lib.rels = scan_relocations(path, lib.syms)
|
|
|
|
for needed in get_elf_needed(path):
|
|
needed_lib = find_library(needed)
|
|
if needed_lib is not None:
|
|
lib.needed.append(needed_lib)
|
|
|
|
return lib
|
|
|
|
return load(path)
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('input', type=str)
|
|
parser.add_argument('output', type=str)
|
|
parser.add_argument('-L', dest='search_path', metavar='PATH', action='append', type=str, default=[])
|
|
|
|
args = parser.parse_args()
|
|
search_path = [Path(p) for p in args.search_path]
|
|
|
|
with open(Path(args.output), 'w') as f:
|
|
root = load_elf_tree(search_path, Path(args.input))
|
|
json.dump(elf_tree_to_json(root), f, sort_keys=True, indent=2)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|