Create a star symbol for gaps at the start & end of sections

tools/binary_size/libsupersize/nm.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.
 
 """Functions that rely on parsing output of "nm" tool."""
 
+import atexit
 import collections
+import errno
 import logging
 import os
 import subprocess
 import sys
 
 import concurrent
 
+_active_subprocesses = None
+
 
 def CollectAliasesByAddress(elf_path, tool_prefix):
   """Runs nm on |elf_path| and returns a dict of address->[names]"""
   names_by_address = collections.defaultdict(list)
 
   # About 60mb of output, but piping takes ~30s, and loading it into RAM
   # directly takes 3s.
   args = [tool_prefix + 'nm', '--no-sort', '--defined-only', '--demangle',
           elf_path]
   output = subprocess.check_output(args)
@@ skipping 136 matching lines @@
     # It would speed up mashalling of the values by removing all entries
     # that have only 1 path. However, these entries are needed to give
     # path information to symbol aliases.
     self._result = paths_by_name
 
   def Get(self):
     assert self._result is not None
     return self._result
 
 
+def _TerminateSubprocesses():
+  for proc in _active_subprocesses:
+    proc.kill()
+
+
 class _BulkObjectFileAnalyzerMaster(object):
   """Runs BulkObjectFileAnalyzer in a subprocess."""
 
   def __init__(self, tool_prefix, output_directory):
     self._process = None
     self._tool_prefix = tool_prefix
     self._output_directory = output_directory
 
   def _Spawn(self):
+    global _active_subprocesses
     log_level = str(logging.getLogger().getEffectiveLevel())
     args = [sys.executable, __file__, log_level, self._tool_prefix,
             self._output_directory]
     self._process = subprocess.Popen(
         args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    if _active_subprocesses is None:
+      _active_subprocesses = []
+      atexit.register(_TerminateSubprocesses)
+    _active_subprocesses.append(self._process)
 
   def AnalyzePaths(self, paths):
     if self._process is None:
       self._Spawn()
 
     logging.debug('Sending batch of %d paths to subprocess', len(paths))
     payload = '\x01'.join(paths)
     self._process.stdin.write('{:08x}'.format(len(payload)))
     self._process.stdin.write(payload)
 
   def Close(self):
     assert not self._process.stdin.closed
     self._process.stdin.close()
+    _active_subprocesses.remove(self._process)
 
   def Get(self):
     assert self._process.stdin.closed
     logging.debug('Decoding nm results from forked process')
 
     encoded_keys_len = int(self._process.stdout.read(8), 16)
     encoded_keys = self._process.stdout.read(encoded_keys_len)
     encoded_values = self._process.stdout.read()
     return concurrent.DecodeDictOfLists(encoded_keys, encoded_values)
 
 
 BulkObjectFileAnalyzer = _BulkObjectFileAnalyzerMaster
 if concurrent.DISABLE_ASYNC:
   BulkObjectFileAnalyzer = _BulkObjectFileAnalyzerWorker
 
 
 def _SubMain(log_level, tool_prefix, output_directory):
-  logging.basicConfig(level=int(log_level),
-                      format='%(levelname).1s %(relativeCreated)6d %(message)s')
+  logging.basicConfig(
+      level=int(log_level),
+      format='nm: %(levelname).1s %(relativeCreated)6d %(message)s')
   bulk_analyzer = _BulkObjectFileAnalyzerWorker(tool_prefix, output_directory)
   while True:
     payload_len = int(sys.stdin.read(8) or '0', 16)
     if not payload_len:
       logging.debug('nm bulk subprocess received eof.')
       break
     paths = sys.stdin.read(payload_len).split('\x01')
     bulk_analyzer.AnalyzePaths(paths)
 
   bulk_analyzer.Close()
   paths_by_name = bulk_analyzer.Get()
   encoded_keys, encoded_values = concurrent.EncodeDictOfLists(paths_by_name)
-  sys.stdout.write('%08x' % len(encoded_keys))
-  sys.stdout.write(encoded_keys)
-  sys.stdout.write(encoded_values)
+  try:
+    sys.stdout.write('%08x' % len(encoded_keys))
+    sys.stdout.write(encoded_keys)
+    sys.stdout.write(encoded_values)
+  except IOError, e:
+    # Parent process exited.
+    if e.errno == errno.EPIPE:
+      sys.exit(1)
+
   logging.debug('nm bulk subprocess finished.')
 
 
 if __name__ == '__main__':
   _SubMain(*sys.argv[1:])