Use absolute pcs and load locations to symbolize 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 78 matching lines @@
 
     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]
+                '0x%x' % symfile.region_start_address, '-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])
+      cmd.extend([hex(int(x) + symfile.region_start_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:]
 
   def Symbolize(self, symfile):
     if self.is_mac:
       self._SymbolizeMac(symfile)
@@ skipping 187 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.region_start_address = 0
 
 
 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 = {}
   for process in processes:
     for frame in process.stack_frames.pc_frames:
       region = process.mmaps.FindRegion(frame.pc)
       if region is None:
         frame.name = '<unresolved>'
         continue
 
       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.region_start_address = region.start_address

[DmitrySkiba, 2017/02/15 22:40:38]

Hmm, this overwrites the whatever value region_start_address previously had.

Does macOS have ASLR for the image itself? The reason we calculate relative_pc
here is because different absolute addresses can end up being single relative
address after translation.

I.e. browser mapped foo() to 0xA000, and renderer mapped it to 0xF000, but it's
relative address ends up being 0x1000 if we take into account load addresses.

With this change we end up with the same relative address 0x1000, but use the
last known start address 0xE000 to later (in _SymbolizeMac) translate 0x1000
back to 0xF000.

What am I missing?

       symfile.frames_by_address[relative_pc].append(frame)
   return symfile_by_path.values()
 
 
 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):
@@ skipping 99 matching lines @@
 
     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()