Handle shared memory symbols better in the binarysize tool.

tools/binary_size/run_binary_size_analysis.py

 #!/usr/bin/env python
 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Generate a spatial analysis against an arbitrary library.
 
 To use, build the 'binary_size_tool' target. Then run this tool, passing
 in the location of the library to be analyzed along with any other options
 you desire.
@@ skipping 151 matching lines @@
   return 2  # Depth of the added subtree.
 
 
 def MakeCompactTree(symbols, symbol_path_origin_dir):
   result = {NODE_NAME_KEY: '/',
             NODE_CHILDREN_KEY: {},
             NODE_TYPE_KEY: 'p',
             NODE_MAX_DEPTH_KEY: 0}
   seen_symbol_with_path = False
   cwd = os.path.abspath(os.getcwd())
-  for symbol_name, symbol_type, symbol_size, file_path in symbols:
+  for symbol_name, symbol_type, symbol_size, file_path, _address in symbols:
 
     if 'vtable for ' in symbol_name:
       symbol_type = '@'  # hack to categorize these separately
     # Take path like '/foo/bar/baz', convert to ['foo', 'bar', 'baz']
     if file_path and file_path != "??":
       file_path = os.path.abspath(os.path.join(symbol_path_origin_dir,
                                                file_path))
       # Let the output structure be relative to $CWD if inside $CWD,
       # otherwise relative to the disk root. This is to avoid
       # unnecessary click-through levels in the output.
@@ skipping 55 matching lines @@
                  directory or file names) and whose values are other nodes;
        size:     the total size, in bytes, of all the leaf nodes that are
                  contained within the children dict (recursively expanded)
 
   The result object is itself a dictionary that represents the common ancestor
   of all child nodes, e.g. a path to which all other nodes beneath it are
   relative. The 'size' attribute of this dict yields the sum of the size of all
   leaf nodes within the data structure.
   """
   dirs = {'children': {}, 'size': 0}
-  for sym, symbol_type, size, path in symbols:
+  for sym, symbol_type, size, path, _address in symbols:
     dirs['size'] += size
     if path:
       path = os.path.normpath(path)
       if path.startswith('/'):
         path = path[1:]
 
     parts = None
     if path:
       parts = path.split('/')
 
@@ skipping 116 matching lines @@
 
 
 # TODO(andrewhayden): Only used for legacy reports. Delete.
 def DumpLargestSymbols(symbols, outfile, n):
   # a list of (sym, symbol_type, size, path); sort by size.
   symbols = sorted(symbols, key=lambda x: -x[2])
   dumped = 0
   out = open(outfile, 'w')
   try:
     out.write('var largestSymbols = [\n')
-    for sym, symbol_type, size, path in symbols:
+    for sym, symbol_type, size, path, _address in symbols:
       if symbol_type in ('b', 'w'):
         continue  # skip bss and weak symbols
       if path is None:
         path = ''
       entry = {'size': FormatBytes(size),
                'symbol': sym,
                'type': SymbolTypeToHuman(symbol_type),
                'location': path }
       out.write(json.dumps(entry))
       out.write(',\n')
       dumped += 1
       if dumped >= n:
         return
   finally:
     out.write('];\n')
     out.flush()
     out.close()
 
 
 def MakeSourceMap(symbols):
   sources = {}
-  for _sym, _symbol_type, size, path in symbols:
+  for _sym, _symbol_type, size, path, _address in symbols:
     key = None
     if path:
       key = os.path.normpath(path)
     else:
       key = '[no path]'
     if key not in sources:
       sources[key] = {'path': path, 'symbol_count': 0, 'size': 0}
     record = sources[key]
     record['size'] += size
     record['symbol_count'] += 1
@@ skipping 19 matching lines @@
         return
   finally:
     out.write('];\n')
     out.flush()
     out.close()
 
 
 # TODO(andrewhayden): Only used for legacy reports. Delete.
 def DumpLargestVTables(symbols, outfile, n):
   vtables = []
-  for symbol, _type, size, path in symbols:
+  for symbol, _type, size, path, _address in symbols:
     if 'vtable for ' in symbol:
       vtables.append({'symbol': symbol, 'path': path, 'size': size})
   vtables = sorted(vtables, key=lambda x: -x['size'])
   dumped = 0
   out = open(outfile, 'w')
   try:
     out.write('var largestVTables = [\n')
     for record in vtables:
       entry = {'size': FormatBytes(record['size']),
                'symbol': record['symbol'],
@@ skipping 465 matching lines @@
     shutil.copy(os.path.join(d3_src, 'LICENSE'), d3_out)
     shutil.copy(os.path.join(d3_src, 'd3.js'), d3_out)
     shutil.copy(os.path.join(template_src, 'index.html'), opts.destdir)
     shutil.copy(os.path.join(template_src, 'D3SymbolTreeMap.js'), opts.destdir)
 
   print 'Report saved to ' + opts.destdir + '/index.html'
 
 
 if __name__ == '__main__':
   sys.exit(main())