symbolize_trace: symbolize in one go on macOS.

experimental/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.
 
 import argparse
 import bisect
 import collections
 import gzip
 import itertools
 import json
 import os
 import re
 import subprocess
 import sys
+import tempfile
 
 sys.path.append(os.path.abspath(os.path.join(
     os.path.dirname(os.path.realpath(__file__)),
     '..', '..', '..', 'tracing', 'bin')))
 sys.path.append(os.path.abspath(os.path.join(
     os.path.dirname(os.path.realpath(__file__)),
     '..', '..', '..', 'tracing', 'third_party', 'symbols')))
 # pylint: disable=import-error
 import symbols.elf_symbolizer as elf_symbolizer
 
@@ skipping 892 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 evalutes 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 596 matching lines @@
 
     print 'Updating the trace file...'
     with OpenTraceFile(trace_file_path, 'w') as trace_file:
       json.dump(trace.Serialize(), trace_file)
   else:
     print 'No modifications were made - not updating the trace file.'
 
 
 if __name__ == '__main__':
   main()