1 #!/usr/bin/env python 2 # Copyright 2014 The Chromium Authors. All rights reserved. 3 # Use of this source code is governed by a BSD-style license that can be 4 # found in the LICENSE file. 5 6 """Describe the size difference of two binaries. 7 8 Generates a description of the size difference of two binaries based 9 on the difference of the size of various symbols. 10 11 This tool needs "nm" dumps of each binary with full symbol 12 information. You can obtain the necessary dumps by running the 13 run_binary_size_analysis.py script upon each binary, with the 14 "--nm-out" parameter set to the location in which you want to save the 15 dumps. Example: 16 17 # obtain symbol data from first binary in /tmp/nm1.dump 18 cd $CHECKOUT1_SRC 19 ninja -C out/Release binary_size_tool 20 tools/binary_size/run_binary_size_analysis \ 21 --library <path_to_library> 22 --destdir /tmp/throwaway 23 --nm-out /tmp/nm1.dump 24 25 # obtain symbol data from second binary in /tmp/nm2.dump 26 cd $CHECKOUT2_SRC 27 ninja -C out/Release binary_size_tool 28 tools/binary_size/run_binary_size_analysis \ 29 --library <path_to_library> 30 --destdir /tmp/throwaway 31 --nm-out /tmp/nm2.dump 32 33 # cleanup useless files 34 rm -r /tmp/throwaway 35 36 # run this tool 37 explain_binary_size_delta.py --nm1 /tmp/nm1.dump --nm2 /tmp/nm2.dump 38 """ 39 40 import collections 41 import operator 42 import optparse 43 import os 44 import sys 45 46 import binary_size_utils 47 48 49 def Compare(symbols1, symbols2): 50 """Executes a comparison of the symbols in symbols1 and symbols2. 51 52 Returns: 53 tuple of lists: (added_symbols, removed_symbols, changed_symbols, others) 54 """ 55 added = [] # tuples 56 removed = [] # tuples 57 changed = [] # tuples 58 unchanged = [] # tuples 59 60 cache1 = {} 61 cache2 = {} 62 # Make a map of (file, symbol_type) : (symbol_name, symbol_size) 63 for cache, symbols in ((cache1, symbols1), (cache2, symbols2)): 64 for symbol_name, symbol_type, symbol_size, file_path in symbols: 65 if 'vtable for ' in symbol_name: 66 symbol_type = '@' # hack to categorize these separately 67 if file_path: 68 file_path = os.path.normpath(file_path) 69 else: 70 file_path = '(No Path)' 71 key = (file_path, symbol_type) 72 bucket = cache.setdefault(key, {}) 73 size_list = bucket.setdefault(symbol_name, []) 74 size_list.append(symbol_size) 75 76 # Now diff them. We iterate over the elements in cache1. For each symbol 77 # that we find in cache2, we record whether it was deleted, changed, or 78 # unchanged. We then remove it from cache2; all the symbols that remain 79 # in cache2 at the end of the iteration over cache1 are the 'new' symbols. 80 for key, bucket1 in cache1.items(): 81 bucket2 = cache2.get(key) 82 if not bucket2: 83 # A file was removed. Everything in bucket1 is dead. 84 for symbol_name, symbol_size_list in bucket1.items(): 85 for symbol_size in symbol_size_list: 86 removed.append((key[0], key[1], symbol_name, symbol_size, None)) 87 else: 88 # File still exists, look for changes within. 89 for symbol_name, symbol_size_list in bucket1.items(): 90 size_list2 = bucket2.get(symbol_name) 91 if size_list2 is None: 92 # Symbol no longer exists in bucket2. 93 for symbol_size in symbol_size_list: 94 removed.append((key[0], key[1], symbol_name, symbol_size, None)) 95 else: 96 del bucket2[symbol_name] # Symbol is not new, delete from cache2. 97 if len(symbol_size_list) == 1 and len(size_list2) == 1: 98 symbol_size = symbol_size_list[0] 99 size2 = size_list2[0] 100 if symbol_size != size2: 101 # Symbol has change size in bucket. 102 changed.append((key[0], key[1], symbol_name, symbol_size, size2)) 103 else: 104 # Symbol is unchanged. 105 unchanged.append((key[0], key[1], symbol_name, symbol_size, 106 size2)) 107 else: 108 # Complex comparison for when a symbol exists multiple times 109 # in the same file (where file can be "unknown file"). 110 symbol_size_counter = collections.Counter(symbol_size_list) 111 delta_counter = collections.Counter(symbol_size_list) 112 delta_counter.subtract(size_list2) 113 for symbol_size in sorted(delta_counter.keys()): 114 delta = delta_counter[symbol_size] 115 unchanged_count = symbol_size_counter[symbol_size] 116 if delta > 0: 117 unchanged_count -= delta 118 for _ in range(unchanged_count): 119 unchanged.append((key[0], key[1], symbol_name, symbol_size, 120 symbol_size)) 121 if delta > 0: # Used to be more of these than there is now. 122 for _ in range(delta): 123 removed.append((key[0], key[1], symbol_name, symbol_size, 124 None)) 125 elif delta < 0: # More of this (symbol,size) now. 126 for _ in range(-delta): 127 added.append((key[0], key[1], symbol_name, None, symbol_size)) 128 129 if len(bucket2) == 0: 130 del cache1[key] # Entire bucket is empty, delete from cache2 131 132 # We have now analyzed all symbols that are in cache1 and removed all of 133 # the encountered symbols from cache2. What's left in cache2 is the new 134 # symbols. 135 for key, bucket2 in cache2.iteritems(): 136 for symbol_name, symbol_size_list in bucket2.items(): 137 for symbol_size in symbol_size_list: 138 added.append((key[0], key[1], symbol_name, None, symbol_size)) 139 return (added, removed, changed, unchanged) 140 141 def DeltaStr(number): 142 """Returns the number as a string with a '+' prefix if it's > 0 and 143 a '-' prefix if it's < 0.""" 144 result = str(number) 145 if number > 0: 146 result = '+' + result 147 return result 148 149 150 class CrunchStatsData(object): 151 """Stores a summary of data of a certain kind.""" 152 def __init__(self, symbols): 153 self.symbols = symbols 154 self.sources = set() 155 self.before_size = 0 156 self.after_size = 0 157 self.symbols_by_path = {} 158 159 160 def CrunchStats(added, removed, changed, unchanged, showsources, showsymbols): 161 """Outputs to stdout a summary of changes based on the symbol lists.""" 162 # Split changed into grown and shrunk because that is easier to 163 # discuss. 164 grown = [] 165 shrunk = [] 166 for item in changed: 167 file_path, symbol_type, symbol_name, size1, size2 = item 168 if size1 < size2: 169 grown.append(item) 170 else: 171 shrunk.append(item) 172 173 new_symbols = CrunchStatsData(added) 174 removed_symbols = CrunchStatsData(removed) 175 grown_symbols = CrunchStatsData(grown) 176 shrunk_symbols = CrunchStatsData(shrunk) 177 sections = [new_symbols, removed_symbols, grown_symbols, shrunk_symbols] 178 for section in sections: 179 for file_path, symbol_type, symbol_name, size1, size2 in section.symbols: 180 section.sources.add(file_path) 181 if size1 is not None: 182 section.before_size += size1 183 if size2 is not None: 184 section.after_size += size2 185 bucket = section.symbols_by_path.setdefault(file_path, []) 186 bucket.append((symbol_name, symbol_type, size1, size2)) 187 188 total_change = sum(s.after_size - s.before_size for s in sections) 189 summary = 'Total change: %s bytes' % DeltaStr(total_change) 190 print(summary) 191 print('=' * len(summary)) 192 for section in sections: 193 if not section.symbols: 194 continue 195 if section.before_size == 0: 196 description = ('added, totalling %s bytes' % DeltaStr(section.after_size)) 197 elif section.after_size == 0: 198 description = ('removed, totalling %s bytes' % 199 DeltaStr(-section.before_size)) 200 else: 201 if section.after_size > section.before_size: 202 type_str = 'grown' 203 else: 204 type_str = 'shrunk' 205 description = ('%s, for a net change of %s bytes ' 206 '(%d bytes before, %d bytes after)' % 207 (type_str, DeltaStr(section.after_size - section.before_size), 208 section.before_size, section.after_size)) 209 print(' %d %s across %d sources' % 210 (len(section.symbols), description, len(section.sources))) 211 212 maybe_unchanged_sources = set() 213 unchanged_symbols_size = 0 214 for file_path, symbol_type, symbol_name, size1, size2 in unchanged: 215 maybe_unchanged_sources.add(file_path) 216 unchanged_symbols_size += size1 # == size2 217 print(' %d unchanged, totalling %d bytes' % 218 (len(unchanged), unchanged_symbols_size)) 219 220 # High level analysis, always output. 221 unchanged_sources = maybe_unchanged_sources 222 for section in sections: 223 unchanged_sources = unchanged_sources - section.sources 224 new_sources = (new_symbols.sources - 225 maybe_unchanged_sources - 226 removed_symbols.sources) 227 removed_sources = (removed_symbols.sources - 228 maybe_unchanged_sources - 229 new_symbols.sources) 230 partially_changed_sources = (grown_symbols.sources | 231 shrunk_symbols.sources | new_symbols.sources | 232 removed_symbols.sources) - removed_sources - new_sources 233 allFiles = set() 234 for section in sections: 235 allFiles = allFiles | section.sources 236 allFiles = allFiles | maybe_unchanged_sources 237 print 'Source stats:' 238 print(' %d sources encountered.' % len(allFiles)) 239 print(' %d completely new.' % len(new_sources)) 240 print(' %d removed completely.' % len(removed_sources)) 241 print(' %d partially changed.' % len(partially_changed_sources)) 242 print(' %d completely unchanged.' % len(unchanged_sources)) 243 remainder = (allFiles - new_sources - removed_sources - 244 partially_changed_sources - unchanged_sources) 245 assert len(remainder) == 0 246 247 if not showsources: 248 return # Per-source analysis, only if requested 249 print 'Per-source Analysis:' 250 delta_by_path = {} 251 for section in sections: 252 for path in section.symbols_by_path: 253 entry = delta_by_path.get(path) 254 if not entry: 255 entry = {'plus': 0, 'minus': 0} 256 delta_by_path[path] = entry 257 for symbol_name, symbol_type, size1, size2 in \ 258 section.symbols_by_path[path]: 259 if size1 is None: 260 delta = size2 261 elif size2 is None: 262 delta = -size1 263 else: 264 delta = size2 - size1 265 266 if delta > 0: 267 entry['plus'] += delta 268 else: 269 entry['minus'] += (-1 * delta) 270 271 def delta_sort_key(item): 272 _path, size_data = item 273 growth = size_data['plus'] - size_data['minus'] 274 return growth 275 276 for path, size_data in sorted(delta_by_path.iteritems(), key=delta_sort_key, 277 reverse=True): 278 gain = size_data['plus'] 279 loss = size_data['minus'] 280 delta = size_data['plus'] - size_data['minus'] 281 header = ' %s - Source: %s - (gained %d, lost %d)' % (DeltaStr(delta), 282 path, gain, loss) 283 divider = '-' * len(header) 284 print '' 285 print divider 286 print header 287 print divider 288 if showsymbols: 289 if path in new_symbols.symbols_by_path: 290 print ' New symbols:' 291 for symbol_name, symbol_type, size1, size2 in \ 292 sorted(new_symbols.symbols_by_path[path], 293 key=operator.itemgetter(3), 294 reverse=True): 295 print (' %8s: %s type=%s, size=%d bytes' % 296 (DeltaStr(size2), symbol_name, symbol_type, size2)) 297 if path in removed_symbols.symbols_by_path: 298 print ' Removed symbols:' 299 for symbol_name, symbol_type, size1, size2 in \ 300 sorted(removed_symbols.symbols_by_path[path], 301 key=operator.itemgetter(2)): 302 print (' %8s: %s type=%s, size=%d bytes' % 303 (DeltaStr(-size1), symbol_name, symbol_type, size1)) 304 for (changed_symbols_by_path, type_str) in [ 305 (grown_symbols.symbols_by_path, "Grown"), 306 (shrunk_symbols.symbols_by_path, "Shrunk")]: 307 if path in changed_symbols_by_path: 308 print ' %s symbols:' % type_str 309 def changed_symbol_sortkey(item): 310 symbol_name, _symbol_type, size1, size2 = item 311 return (size1 - size2, symbol_name) 312 for symbol_name, symbol_type, size1, size2 in \ 313 sorted(changed_symbols_by_path[path], key=changed_symbol_sortkey): 314 print (' %8s: %s type=%s, (was %d bytes, now %d bytes)' 315 % (DeltaStr(size2 - size1), symbol_name, 316 symbol_type, size1, size2)) 317 318 319 def main(): 320 usage = """%prog [options] 321 322 Analyzes the symbolic differences between two binary files 323 (typically, not necessarily, two different builds of the same 324 library) and produces a detailed description of symbols that have 325 been added, removed, or whose size has changed. 326 327 Example: 328 explain_binary_size_delta.py --nm1 /tmp/nm1.dump --nm2 /tmp/nm2.dump 329 330 Options are available via '--help'. 331 """ 332 parser = optparse.OptionParser(usage=usage) 333 parser.add_option('--nm1', metavar='PATH', 334 help='the nm dump of the first library') 335 parser.add_option('--nm2', metavar='PATH', 336 help='the nm dump of the second library') 337 parser.add_option('--showsources', action='store_true', default=False, 338 help='show per-source statistics') 339 parser.add_option('--showsymbols', action='store_true', default=False, 340 help='show all symbol information; implies --showfiles') 341 parser.add_option('--verbose', action='store_true', default=False, 342 help='output internal debugging stuff') 343 opts, _args = parser.parse_args() 344 345 if not opts.nm1: 346 parser.error('--nm1 is required') 347 if not opts.nm2: 348 parser.error('--nm2 is required') 349 symbols = [] 350 for path in [opts.nm1, opts.nm2]: 351 with file(path, 'r') as nm_input: 352 if opts.verbose: 353 print 'parsing ' + path + '...' 354 symbols.append(list(binary_size_utils.ParseNm(nm_input))) 355 (added, removed, changed, unchanged) = Compare(symbols[0], symbols[1]) 356 CrunchStats(added, removed, changed, unchanged, 357 opts.showsources | opts.showsymbols, opts.showsymbols) 358 359 if __name__ == '__main__': 360 sys.exit(main()) 361
