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.
434 lines
15 KiB
434 lines
15 KiB
#!/usr/bin/python
|
|
#
|
|
# Copyright 2013 Google Inc. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import fileinput
|
|
import operator
|
|
import optparse
|
|
import os
|
|
import pprint
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import json
|
|
|
|
def format_bytes(bytes):
|
|
"""Pretty-print a number of bytes."""
|
|
if bytes > 1e6:
|
|
bytes = bytes / 1.0e6
|
|
return '%.1fm' % bytes
|
|
if bytes > 1e3:
|
|
bytes = bytes / 1.0e3
|
|
return '%.1fk' % bytes
|
|
return str(bytes)
|
|
|
|
|
|
def symbol_type_to_human(type):
|
|
"""Convert a symbol type as printed by nm into a human-readable name."""
|
|
return {
|
|
'b': 'bss',
|
|
'd': 'data',
|
|
'r': 'read-only data',
|
|
't': 'code',
|
|
'u': 'weak symbol', # Unique global.
|
|
'w': 'weak symbol',
|
|
'v': 'weak symbol'
|
|
}[type]
|
|
|
|
|
|
def parse_nm(input):
|
|
"""Parse nm output.
|
|
|
|
Argument: an iterable over lines of nm output.
|
|
|
|
Yields: (symbol name, symbol type, symbol size, source file path).
|
|
Path may be None if nm couldn't figure out the source file.
|
|
"""
|
|
|
|
# Match lines with size + symbol + optional filename.
|
|
sym_re = re.compile(r'^[0-9a-f]+ ([0-9a-f]+) (.) ([^\t]+)(?:\t(.*):\d+)?$')
|
|
|
|
# Match lines with addr but no size.
|
|
addr_re = re.compile(r'^[0-9a-f]+ (.) ([^\t]+)(?:\t.*)?$')
|
|
# Match lines that don't have an address at all -- typically external symbols.
|
|
noaddr_re = re.compile(r'^ + (.) (.*)$')
|
|
|
|
for line in input:
|
|
line = line.rstrip()
|
|
match = sym_re.match(line)
|
|
if match:
|
|
size, type, sym = match.groups()[0:3]
|
|
size = int(size, 16)
|
|
type = type.lower()
|
|
if type in ['u', 'v']:
|
|
type = 'w' # just call them all weak
|
|
if type == 'b':
|
|
continue # skip all BSS for now
|
|
path = match.group(4)
|
|
yield sym, type, size, path
|
|
continue
|
|
match = addr_re.match(line)
|
|
if match:
|
|
type, sym = match.groups()[0:2]
|
|
# No size == we don't care.
|
|
continue
|
|
match = noaddr_re.match(line)
|
|
if match:
|
|
type, sym = match.groups()
|
|
if type in ('U', 'w'):
|
|
# external or weak symbol
|
|
continue
|
|
|
|
print >>sys.stderr, 'unparsed:', repr(line)
|
|
|
|
def demangle(ident, cppfilt):
|
|
if cppfilt and ident.startswith('_Z'):
|
|
# Demangle names when possible. Mangled names all start with _Z.
|
|
ident = subprocess.check_output([cppfilt, ident]).strip()
|
|
return ident
|
|
|
|
|
|
class Suffix:
|
|
def __init__(self, suffix, replacement):
|
|
self.pattern = '^(.*)' + suffix + '(.*)$'
|
|
self.re = re.compile(self.pattern)
|
|
self.replacement = replacement
|
|
|
|
class SuffixCleanup:
|
|
"""Pre-compile suffix regular expressions."""
|
|
def __init__(self):
|
|
self.suffixes = [
|
|
Suffix('\.part\.([0-9]+)', 'part'),
|
|
Suffix('\.constprop\.([0-9]+)', 'constprop'),
|
|
Suffix('\.isra\.([0-9]+)', 'isra'),
|
|
]
|
|
def cleanup(self, ident, cppfilt):
|
|
"""Cleanup identifiers that have suffixes preventing demangling,
|
|
and demangle if possible."""
|
|
to_append = []
|
|
for s in self.suffixes:
|
|
found = s.re.match(ident)
|
|
if not found:
|
|
continue
|
|
to_append += [' [' + s.replacement + '.' + found.group(2) + ']']
|
|
ident = found.group(1) + found.group(3)
|
|
if len(to_append) > 0:
|
|
# Only try to demangle if there were suffixes.
|
|
ident = demangle(ident, cppfilt)
|
|
for s in to_append:
|
|
ident += s
|
|
return ident
|
|
|
|
suffix_cleanup = SuffixCleanup()
|
|
|
|
def parse_cpp_name(name, cppfilt):
|
|
name = suffix_cleanup.cleanup(name, cppfilt)
|
|
|
|
# Turn prefixes into suffixes so namespacing works.
|
|
prefixes = [
|
|
['bool ', ''],
|
|
['construction vtable for ', ' [construction vtable]'],
|
|
['global constructors keyed to ', ' [global constructors]'],
|
|
['guard variable for ', ' [guard variable]'],
|
|
['int ', ''],
|
|
['non-virtual thunk to ', ' [non-virtual thunk]'],
|
|
['typeinfo for ', ' [typeinfo]'],
|
|
['typeinfo name for ', ' [typeinfo name]'],
|
|
['virtual thunk to ', ' [virtual thunk]'],
|
|
['void ', ''],
|
|
['vtable for ', ' [vtable]'],
|
|
['VTT for ', ' [VTT]'],
|
|
]
|
|
for prefix, replacement in prefixes:
|
|
if name.startswith(prefix):
|
|
name = name[len(prefix):] + replacement
|
|
# Simplify parenthesis parsing.
|
|
replacements = [
|
|
['(anonymous namespace)', '[anonymous namespace]'],
|
|
]
|
|
for value, replacement in replacements:
|
|
name = name.replace(value, replacement)
|
|
|
|
def parse_one(val):
|
|
"""Returns (leftmost-part, remaining)."""
|
|
if (val.startswith('operator') and
|
|
not (val[8].isalnum() or val[8] == '_')):
|
|
# Operator overload function, terminate.
|
|
return (val, '')
|
|
co = val.find('::')
|
|
lt = val.find('<')
|
|
pa = val.find('(')
|
|
co = len(val) if co == -1 else co
|
|
lt = len(val) if lt == -1 else lt
|
|
pa = len(val) if pa == -1 else pa
|
|
if co < lt and co < pa:
|
|
# Namespace or type name.
|
|
return (val[:co], val[co+2:])
|
|
if lt < pa:
|
|
# Template. Make sure we capture nested templates too.
|
|
open_tmpl = 1
|
|
gt = lt
|
|
while val[gt] != '>' or open_tmpl != 0:
|
|
gt = gt + 1
|
|
if val[gt] == '<':
|
|
open_tmpl = open_tmpl + 1
|
|
if val[gt] == '>':
|
|
open_tmpl = open_tmpl - 1
|
|
ret = val[gt+1:]
|
|
if ret.startswith('::'):
|
|
ret = ret[2:]
|
|
if ret.startswith('('):
|
|
# Template function, terminate.
|
|
return (val, '')
|
|
return (val[:gt+1], ret)
|
|
# Terminate with any function name, identifier, or unmangled name.
|
|
return (val, '')
|
|
|
|
parts = []
|
|
while len(name) > 0:
|
|
(part, name) = parse_one(name)
|
|
assert len(part) > 0
|
|
parts.append(part)
|
|
return parts
|
|
|
|
|
|
def treeify_syms(symbols, strip_prefix=None, cppfilt=None):
|
|
dirs = {}
|
|
for sym, type, size, path in symbols:
|
|
if path:
|
|
path = os.path.normpath(path)
|
|
if strip_prefix and path.startswith(strip_prefix):
|
|
path = path[len(strip_prefix):]
|
|
elif path.startswith('/'):
|
|
path = path[1:]
|
|
path = ['[path]'] + path.split('/')
|
|
|
|
parts = parse_cpp_name(sym, cppfilt)
|
|
if len(parts) == 1:
|
|
if path:
|
|
# No namespaces, group with path.
|
|
parts = path + parts
|
|
else:
|
|
new_prefix = ['[ungrouped]']
|
|
regroups = [
|
|
['.L.str', '[str]'],
|
|
['.L__PRETTY_FUNCTION__.', '[__PRETTY_FUNCTION__]'],
|
|
['.L__func__.', '[__func__]'],
|
|
['.Lswitch.table', '[switch table]'],
|
|
]
|
|
for prefix, group in regroups:
|
|
if parts[0].startswith(prefix):
|
|
parts[0] = parts[0][len(prefix):]
|
|
parts[0] = demangle(parts[0], cppfilt)
|
|
new_prefix += [group]
|
|
break
|
|
parts = new_prefix + parts
|
|
|
|
key = parts.pop()
|
|
tree = dirs
|
|
try:
|
|
depth = 0
|
|
for part in parts:
|
|
depth = depth + 1
|
|
assert part != '', path
|
|
if part not in tree:
|
|
tree[part] = {'$bloat_symbols':{}}
|
|
if type not in tree[part]['$bloat_symbols']:
|
|
tree[part]['$bloat_symbols'][type] = 0
|
|
tree[part]['$bloat_symbols'][type] += 1
|
|
tree = tree[part]
|
|
old_size, old_symbols = tree.get(key, (0, {}))
|
|
if type not in old_symbols:
|
|
old_symbols[type] = 0
|
|
old_symbols[type] += 1
|
|
tree[key] = (old_size + size, old_symbols)
|
|
except:
|
|
print >>sys.stderr, 'sym `%s`\tparts `%s`\tkey `%s`' % (sym, parts, key)
|
|
raise
|
|
return dirs
|
|
|
|
|
|
def jsonify_tree(tree, name):
|
|
children = []
|
|
total = 0
|
|
files = 0
|
|
|
|
for key, val in tree.iteritems():
|
|
if key == '$bloat_symbols':
|
|
continue
|
|
if isinstance(val, dict):
|
|
subtree = jsonify_tree(val, key)
|
|
total += subtree['data']['$area']
|
|
children.append(subtree)
|
|
else:
|
|
(size, symbols) = val
|
|
total += size
|
|
assert len(symbols) == 1, symbols.values()[0] == 1
|
|
symbol = symbol_type_to_human(symbols.keys()[0])
|
|
children.append({
|
|
'name': key + ' ' + format_bytes(size),
|
|
'data': {
|
|
'$area': size,
|
|
'$symbol': symbol,
|
|
}
|
|
})
|
|
|
|
children.sort(key=lambda child: -child['data']['$area'])
|
|
dominant_symbol = ''
|
|
if '$bloat_symbols' in tree:
|
|
dominant_symbol = symbol_type_to_human(
|
|
max(tree['$bloat_symbols'].iteritems(),
|
|
key=operator.itemgetter(1))[0])
|
|
return {
|
|
'name': name + ' ' + format_bytes(total),
|
|
'data': {
|
|
'$area': total,
|
|
'$dominant_symbol': dominant_symbol,
|
|
},
|
|
'children': children,
|
|
}
|
|
|
|
|
|
def dump_nm(nmfile, strip_prefix, cppfilt):
|
|
dirs = treeify_syms(parse_nm(nmfile), strip_prefix, cppfilt)
|
|
print ('var kTree = ' +
|
|
json.dumps(jsonify_tree(dirs, '[everything]'), indent=2))
|
|
|
|
|
|
def parse_objdump(input):
|
|
"""Parse objdump -h output."""
|
|
sec_re = re.compile('^\d+ (\S+) +([0-9a-z]+)')
|
|
sections = []
|
|
debug_sections = []
|
|
|
|
for line in input:
|
|
line = line.strip()
|
|
match = sec_re.match(line)
|
|
if match:
|
|
name, size = match.groups()
|
|
if name.startswith('.'):
|
|
name = name[1:]
|
|
if name.startswith('debug_'):
|
|
name = name[len('debug_'):]
|
|
debug_sections.append((name, int(size, 16)))
|
|
else:
|
|
sections.append((name, int(size, 16)))
|
|
continue
|
|
return sections, debug_sections
|
|
|
|
|
|
def jsonify_sections(name, sections):
|
|
children = []
|
|
total = 0
|
|
for section, size in sections:
|
|
children.append({
|
|
'name': section + ' ' + format_bytes(size),
|
|
'data': { '$area': size }
|
|
})
|
|
total += size
|
|
|
|
children.sort(key=lambda child: -child['data']['$area'])
|
|
|
|
return {
|
|
'name': name + ' ' + format_bytes(total),
|
|
'data': { '$area': total },
|
|
'children': children
|
|
}
|
|
|
|
|
|
def dump_sections(objdump):
|
|
sections, debug_sections = parse_objdump(objdump)
|
|
sections = jsonify_sections('sections', sections)
|
|
debug_sections = jsonify_sections('debug', debug_sections)
|
|
size = sections['data']['$area'] + debug_sections['data']['$area']
|
|
print 'var kTree = ' + json.dumps({
|
|
'name': 'top ' + format_bytes(size),
|
|
'data': { '$area': size },
|
|
'children': [ debug_sections, sections ]})
|
|
|
|
|
|
usage="""%prog [options] MODE
|
|
|
|
Modes are:
|
|
syms: output symbols json suitable for a treemap
|
|
dump: print symbols sorted by size (pipe to head for best output)
|
|
sections: output binary sections json suitable for a treemap
|
|
|
|
nm output passed to --nm-output should from running a command
|
|
like the following (note, can take a long time -- 30 minutes):
|
|
nm -C -S -l /path/to/binary > nm.out
|
|
|
|
objdump output passed to --objdump-output should be from a command
|
|
like:
|
|
objdump -h /path/to/binary > objdump.out"""
|
|
parser = optparse.OptionParser(usage=usage)
|
|
parser.add_option('--nm-output', action='store', dest='nmpath',
|
|
metavar='PATH', default='nm.out',
|
|
help='path to nm output [default=nm.out]')
|
|
parser.add_option('--objdump-output', action='store', dest='objdumppath',
|
|
metavar='PATH', default='objdump.out',
|
|
help='path to objdump output [default=objdump.out]')
|
|
parser.add_option('--strip-prefix', metavar='PATH', action='store',
|
|
help='strip PATH prefix from paths; e.g. /path/to/src/root')
|
|
parser.add_option('--filter', action='store',
|
|
help='include only symbols/files matching FILTER')
|
|
parser.add_option('--c++filt', action='store', metavar='PATH', dest='cppfilt',
|
|
default='c++filt', help="Path to c++filt, used to demangle "
|
|
"symbols that weren't handled by nm. Set to an invalid path "
|
|
"to disable.")
|
|
opts, args = parser.parse_args()
|
|
|
|
if len(args) != 1:
|
|
parser.print_usage()
|
|
sys.exit(1)
|
|
|
|
mode = args[0]
|
|
if mode == 'syms':
|
|
nmfile = open(opts.nmpath, 'r')
|
|
try:
|
|
res = subprocess.check_output([opts.cppfilt, 'main'])
|
|
if res.strip() != 'main':
|
|
print >>sys.stderr, ("%s failed demangling, "
|
|
"output won't be demangled." % opt.cppfilt)
|
|
opts.cppfilt = None
|
|
except:
|
|
print >>sys.stderr, ("Could not find c++filt at %s, "
|
|
"output won't be demangled." % opt.cppfilt)
|
|
opts.cppfilt = None
|
|
dump_nm(nmfile, strip_prefix=opts.strip_prefix, cppfilt=opts.cppfilt)
|
|
elif mode == 'sections':
|
|
objdumpfile = open(opts.objdumppath, 'r')
|
|
dump_sections(objdumpfile)
|
|
elif mode == 'dump':
|
|
nmfile = open(opts.nmpath, 'r')
|
|
syms = list(parse_nm(nmfile))
|
|
# a list of (sym, type, size, path); sort by size.
|
|
syms.sort(key=lambda x: -x[2])
|
|
total = 0
|
|
for sym, type, size, path in syms:
|
|
if type in ('b', 'w'):
|
|
continue # skip bss and weak symbols
|
|
if path is None:
|
|
path = ''
|
|
if opts.filter and not (opts.filter in sym or opts.filter in path):
|
|
continue
|
|
print '%6s %s (%s) %s' % (format_bytes(size), sym,
|
|
symbol_type_to_human(type), path)
|
|
total += size
|
|
print '%6s %s' % (format_bytes(total), 'total'),
|
|
else:
|
|
print 'unknown mode'
|
|
parser.print_usage()
|