Add an end-to-end test for symbolize_trace on macOS.

tracing/bin/symbolize_trace.py

 #!/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 967 matching lines @@
   """Holds file path, addresses to symbolize and stack frames to update.
 
   This class is a link between ELFSymbolizer and a trace file: it specifies
   what to symbolize (addresses) and what to update with the symbolization
   result (frames).
   """
   def __init__(self, file_path):
     self.path = file_path
     self.symbolizable_path = file_path # path to use for symbolization
     self.frames_by_address = collections.defaultdict(list)
+    self.skip_symbolization = False
 
 
 def ResolveSymbolizableFiles(processes):
   """Resolves and groups PCs into list of SymbolizableFiles.
 
   As part of the grouping process, this function resolves PC from each stack
   frame to the corresponding mmap region. Stack frames that failed to resolve
   are symbolized with '<unresolved>'.
   """
   symfile_by_path = {}
@@ skipping 61 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):
+    if symfile.skip_symbolization:
+      for address, frames in symfile.frames_by_address.iteritems():
+        unsymbolized_name = ('<' + symfile.symbolizable_path + '> + ' +

[etienneb, 2017/06/20 03:28:09]

I wonder if we should not use only basename instead of the full path

[erikchen, 2017/06/23 00:33:45]

Done.

+                             str(address))
+        for frame in frames:
+          frame.name = unsymbolized_name
+      return
+
     load_address = (symbolize_trace_macho_reader.
         ReadMachOTextLoadAddress(symfile.symbolizable_path))
     assert load_address is not None
 
     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))
 
