Update symbolize_trace to work 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.
 
 import argparse
 import bisect
 import collections
 import gzip
 import json
 import os
 import re
 import subprocess
 import sys
 
 _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
 
+import symbolize_trace_atos_regex
+
 
 # Relevant trace event phases from Chromium's
 # src/base/trace_event/common/trace_event_common.h.
 TRACE_EVENT_PHASE_METADATA = 'M'
 TRACE_EVENT_PHASE_MEMORY_DUMP = 'v'
 
 
 # Matches Android library paths, supports both K (/data/app-lib/<>/lib.so)
 # as well as L+ (/data/app/<>/lib/<>/lib.so). Library name is available
 # via 'name' group.
@@ skipping 10 matching lines @@
 
 def FindInSystemPath(binary_name):
   paths = os.environ['PATH'].split(os.pathsep)
   for path in paths:
     binary_path = os.path.join(path, binary_name)
     if os.path.isfile(binary_path):
       return binary_path
   return None
 
 
+class Symbolizer(object):
+  # Encapsulates platform-specific symbolization logic.
+  def __init__(self):
+    self.is_mac = sys.platform == 'darwin'
+    if self.is_mac:
+      self.binary = 'atos'
+      self._matcher = symbolize_trace_atos_regex.AtosRegexMatcher()
+    else:
+      self.binary = 'addr2line'
+    self.symbolizer_path = FindInSystemPath(self.binary)
+
+  def _SymbolizeLinuxAndAndroid(self, symfile):
+    def _SymbolizerCallback(sym_info, frames):
+      # Unwind inline chain to the top.
+      while sym_info.inlined_by:
+        sym_info = sym_info.inlined_by
+
+      symbolized_name = sym_info.name if sym_info.name else unsymbolized_name
+      for frame in frames:
+        frame.name = symbolized_name
+
+    symbolizer = elf_symbolizer.ELFSymbolizer(symfile.symbolizable_path,
+                                              self.symbolizer_path,
+                                              _SymbolizerCallback,
+                                              inlines=True)
+
+    for address, frames in symfile.frames_by_address.iteritems():
+      # 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
+
+    cmd_base = [self.symbolizer_path, '-arch', 'x86_64', '-l',
+                '0x0', '-o' , symfile.symbolizable_path]
+    chars_for_other_arguments = len(' '.join(cmd_base)) + 1
+
+    # 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
+
+    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)) 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:]
+
+  def Symbolize(self, symfile):
+    if self.is_mac:
+      self._SymbolizeMac(symfile)
+    else:
+      self._SymbolizeLinuxAndAndroid(symfile)
+
+
 def IsSymbolizableFile(file_path):
   result = subprocess.check_output(['file', '-0', file_path])
   type_string = result[result.find('\0') + 1:]
-  return bool(re.match(r'\: (ELF|Mach-O) (32|64)-bit\b', type_string))
+  return bool(re.match(r'.*(ELF|Mach-O) (32|64)-bit\b.*',
+              type_string, re.DOTALL))
 
 
 class ProcessMemoryMaps(object):
   """Represents 'process_mmaps' trace file entry."""
 
   class Region(object):
     def __init__(self, start_address, size, file_path):
       self._start_address = start_address
       self._size = size
       self._file_path = file_path
@@ skipping 195 matching lines @@
       symfile = symfile_by_path.get(region.file_path)
       if symfile is None:
         symfile = SymbolizableFile(region.file_path)
         symfile_by_path[symfile.path] = symfile
 
       relative_pc = frame.pc - region.start_address
       symfile.frames_by_address[relative_pc].append(frame)
   return symfile_by_path.values()
 
 
