analyze_code_size.py

#!/usr/bin/env python

importargparse
importre
importsubprocess
importsys


useCSV=False


defmain(arguments):
parser=argparse.ArgumentParser(
description='Analyze the code size in a binary')
parser.add_argument('-arch', type=str,
help='the arch to look at', default='arm64')
parser.add_argument('-categorize', action='store_true',
help='categorize symbols', dest='build_categories',
default=False)
parser.add_argument('-list-category', type=str,
help='list symbols in category')
parser.add_argument('-csv', dest='use_csv', action='store_true',
help='print results as csv')
parser.add_argument('-uncategorized', action='store_true',
help='show all uncategorized symbols',
dest='show_uncategorized',
default=False)
parser.add_argument('bin', help='the binary')
parser.set_defaults(use_csv=False)

args=parser.parse_args(arguments)
ifargs.use_csv:
globaluseCSV
useCSV=True
print("Using csv")

segments=parse_segments(args.bin, args.arch)

ifargs.build_categories:
categorize(segments)
elifargs.show_uncategorized:
uncategorized(segments)
elifargs.list_category:
list_category(segments, args.list_category)
else:
show_all(segments)


classSymbol(object):
def__init__(self, name, mangled_name, size):
self.name=name
self.mangled_name=mangled_name
self.count=1
self.size=int(size)


defget_symbol_size(sym):
returnsym.size


classSegment(object):
def__init__(self, name):
self.name=name
self.sections= []


classSection(object):
def__init__(self, name, size):
self.name=name
self.size=size
self.symbols= []


classCategory(object):
def__init__(self, name):
self.name=name
self.size=0
self.symbols= []

defadd(self, symbol):
self.symbols.append(symbol)
self.size+=symbol.size


classCategories(object):
def__init__(self):
self.category_matching= [
 ['Objective-C function', re.compile(r'.*[+-]\[')],
 ['C++', re.compile(r'_+swift')],
 ['Generic specialization of stdlib', 
re.compile(r'.*generic specialization.* of Swift\.')],
 ['Generic specialization', 
re.compile(r'.*generic specialization')],
 ['Merged function', re.compile(r'merged ')],
 ['Key path', re.compile(r'key path')],
 ['Function signature specialization',
re.compile(r'function signature specialization')],
 ['Reabstraction thunk helper',
re.compile(r'reabstraction thunk helper')],
 ['vtable thunk', re.compile(r'vtable thunk for')],
 ['@objc thunk', re.compile(r'@objc')],
 ['@nonobjc thunk', re.compile(r'@nonobjc')],
 ['Value witness', re.compile(r'.*value witness for')],
 ['Block copy helper', re.compile(r'_block_copy_helper')],
 ['Block destroy helper', re.compile(r'_block_destroy_helper')],
 ['Block literal global', re.compile(r'___block_literal_global')],
 ['Destroy helper block', re.compile(r'___destroy_helper_block')],
 ['Copy helper block', re.compile(r'___copy_helper_block')],
 ['Object destroy', re.compile(r'_objectdestroy')],
 ['Partial apply forwarder',
re.compile(r'partial apply forwarder')],
 ['Closure function', re.compile(r'closure #')],
 ['ObjC metadata update function',
re.compile(r'ObjC metadata update function for')],
 ['Variable initialization expression',
re.compile(r'variable initialization expression of')],
 ['Global initialization', re.compile(r'_globalinit_')],
 ['Unnamed', re.compile(r'___unnamed_')],
 ['Dyld stubs', re.compile(r'DYLD-STUB\$')],
 ['Witness table accessor',
re.compile(r'.*witness table accessor for')],
 ['Protocol witness', re.compile(r'protocol witness for')],
 ['Outlined variable', re.compile(r'outlined variable #')],
 ['Outlined value function (copy,destroy,release...)',
re.compile(r'outlined')],
 ['_symbolic', re.compile(r'_symbolic')],
 ['_associated conformance',
re.compile(r'_associated conformance')],
 ['Direct field offset', re.compile(r'direct field offset for')],
 ['Value witness tables', re.compile(r'.*value witness table')],
 ['Protocol witness table',
re.compile(r'.*protocol witness table for')],
 ['Protocol conformance descriptor',
re.compile(r'protocol conformance descriptor for')],
 ['Lazy protocol witness table cache var',
re.compile(
r'lazy protocol witness table cache variable for type')],
 ['Nominal type descriptor',
re.compile(r'nominal type descriptor for')],
 ['ObjC class', re.compile(r'_OBJC_CLASS_')],
 ['ObjC metaclass', re.compile(r'_OBJC_METACLASS')],
 ['ObjC ivar', re.compile(r'_OBJC_IVAR')],
 ['Metaclass', re.compile(r'metaclass for')],
 ['Block descriptor', re.compile(r'_+block_descriptor')],
 ['Extension descriptor', re.compile(r'extension descriptor')],
 ['Module descriptor', re.compile(r'module descriptor')],
 ['Associated type descriptor',
re.compile(r'associated type descriptor for')],
 ['Associated conformance descriptor',
re.compile(r'associated conformance descriptor for')],
 ['Protocol descriptor', re.compile(r'protocol descriptor for')],
 ['Base conformance descriptor',
re.compile(r'base conformance descriptor for')],
 ['Protocol requirements base descriptor',
re.compile(r'protocol requirements base descriptor for')],
 ['Property descriptor', re.compile(r'property descriptor for')],
 ['Method descriptor', re.compile(r'method descriptor for')],
 ['Anonymous descriptor', re.compile(r'anonymous descriptor')],
 ['Type metadata accessor',
re.compile(r'.*type metadata accessor')],
 ['Type metadata', re.compile(r'.*type metadata')],
 ['Reflection metadata descriptor',
re.compile(r'reflection metadata .* descriptor')],
 ]