@@ skipping 16 matching lines @@
     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
     compatible with the POSIX addr2line interface, parallelizing the
     symbolization does not yield the same performance effects. Running
     just one symbolizer seems good enough for now. Can optimize later
     if this becomes a bottleneck.
     """
+    if symfile.skip_symbolization:
+      for address, frames in symfile.frames_by_address.iteritems():
+        unsymbolized_name = ('<' + symfile.symbolizable_path + '> + ' +
+                             str(address))

[etienneb, 2017/06/20 03:28:09]

nit: address should be hexa!?

[erikchen, 2017/06/23 00:33:45]

Done.

+        for frame in frames:
+          frame.name = unsymbolized_name
+      return
+
     cmd = [self.symbolizer_path, '--functions', '--demangle', '--exe',
                 symfile.symbolizable_path]
 
     proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE,
             stderr=sys.stderr)
     addrs = ["%x" % relative_pc for relative_pc in
              symfile.frames_by_address.keys()]
     (stdout_data, stderr_data) = proc.communicate('\n'.join(addrs))
     stdout_data = stdout_data.split('\n')
 
@@ skipping 90 matching lines @@
       name = match.group('name')
       symfile.symbolizable_path = os.path.join(
           output_path, ANDROID_UNSTRIPPED_SUBPATH, name)
     else:
       # Clobber file path to trigger "not a file" problem in SymbolizeFiles().
       # Without this, files won't be symbolized with "file not found" problem,
       # which is not accurate.
       symfile.symbolizable_path = 'android://{}'.format(symfile.path)
 
 
-def RemapMacFiles(symfiles, symbol_base_directory, version):
+def RemapMacFiles(symfiles, symbol_base_directory, version,
+                  only_symbolize_chrome_symbols):
   suffix = ("Google Chrome Framework.dSYM/Contents/Resources/DWARF/"
             "Google Chrome Framework")
   symbol_sub_dir = os.path.join(symbol_base_directory, version)
   symbolizable_path = os.path.join(symbol_sub_dir, suffix)
 
   for symfile in symfiles:
     if symfile.path.endswith("Google Chrome Framework"):
       symfile.symbolizable_path = symbolizable_path
+    elif only_symbolize_chrome_symbols:
+      symfile.skip_symbolization = True
 
-def RemapWinFiles(symfiles, symbol_base_directory, version, is64bit):
+def RemapWinFiles(symfiles, symbol_base_directory, version, is64bit,
+                  only_symbolize_chrome_symbols):
   folder = "win64" if is64bit else "win"
   symbol_sub_dir = os.path.join(symbol_base_directory,
                                 "chrome-" + folder + "-" + version)
   for symfile in symfiles:
     image = os.path.join(symbol_sub_dir, os.path.basename(symfile.path))
     symbols = image + ".pdb"
     if os.path.isfile(image) and os.path.isfile(symbols):
       symfile.symbolizable_path = image
+    elif only_symbolize_chrome_symbols:
+      symfile.skip_symbolization = True
 
 def Symbolize(options, trace, symbolizer):
   symfiles = ResolveSymbolizableFiles(trace.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:
       sys.exit('The trace file appears to be from Android. Please '
                'specify output directory to properly symbolize it.')
     RemapAndroidFiles(symfiles, os.path.abspath(options.output_directory))
 
 
   if not trace.is_chromium:
     if symbolizer.is_mac:
-      RemapMacFiles(symfiles, options.symbol_base_directory, trace.version)
+      RemapMacFiles(symfiles, options.symbol_base_directory, trace.version,
+                    options.only_symbolize_chrome_symbols)
     if symbolizer.is_win:
       RemapWinFiles(symfiles, options.symbol_base_directory, trace.version,
-                    trace.is_64bit)
+                    trace.is_64bit, options.only_symbolize_chrome_symbols)
 
   SymbolizeFiles(symfiles, symbolizer)
 
 
 def OpenTraceFile(file_path, mode):
   if file_path.endswith('.gz'):
     return gzip.open(file_path, mode + 'b')
   else:
     return open(file_path, mode + 't')
 
@@ skipping 68 matching lines @@
       os.path.join(symbol_base_directory,
                    "chrome-" + folder + "-" + version + ".zip"),
       gcs_folder + "chrome-" + folder + "-pgo.zip",
       symbol_sub_dir)
 
   return True
 
 # Suffix used for backup files.
 BACKUP_FILE_TAG = '.BACKUP'
 
-def main():
+def main(args):
   parser = argparse.ArgumentParser()
   parser.add_argument(
       'file',
       help='Trace file to symbolize (.json or .json.gz)')
 
   parser.add_argument(
       '--no-backup', dest='backup', default='true', action='store_false',
       help="Don't create {} files".format(BACKUP_FILE_TAG))
 
   parser.add_argument(
       '--output-directory',
       help='The path to the build output directory, such as out/Debug.')
 
+  parser.add_argument(

[etienneb, 2017/06/20 03:28:09]

For not chromium trace (traces from user computers) we should put that flag "on"
by default.

Or

We could symbolize address + offset by default, and put a flag to also symbolize
system libraries.

[erikchen, 2017/06/23 00:33:45]

Done.

+      '--only-symbolize-chrome-symbols',
+      action='store_true',
+      help='Prevents symbolization of non-Chrome [system] symbols.')
+
   home_dir = os.path.expanduser('~')
   default_dir = os.path.join(home_dir, "symbols")
   parser.add_argument(
       '--symbol-base-directory',
       default=default_dir,
       help='Directory where symbols are downloaded and cached.')
 
   symbolizer = Symbolizer()
   if symbolizer.symbolizer_path is None:
     sys.exit("Can't symbolize - no %s in PATH." % symbolizer.binary)
 
-  options = parser.parse_args()
+  options = parser.parse_args(args)
 
   trace_file_path = options.file
 
   print 'Reading trace file...'
   with OpenTraceFile(trace_file_path, 'r') as trace_file:
     trace = Trace(json.load(trace_file))
 
   # Perform some sanity checks.
   if trace.is_win and sys.platform != 'win32':
     print "Cannot symbolize a windows trace on this architecture!"
@@ skipping 26 matching lines @@
       os.rename(trace_file_path, backup_file_path)
 
     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()
+  main(sys.argv[1:])