Add main lib section sizes to resource_sizes.py.

build/android/resource_sizes.py

 #!/usr/bin/python
 # Copyright (c) 2011 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.
 
 """Prints the size of each given file and optionally computes the size of
    libchrome.so without the dependencies added for building with android NDK.
    Also breaks down the contents of the APK to determine the installed size
    and assign size contributions to different classes of file.
 """
 
 import collections
 import json
 import logging
 import operator
 import optparse
 import os
 import re
+import shutil
 import struct
 import sys
 import tempfile
 import zipfile
 import zlib
 
 import devil_chromium
 from devil.android.sdk import build_tools
 from devil.utils import cmd_helper
 from devil.utils import lazy
@@ skipping 63 matching lines @@
     'benchmark_name': 'resource_sizes',
     'benchmark_description': 'APK resource size information.',
     'trace_rerun_options': [],
     'charts': {}
 }
 _DUMP_STATIC_INITIALIZERS_PATH = os.path.join(
     host_paths.DIR_SOURCE_ROOT, 'tools', 'linux', 'dump-static-initializers.py')
 # Pragma exists when enable_resource_whitelist_generation=true.
 _RC_HEADER_RE = re.compile(
     r'^#define (?P<name>\w+) (?:_Pragma\(.*?\) )?(?P<id>\d+)$')
+_READELF_SIZES_METRICS = {
+  'text': ['text'],
+  'data': ['data', 'rodata'],
+  'relocations': ['rel.dyn', 'rel.plt', 'data.rel.ro', 'data.rel.ro.loca'],
+  'unwind': ['ARM.extab', 'ARM.exidx'],
+  'symbols': ['dynsym', 'dynstr', 'dynamic', 'shstrtab', 'got', 'plt'],
+  'other': ['hash', 'init_array', 'fini_array', 'comment',

[agrieve, 2017/02/02 19:45:41]

I don't think the list of sections is guaranteed to not change over time.
I think it would be better to make these "other" sections a comment, and parse
in a way that puts things that don't match anything above in the "other" bucket.

re.finditer() should do the trick.

[estevenson, 2017/02/02 21:34:54]

True! I actually meant to do something like that because I noticed when running
readelf locally that I saw one less section than you posted in
https://bugs.chromium.org/p/chromium/issues/detail?id=681153. Done.

+            'note.gnu.gold-ve', 'ARM.attributes', 'note.gnu.build-i',
+            'gnu.version', 'gnu.version_d', 'gnu.version_r']
+}
+
+
+def _ParseReadElfSectionSize(readelf_stdout, section_name):
+  # Matches: .|section_name| Type Addr Off Size ES Flg Lk Inf Al
+  match = re.search(
+      r'\.%s\s+.*$' % re.escape(section_name), readelf_stdout, re.MULTILINE)
+  return int(match.group(0).split()[4], 16) if match else None
+
+
+def _ExtractMainLibSectionSizesFromApk(apk_path, main_lib_path):
+  tmpdir = tempfile.mkdtemp(suffix='_apk_extract')
+  try:
+    with zipfile.ZipFile(apk_path, 'r') as z:
+      extracted_lib_path = z.extract(main_lib_path, tmpdir)
+      return _ComputeMainLibSectionSizes(extracted_lib_path)
+  finally:
+    shutil.rmtree(tmpdir)
+
+
+def _ComputeMainLibSectionSizes(so_path):
+  stdout = cmd_helper.GetCmdOutput(['readelf', '-S', so_path])
+  sizes = collections.defaultdict(int)
+  for metric, section_names in _READELF_SIZES_METRICS.iteritems():
+    for section_name in section_names:
+      section_size = _ParseReadElfSectionSize(stdout, section_name)
+      if section_size:
+        sizes[metric] += section_size
+
+  return sizes
 
 
 def CountStaticInitializers(so_path):
   # Static initializers expected in official builds. Note that this list is
   # built using 'nm' on libchrome.so which results from a GCC official build
   # (i.e. Clang is not supported currently).
-  def get_elf_section_size(readelf_stdout, section_name):
-    # Matches: .ctors PROGBITS 000000000516add0 5169dd0 000010 00 WA 0 0 8
-    match = re.search(r'\.%s.*$' % re.escape(section_name),
-                      readelf_stdout, re.MULTILINE)
-    if not match:
-      return (False, -1)
-    size_str = re.split(r'\W+', match.group(0))[5]
-    return (True, int(size_str, 16))
 
   # Find the number of files with at least one static initializer.
   # First determine if we're 32 or 64 bit
   stdout = cmd_helper.GetCmdOutput(['readelf', '-h', so_path])
   elf_class_line = re.search('Class:.*$', stdout, re.MULTILINE).group(0)
   elf_class = re.split(r'\W+', elf_class_line)[1]
   if elf_class == 'ELF32':
     word_size = 4
   else:
     word_size = 8
 
   # Then find the number of files with global static initializers.
   # NOTE: this is very implementation-specific and makes assumptions
   # about how compiler and linker implement global static initializers.
   si_count = 0
   stdout = cmd_helper.GetCmdOutput(['readelf', '-SW', so_path])
-  has_init_array, init_array_size = get_elf_section_size(stdout, 'init_array')
-  if has_init_array:
+  init_array_size = _ParseReadElfSectionSize(stdout, 'init_array')
+  if init_array_size:
     si_count = init_array_size / word_size
   si_count = max(si_count, 0)
   return si_count
 
 
 def GetStaticInitializers(so_path):
   output = cmd_helper.GetCmdOutput([_DUMP_STATIC_INITIALIZERS_PATH, '-d',
                                     so_path])
   return output.splitlines()
 
@@ skipping 214 matching lines @@
   # Size of main .so vs remaining.
   main_lib_info = native_code.FindLargest()
   if main_lib_info:
     main_lib_size = main_lib_info.file_size
     ReportPerfResult(chartjson, apk_basename + '_Specifics',
                      'main lib size', main_lib_size, 'bytes')
     secondary_size = native_code.ComputeUncompressedSize() - main_lib_size
     ReportPerfResult(chartjson, apk_basename + '_Specifics',
                      'other lib size', secondary_size, 'bytes')
 
+    main_lib_section_sizes = _ExtractMainLibSectionSizesFromApk(
+        apk_filename, main_lib_info.filename)
+    for metric_name, size in main_lib_section_sizes.iteritems():
+      ReportPerfResult(chartjson, apk_basename + '_MainLibInfo',
+                       metric_name, size, 'bytes')
+
   # Main metric that we want to monitor for jumps.
   normalized_apk_size = total_apk_size
   # Always look at uncompressed .dex & .so.
   normalized_apk_size -= java_code.ComputeZippedSize()
   normalized_apk_size += java_code.ComputeUncompressedSize()
   normalized_apk_size -= native_code.ComputeZippedSize()
   normalized_apk_size += native_code.ComputeUncompressedSize()
   # Avoid noise caused when strings change and translations haven't yet been
   # updated.
   english_pak = translations.FindByPattern(r'.*/en[-_][Uu][Ss]\.l?pak')
@@ skipping 279 matching lines @@
 
   if chartjson:
     results_path = os.path.join(options.output_dir, 'results-chart.json')
     logging.critical('Dumping json to %s', results_path)
     with open(results_path, 'w') as json_file:
       json.dump(chartjson, json_file)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))