self.category_mangled_matching= [
 ['Swift variable storage', re.compile(r'^_\$s.*[v][p][Z]?$')],
 ['Swift constructor', re.compile(r'^_\$s.*[f][cC]$')],
 ['Swift initializer', re.compile(r'^_\$s.*[f][ie]$')],
 ['Swift destructor/destroyer', re.compile(r'^_\$s.*[f][dDE]$')],
 ['Swift getter', re.compile(r'^_\$s.*[iv][gG]$')],
 ['Swift setter', re.compile(r'^_\$s.*[iv][swW]$')],
 ['Swift materializeForSet', re.compile(r'^_\$s.*[iv][m]$')],
 ['Swift modify', re.compile(r'^_\$s.*[iv][M]$')],
 ['Swift read', re.compile(r'^_\$s.*[iv][r]$')],
 ['Swift addressor', re.compile(r'^_\$s.*[iv][al][uOop]$')],
 ['Swift function', re.compile(r'^_\$s.*F$')],
 ['Swift unknown', re.compile(r'^_\$s.*')],
 ]
self.categories= {}

defcategorize_by_name(self, symbol):
forcinself.category_matching:
ifc[1].match(symbol.name):
returnc[0]
returnNone

defcategorize_by_mangled_name(self, symbol):
forcinself.category_mangled_matching:
ifc[1].match(symbol.mangled_name):
returnc[0]
returnNone

defadd_symbol(self, category_name, symbol):
existing_category=self.categories.get(category_name)
ifexisting_category:
existing_category.add(symbol)
else:
new_category=Category(category_name)
new_category.add(symbol)
self.categories[category_name] =new_category

defadd(self, symbol):
category_name=self.categorize_by_name(symbol)
ifcategory_name:
self.add_symbol(category_name, symbol)
return
category_name=self.categorize_by_mangled_name(symbol)
ifcategory_name:
self.add_symbol(category_name, symbol)
else:
self.add_symbol('Unknown', symbol)

defcategorize(self, symbols):
forsyminsymbols:
self.add(sym)

defprint_summary(self, section_size):
names= [c[0] forcinself.category_matching]
names.extend([c[0] forcinself.category_mangled_matching])
names.append('Unknown')
total_size=0
sorted_categories= []
fornameinnames:
category=self.categories.get(name)
size=0
ifcategory:
size=category.size
total_size+=size
ifsize>0:
sorted_categories.append(
 (name, size, (float(size) *100) /section_size))
sorted_categories.sort(key=lambdaentry: entry[1], reverse=True)
forcategoryinsorted_categories:
ifuseCSV:
print("%s;%d;%.2f%%"%
 (category[0], category[1], category[2]))
else:
print("%60s: %8d (%6.2f%%)"%
 (category[0], category[1], category[2]))
print("%60s: %8d (%6.2f%%)"% ('TOTAL', total_size, float(100)))