-def SymbolizeFiles(symfiles, addr2line_path):
+def SymbolizeFiles(symfiles, symbolizer):
   """Symbolizes each file in the given list of SymbolizableFiles
      and updates stack frames with symbolization results."""
   print 'Symbolizing...'
 
   def _SubPrintf(message, *args):
     print ('  ' + message).format(*args)
 
   symbolized = False
   for symfile in symfiles:
     unsymbolized_name = '<{}>'.format(
         symfile.path if symfile.path else 'unnamed')
 
     problem = None
     if not os.path.isabs(symfile.symbolizable_path):
       problem = 'not a file'
     elif not os.path.isfile(symfile.symbolizable_path):
       problem = "file doesn't exist"
     elif not IsSymbolizableFile(symfile.symbolizable_path):
       problem = 'file is not symbolizable'
     if problem:
       _SubPrintf("Won't symbolize {} PCs for '{}': {}.",
                  len(symfile.frames_by_address),
                  symfile.symbolizable_path,
                  problem)
       for frames in symfile.frames_by_address.itervalues():
         for frame in frames:
           frame.name = unsymbolized_name
       continue
 
-    def _SymbolizerCallback(sym_info, frames):
-      # Unwind inline chain to the top.
-      while sym_info.inlined_by:
-        sym_info = sym_info.inlined_by
-
-      symbolized_name = sym_info.name if sym_info.name else unsymbolized_name
-      for frame in frames:
-        frame.name = symbolized_name
-
-    symbolizer = elf_symbolizer.ELFSymbolizer(symfile.symbolizable_path,
-                                              addr2line_path,
-                                              _SymbolizerCallback,
-                                              inlines=True)
-
     _SubPrintf('Symbolizing {} PCs from {}...',
                len(symfile.frames_by_address),
                symfile.path)
 
-    for address, frames in symfile.frames_by_address.iteritems():
-      # 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()
+    symbolizer.Symbolize(symfile)
     symbolized = True
 
   return symbolized
 
 
 def HaveFilesFromAndroid(symfiles):
   return any(ANDROID_PATH_MATCHER.match(f.path) for f in symfiles)
 
 
 def RemapAndroidFiles(symfiles, output_path):
@@ skipping 25 matching lines @@
                            'as out/Debug. Only needed for Android.')
   options = parser.parse_args()
 
   trace_file_path = options.file
   def _OpenTraceFile(mode):
     if trace_file_path.endswith('.gz'):
       return gzip.open(trace_file_path, mode + 'b')
     else:
       return open(trace_file_path, mode + 't')
 
-  addr2line_path = FindInSystemPath('addr2line')
-  if addr2line_path is None:
-    sys.exit("Can't symbolize - no addr2line in PATH.")
+  symbolizer = Symbolizer()
+  if symbolizer.symbolizer_path is None:
+    sys.exit("Can't symbolize - no %s in PATH." % symbolizer.binary)
 
   print 'Reading trace file...'
   with _OpenTraceFile('r') as trace_file:
     trace = json.load(trace_file)
 
   processes = CollectProcesses(trace)
   symfiles = ResolveSymbolizableFiles(processes)
 
   # Android trace files don't have any indication they are from Android.
   # So we're checking for Android-specific paths.
   if HaveFilesFromAndroid(symfiles):
     if not options.output_directory:
       parser.error('The trace file appears to be from Android. Please '
                    "specify output directory (e.g. 'out/Debug') to properly "
                    'symbolize it.')
     RemapAndroidFiles(symfiles, os.path.abspath(options.output_directory))
 
-  if SymbolizeFiles(symfiles, addr2line_path):
+  if SymbolizeFiles(symfiles, symbolizer):
     if options.backup:
       backup_file_path = trace_file_path + BACKUP_FILE_TAG
       print 'Backing up trace file to {}...'.format(backup_file_path)
       os.rename(trace_file_path, backup_file_path)
 
     print 'Updating trace file...'
     with _OpenTraceFile('w') as trace_file:
       json.dump(trace, trace_file)
   else:
     print 'No PCs symbolized - not updating trace file.'
 
 
 if __name__ == '__main__':
   main()