symbolize_trace: symbolize in one go on macOS.

tracing/bin/symbolize_trace

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 """
 This script processes trace files and symbolizes stack frames generated by
 Chrome's native heap profiler. This script assumes that the Chrome binary
 referenced in the trace contains symbols, and is the same binary used to emit
 the trace.
@@ skipping 206 matching lines @@
 import gzip
 import itertools
 import json
 import os
 import re
 import shutil
 import subprocess
 import sys
 import tarfile
 import zipfile
+import tempfile
 
 _SYMBOLS_PATH = os.path.abspath(os.path.join(
     os.path.dirname(os.path.realpath(__file__)),
     '..',
     'third_party',
     'symbols'))
 sys.path.append(_SYMBOLS_PATH)
 # pylint: disable=import-error
 import symbols.elf_symbolizer as elf_symbolizer
 
@@ skipping 815 matching lines @@
       # SymbolizeAsync() asserts that the type of address is int. We operate
       # on longs (since they are raw pointers possibly from 64-bit processes).
       # It's OK to cast here because we're passing relative PC, which should
       # always fit into int.
       symbolizer.SymbolizeAsync(int(address), frames)
 
     symbolizer.Join()
 
 
   def _SymbolizeMac(self, symfile):
-    chars_max = int(subprocess.check_output("getconf ARG_MAX", shell=True))
-
-    # 16 for the address, 2 for "0x", 1 for the space
-    chars_per_address = 19
-
     load_address = (symbolize_trace_macho_reader.
         ReadMachOTextLoadAddress(symfile.symbolizable_path))
     assert load_address is not None
 
-    cmd_base = [self.symbolizer_path, '-arch', 'x86_64', '-l',
-                '0x%x' % load_address, '-o',
-                symfile.symbolizable_path]
-    chars_for_other_arguments = len(' '.join(cmd_base)) + 1
+    address_os_file, address_file_path = tempfile.mkstemp()
+    try:
+      with os.fdopen(address_os_file, 'w') as address_file:
+        for address in symfile.frames_by_address.iterkeys():
+          address_file.write('{:x} '.format(address + load_address))
 
-    # The maximum number of inputs that can be processed at once is limited by
-    # ARG_MAX. This currently evaluates to ~13000 on macOS.
-    max_inputs = (chars_max - chars_for_other_arguments) / chars_per_address
+      cmd = [self.symbolizer_path, '-arch', 'x86_64', '-l',
+             '0x%x' % load_address, '-o', symfile.symbolizable_path,
+             '-f', address_file_path]
+      output_array = subprocess.check_output(cmd).split('\n')
 
-    all_keys = symfile.frames_by_address.keys()
-    processed_keys_count = 0
-    while len(all_keys):
-      input_count = min(len(all_keys), max_inputs)
-      keys_to_process = all_keys[0:input_count]
-      cmd = list(cmd_base)
-      cmd.extend([hex(int(x) + load_address)
-          for x in keys_to_process])
-      output_array = subprocess.check_output(cmd).split('\n')
-      for i in range(len(keys_to_process)):
-        for frame in (symfile.frames_by_address.values()
-            [i + processed_keys_count]):
-          frame.name = self._matcher.Match(output_array[i])
-      processed_keys_count += len(keys_to_process)
-      all_keys = all_keys[input_count:]
+      for i, frames in enumerate(symfile.frames_by_address.itervalues()):
+        symbolized_name = self._matcher.Match(output_array[i])
+        for frame in frames:
+          frame.name = symbolized_name
+    finally:
+      os.remove(address_file_path)
 
   def _SymbolizeWin(self, symfile):
     """Invoke symbolizer binary on windows and write all input in one go.
 
     Unlike linux, on windows, symbolization talks through a shared system
     service that handles communication with the NT symbol servers. This
     creates an explicit serialization (and therefor lock contention) of
     any process using the symbol API for files do not have a local PDB.
 
     Thus, even though the windows symbolizer binary can be make command line
@@ skipping 304 matching lines @@
 
     print 'Updating the trace file...'
     with OpenTraceFile(trace_file_path, 'w') as trace_file:
       json.dump(trace.node, trace_file)
   else:
     print 'No modifications were made - not updating the trace file.'
 
 
 if __name__ == '__main__':
   main()