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
@@ skipping 37 matching lines @@
   for path in paths:
     binary_path = os.path.join(path, binary_name)
     if os.path.isfile(binary_path):
       return binary_path
   return None
 
 
 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_path):
   """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()
+    if sys.platform == 'darwin':

[DmitrySkiba, 2017/01/10 21:28:09]

We have this check in two places - first when we decide what symbolizer_path
should be, the other is here. If looks like symbolizer_path should instead be
'symblizer' object with a single method.

[erikchen, 2017/02/04 02:34:56]

Introducing a class to avoid an extra conditional seems dubious to me, but
whatever. Done.

+      SymbolizeMac(symfile, symbolizer_path)
+    else:
+      SymbolizeLinuxAndAndroid(sym_file, symbolizer_path)
     symbolized = True
 
   return symbolized
 
 
+def SymbolizeLinuxAndAndroid(sym_file, symbolizer_path):
+  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,
+                                            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(symfile, symbolizer_path):
+  cmd = [symbolizer_path, '-arch', 'x86_64', '-l',
+         '0x0', '-o' , symfile.symbolizable_path]
+  cmd.extend([hex(int(x)) for x in symfile.frames_by_address.keys()])

[DmitrySkiba, 2017/01/10 21:28:09]

What is the max command line length on macOS? This can easily append thousands
of addresses.

[erikchen, 2017/02/04 02:34:56]

By default, the max length is 260k characters. I've added logic to not exceed
that limit.

+  output_array = subprocess.check_output(cmd).split('\n')
+  for i in range(len(symfile.frames_by_address.keys())):
+    for frame in symfile.frames_by_address.values()[i]:
+      frame.name = output_array[i]
+
+
 def HaveFilesFromAndroid(symfiles):
   return any(ANDROID_PATH_MATCHER.match(f.path) for f in symfiles)
 
 
 def RemapAndroidFiles(symfiles, output_path):
   for symfile in symfiles:
     match = ANDROID_PATH_MATCHER.match(symfile.path)
     if match:
       name = match.group('name')
       symfile.symbolizable_path = os.path.join(
@@ skipping 20 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.")
+  if sys.platform == 'darwin':
+    symbolizer = 'atos'
+  else:
+    symbolizer = 'addr2line'
+  symbolizer_path = FindInSystemPath(symbolizer)
+  if symbolizer_path is None:
+    sys.exit("Can't symbolize - no %s in PATH." % symbolizer)
 
   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_path):
     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()