supersize: A few fixes for Android+clang builds

tools/binary_size/libsupersize/archive.py

 # Copyright 2017 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.
 
 """Main Python API for analyzing binary size."""
 
 import argparse
 import calendar
 import collections
 import datetime
@@ skipping 306 matching lines @@
     name_list = aliases_by_address.get(s.address)
     if name_list:
       if s.full_name not in name_list:
         logging.warning('Name missing from aliases: %s %s', s.full_name,
                         name_list)
         continue
       replacements.append((i, name_list))
       num_new_symbols += len(name_list) - 1
 
   if float(num_new_symbols) / len(raw_symbols) < .05:
+    # TODO(agrieve): Figure out if there's a way to get alias information from
+    # clang-compiled nm.
     logging.warning('Number of aliases is oddly low (%.0f%%). It should '
-                    'usually be around 25%%. Ensure --tool-prefix is correct.',
+                    'usually be around 25%%. Ensure --tool-prefix is correct. '
+                    'Ignore this if you compiled with clang.',
                     float(num_new_symbols) / len(raw_symbols) * 100)
 
   # Step 2: Create new symbols as siblings to each existing one.
   logging.debug('Creating %d aliases', num_new_symbols)
   src_cursor_end = len(raw_symbols)
   raw_symbols += [None] * num_new_symbols
   dst_cursor_end = len(raw_symbols)
   for src_index, name_list in reversed(replacements):
     # Copy over symbols that come after the current one.
     chunk_size = src_cursor_end - src_index - 1
@@ skipping 58 matching lines @@
       gn_args = _ParseGnArgs(os.path.join(output_directory, 'args.gn'))
       metadata[models.METADATA_MAP_FILENAME] = relative_to_out(map_path)
       metadata[models.METADATA_ELF_FILENAME] = relative_to_out(elf_path)
       metadata[models.METADATA_GN_ARGS] = gn_args
 
       if apk_path:
         metadata[models.METADATA_APK_FILENAME] = relative_to_out(apk_path)
   return metadata
 
 
-def CreateSizeInfo(map_path, elf_path, tool_prefix, output_directory,
-                   raw_only=False):
+def CreateSizeInfo(map_path, elf_path, tool_prefix, output_directory):
   """Creates a SizeInfo.
 
   Args:
     map_path: Path to the linker .map(.gz) file to parse.
     elf_path: Path to the corresponding unstripped ELF file. Used to find symbol
         aliases and inlined functions. Can be None.
     tool_prefix: Prefix for c++filt & nm (required).
     output_directory: Build output directory. If None, source_paths and symbol
         alias information will not be recorded.
-    raw_only: Fill in just the information required for creating a .size file.
   """
   source_mapper = None
   if output_directory:
     # Start by finding the elf_object_paths, so that nm can run on them while
     # the linker .map is being parsed.
     logging.info('Parsing ninja files.')
     source_mapper, elf_object_paths = ninja_parser.Parse(
         output_directory, elf_path)
     assert not elf_path or elf_object_paths, (
         'Failed to find link command in ninja files for ' +
@@ skipping 71 matching lines @@
       _ComputeAnscestorPathsAndNormalizeObjectPaths(
           raw_symbols, object_paths_by_name, source_mapper)
 
   if not elf_path or not output_directory:
     logging.info('Normalizing object paths.')
     for symbol in raw_symbols:
       symbol.object_path = _NormalizeObjectPath(symbol.object_path)
 
   size_info = models.SizeInfo(section_sizes, raw_symbols)
 
-  # Name normalization not strictly required, but makes for smaller files.
-  if raw_only:
-    logging.info('Normalizing symbol names')
-    _NormalizeNames(size_info.raw_symbols)
-  else:
-    _PostProcessSizeInfo(size_info)
+  # When creating the .size file, name normalization is not strictly required,
+  # but makes for smaller files.
+  # Padding not required either, but it is useful to check for large padding and
+  # log a warning.
+  _PostProcessSizeInfo(size_info)
 
-  if logging.getLogger().isEnabledFor(logging.DEBUG):
-    # Padding is reported in size coverage logs.
-    if raw_only:
-      _CalculatePadding(size_info.raw_symbols)
+  if logging.getLogger().isEnabledFor(logging.INFO):
     for line in describe.DescribeSizeInfoCoverage(size_info):
       logging.info(line)
   logging.info('Recorded info for %d symbols', len(size_info.raw_symbols))
   return size_info
 
 
 def _DetectGitRevision(directory):
   try:
     git_rev = subprocess.check_output(
         ['git', '-C', directory, 'rev-parse', 'HEAD'])
@@ skipping 126 matching lines @@
   if not args.no_source_paths:
     output_directory = lazy_paths.VerifyOutputDirectory()
 
   metadata = CreateMetadata(map_path, elf_path, apk_path, tool_prefix,
                             output_directory)
   if apk_path and elf_path:
     # Extraction takes around 1 second, so do it in parallel.
     apk_elf_result = concurrent.ForkAndCall(
         _ElfInfoFromApk, (apk_path, apk_so_path, tool_prefix))
 
-  size_info = CreateSizeInfo(
-      map_path, elf_path, tool_prefix, output_directory, raw_only=True)
+  size_info = CreateSizeInfo(map_path, elf_path, tool_prefix, output_directory)
 
   if metadata:
     size_info.metadata = metadata
 
     if apk_path:
       logging.debug('Extracting section sizes from .so within .apk')
       unstripped_section_sizes = size_info.section_sizes
       apk_build_id, size_info.section_sizes = apk_elf_result.get()
       assert apk_build_id == metadata[models.METADATA_ELF_BUILD_ID], (
           'BuildID for %s within %s did not match the one at %s' %
@@ skipping 13 matching lines @@
           logging.warning('Packed section not present: %s', packed_section_name)
         else:
           size_info.section_sizes['%s (unpacked)' % packed_section_name] = (
               unstripped_section_sizes.get(packed_section_name))
 
   logging.info('Recording metadata: \n  %s',
                '\n  '.join(describe.DescribeMetadata(size_info.metadata)))
   logging.info('Saving result to %s', args.size_file)
   file_format.SaveSizeInfo(size_info, args.size_file)
   logging.info('Done')