Output a linker map file for official builds

build/toolchain/gcc_solink_wrapper.py

 #!/usr/bin/env python
 # Copyright 2015 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.
 
 """Runs 'ld -shared' and generates a .TOC file that's untouched when unchanged.
 
 This script exists to avoid using complex shell commands in
 gcc_toolchain.gni's tool("solink"), in case the host running the compiler
 does not have a POSIX-like shell (e.g. Windows).
 """
 
 import argparse
+import gzip
 import os
+import shutil
 import subprocess
 import sys
+import threading
 
 import wrapper_utils
 
 
 def CollectSONAME(args):
   """Replaces: readelf -d $sofile | grep SONAME"""
   toc = ''
   readelf = subprocess.Popen(wrapper_utils.CommandToRun(
       [args.readelf, '-d', args.sofile]), stdout=subprocess.PIPE, bufsize=-1)
   for line in readelf.stdout:
@@ skipping 23 matching lines @@
 
 def UpdateTOC(tocfile, toc):
   if os.path.exists(tocfile):
     old_toc = open(tocfile, 'r').read()
   else:
     old_toc = None
   if toc != old_toc:
     open(tocfile, 'w').write(toc)
 
 
+def _GzipHelper(src_path, dest_path):
+  # Results for Android map file with GCC on a z620:
+  # Uncompressed: 207MB
+  # gzip -9: 16.4MB, takes 8.7 seconds.
+  # gzip -1: 21.8MB, takes 2.0 seconds.
+  # Piping directly from the linker via -print-map (or via -Map with a fifo)
+  # adds a whopping 30-45 seconds!
+  with open(src_path, 'rb') as f_in, gzip.GzipFile(dest_path, 'wb', 1) as f_out:
+    shutil.copyfileobj(f_in, f_out)
+  os.unlink(src_path)
+
+
 def main():
   parser = argparse.ArgumentParser(description=__doc__)
   parser.add_argument('--readelf',
                       required=True,
                       help='The readelf binary to run',
                       metavar='PATH')
   parser.add_argument('--nm',
                       required=True,
                       help='The nm binary to run',
                       metavar='PATH')
   parser.add_argument('--strip',
                       help='The strip binary to run',
                       metavar='PATH')
   parser.add_argument('--sofile',
                       required=True,
                       help='Shared object file produced by linking command',
                       metavar='FILE')
   parser.add_argument('--tocfile',
                       required=True,
                       help='Output table-of-contents file',
                       metavar='FILE')
+  parser.add_argument('--mapfile',
+                      help=('Use --Wl,-Map to generate a map file. Will be '
+                            'gzipped if extension ends with .gz'),
+                      metavar='FILE')
   parser.add_argument('--output',
                       required=True,
                       help='Final output shared object file',
                       metavar='FILE')
   parser.add_argument('--resource-whitelist',
                       help='Merge all resource whitelists into a single file.',
                       metavar='PATH')
   parser.add_argument('command', nargs='+',
                       help='Linking command')
   args = parser.parse_args()
 
   # Work-around for gold being slow-by-default. http://crbug.com/632230
   fast_env = dict(os.environ)
   fast_env['LC_ALL'] = 'C'
 
   if args.resource_whitelist:
     whitelist_candidates = wrapper_utils.ResolveRspLinks(args.command)
     wrapper_utils.CombineResourceWhitelists(
         whitelist_candidates, args.resource_whitelist)
 
   # First, run the actual link.
-  result = subprocess.call(
-      wrapper_utils.CommandToRun(args.command), env=fast_env)
+  command = wrapper_utils.CommandToRun(args.command)
+  tmp_map_path = None
+  if args.mapfile and args.mapfile.endswith('.gz'):
+    tmp_map_path = args.mapfile + '.tmp'
+    command.append('-Wl,-Map,' + tmp_map_path)
+  elif args.mapfile:
+    command.append('-Wl,-Map,' + args.mapfile)
+  result = subprocess.call(command, env=fast_env)
+
+  if tmp_map_path and result == 0:
+    threading.Thread(
+        target=lambda: _GzipHelper(tmp_map_path, args.mapfile)).start()
+  elif tmp_map_path and os.path.exists(tmp_map_file):
+    os.unlink(tmp_map_file)
+
   if result != 0:
     return result
 
   # Next, generate the contents of the TOC file.
   result, toc = CollectTOC(args)
   if result != 0:
     return result
 
   # If there is an existing TOC file with identical contents, leave it alone.
   # Otherwise, write out the TOC file.
   UpdateTOC(args.tocfile, toc)
 
   # Finally, strip the linked shared object file (if desired).
   if args.strip:
     result = subprocess.call(wrapper_utils.CommandToRun(
         [args.strip, '--strip-unneeded', '-o', args.output, args.sofile]))
 
   return result
 
 
 if __name__ == "__main__":
   sys.exit(main())