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
 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
+import symbolize_trace_macho_reader
 
 
 # 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
@@ skipping 52 matching lines @@
       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
 
+    region_start_address = (symbolize_trace_macho_reader.

[DmitrySkiba, 2017/02/16 21:19:45]

Let's call this load_address ?

[erikchen, 2017/02/16 21:32:18]

Done.

+        ReadMachOTextLoadAddress(symfile.symbolizable_path))
+    assert region_start_address is not None
+
     cmd_base = [self.symbolizer_path, '-arch', 'x86_64', '-l',
-                '0x0', '-o' , symfile.symbolizable_path]
+                '0x%x' % 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) + region_start_address)

[DmitrySkiba, 2017/02/16 21:19:45]

This change seems to be noop, why are you making it? (Also, the one below.)

[erikchen, 2017/02/16 21:32:18]

I don't understand your question.

old code:
hex(int(x))

new code:

hex(int(x) + region_start_address)

[DmitrySkiba, 2017/02/16 21:38:48]

Oops, sorry, this line is fine.

But the next line changed from

for frame in symfile.frames_by_address.values()[i + processed_keys_count]:

to

for frame in (symfile.frames_by_address.values()
    [i + processed_keys_count]):

and I wonder why?

[erikchen, 2017/02/16 21:43:21]

previous version exceeded 80 column length

+          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]:
+        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)
 
@@ skipping 326 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()