defuncatorizedSymbols(self):
category=self.categories.get('Unknown')
ifcategory:
returncategory.symbols
returnNone

defprint_uncategorizedSymbols(self):
syms=self.uncatorizedSymbols()
ifsyms:
forsymbolinsyms:
print(symbol.mangled_name+" "+symbol.name+" "+
str(symbol.size))

defprint_category(self, category):
category=self.categories.get(category)
ifcategory:
ifcategory.symbols:
sorted_symbols=sorted(category.symbols, key=get_symbol_size)
forsyminsorted_symbols:
print('%8d %s %s'% (sym.size, sym.name, sym.mangled_name))

defhas_category(self, category):
category=self.categories.get(category)
ifcategory:
ifcategory.symbols:
returnTrue
returnFalse


defparse_segments(path, arch):
mangled=subprocess.check_output(
 ['symbols', '-noSources', '-noDemangling', '-arch', arch, path])
demangle=subprocess.Popen(
 ['xcrun', 'swift-demangle'], stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
demangled=demangle.communicate(mangled)[0]
symbols= {}
segments= []
segment_regex=re.compile(
r"^ 0x[0-9a-f]+ \(\s*0x(?P<size>[0-9a-f]+)\) "
r"(?P<name>.+?) (?P<name2>.+?)$")
object_file_segment_regex=re.compile(
r"^ 0x[0-9a-f]+ \(\s*0x(?P<size>[0-9a-f]+)\) "
r"SEGMENT$")
section_regex=re.compile(
r"^ 0x[0-9a-f]+ \(\s*0x(?P<size>[0-9a-f]+)\) "
r"(?P<name>.+?) (?P<name2>.+?)$")
symbol_regex=re.compile(
r"^ 0x[0-9a-f]+ \(\s*0x(?P<size>[0-9a-f]+)\) "
r"(?P<name>.+?) \[[^\]]+\] $")

mangled_lines=mangled.splitlines()
current_line_number=0

forlineindemangled.splitlines():
mangled_line=mangled_lines[current_line_number]
current_line_number+=1

# Match a segment entry.
segment_match=segment_regex.match(line)
ifsegment_match:
new_segment=Segment(segment_match.group('name'))
segments.append(new_segment)
continue

object_file_segment_match=object_file_segment_regex.match(line)
ifobject_file_segment_match:
new_segment=Segment("SEGMENT")
segments.append(new_segment)
continue

# Match a section entry.
section_match=section_regex.match(line)
ifsection_match:
new_section=Section(section_match.group('name2'),
int(section_match.group('size'), 16))
segments[-1].sections.append(new_section)
continue

# Match a symbol entry.
symbol_match=symbol_regex.match(line)
ifnotsymbol_match:
continue
mangled_symbol_match=symbol_regex.match(mangled_line)
ifnotmangled_symbol_match:
print('mangled and demangled mismatch')
print(mangled_line)
print(line)
assertFalse

symbol=Symbol(symbol_match.group('name'),
mangled_symbol_match.group('name'),
int(symbol_match.group('size'), 16))
existing=symbols.get(symbol.name)
ifexisting:
existing.size+=symbol.size
else:
symbols[symbol.name] =symbol
segments[-1].sections[-1].symbols.append(symbol)

returnsegments


defshow_all(segments):
forsegmentinsegments:
forsectioninsegment.sections:
symbols=section.symbols
forsyminsymbols:
print(str(sym.size) +' '+sym.name+' '+sym.mangled_name)


defcategorize(segments):
forsegmentinsegments:
forsectioninsegment.sections:
print('Section %52s: %8d'%
 (segment.name+';'+section.name, section.size))
symbols=section.symbols
categories=Categories()
categories.categorize(symbols)
categories.print_summary(section.size)
print('')


defuncategorized(segments):
forsegmentinsegments:
forsectioninsegment.sections:
symbols=section.symbols
categories=Categories()
categories.categorize(symbols)
categories.print_uncategorizedSymbols()


deflist_category(segments, category):
forsegmentinsegments:
forsectioninsegment.sections:
symbols=section.symbols
categories=Categories()
categories.categorize(symbols)
ifcategories.has_category(category):
print('Section %22s: %8d'%
 (segment.name+';'+section.name, section.size))
categories.print_category(category)


if__name__=='__main__':
sys.exit(main(sys.argv[1:]))