[asan] Teach asan_symbolize.py to use :arch with atos and llvm-symbolizer on Darwin

[kubamracek]

Summary

On Darwin, there is an issue with llvm-symbolizer and atos, where we cannot properly symbolize when mixing x86_64 and x86_64h modules within one process. This is a very common case on macOS (x86_64h is backwards compatible, so when there is no x86_64h slice, a regular x86_64 is loaded instead). This currently makes some compiler-rt tests fail on Haswell+ Darwin machines.

This patch teaches asan_symbolize.py to read an architecture suffix on module names (e.g. ":x86_64") and pass that option to atos and llvm-symbolizer. Follow-up patches will fix the same problem when invoking llvm-symbolizer directly from sanitizers.

[filcab]

Please add an if force_system_symbolizer: assert(allow_system_symbolizer) or similar, to do a sanity check.

lib/asan/scripts/asan_symbolize.py

444 ↗

(On Diff #80160)

Isn't : a valid filename character on most Linux fs?

[kubamracek]

lib/asan/scripts/asan_symbolize.py

444 ↗

(On Diff #80160)

Ah, okay. Do you want me to restrict this to Darwin?

[kubamracek]

Addressing review comments, updating patch. We will assume that the arch is part of the filename ("libabc.dylib:x86_64h") only if the last part is a known architecture. I'll update my other patch to add a comment into the .h file to point out that there's a list of known architectures in asan_symbolize.py.

[kubamracek]

ping

compiler-rt/trunk/lib/asan/scripts/asan_symbolize.py

 DEBUG = False
 demangle = False
 binutils_prefix = None
 sysroot_path = None
 binary_name_filter = None
 fix_filename_patterns = None
 logfile = sys.stdin
 allow_system_symbolizer = True
+force_system_symbolizer = False
 
 # FIXME: merge the code that calls fix_filename().
 def fix_filename(file_name):
   if fix_filename_patterns:
     for path_to_cut in fix_filename_patterns:
       file_name = re.sub('.*' + path_to_cut, '', file_name)
   file_name = re.sub('.*asan_[a-z_]*.cc:[0-9]*', '_asan_rtl_', file_name)
   file_name = re.sub('.*crtstuff.c:0', '???:0', file_name)
   return file_name
 
 def sysroot_path_filter(binary_name):
   return sysroot_path + binary_name
 
+def is_valid_arch(s):
+  return s in ["i386", "x86_64", "x86_64h", "arm", "armv6", "armv7", "armv7s",
+               "armv7k", "arm64", "powerpc64", "powerpc64le", "s390x", "s390"]
+
 def guess_arch(addr):
   # Guess which arch we're running. 10 = len('0x') + 8 hex digits.
   if len(addr) > 10:
     return 'x86_64'
   else:
     return 'i386'
 
 class Symbolizer(object):
def convert(self, line):
     self.w.write(line + "\n")
     return self.readline()
 
   def readline(self):
     return self.r.readline().rstrip()
 
 
 class DarwinSymbolizer(Symbolizer):
-  def __init__(self, addr, binary):
+  def __init__(self, addr, binary, arch):
     super(DarwinSymbolizer, self).__init__()
     self.binary = binary
-    self.arch = guess_arch(addr)
+    self.arch = arch
     self.open_atos()
 
   def open_atos(self):
     if DEBUG:
       print 'atos -o %s -arch %s' % (self.binary, self.arch)
     cmdline = ['atos', '-o', self.binary, '-arch', self.arch]
     self.atos = UnbufferedLineConverter(cmdline, close_stderr=True)
 
def BreakpadSymbolizerFactory(binary):
   suffix = os.getenv('BREAKPAD_SUFFIX')
   if suffix:
     filename = binary + suffix
     if os.access(filename, os.F_OK):
       return BreakpadSymbolizer(filename)
   return None
 
 
-def SystemSymbolizerFactory(system, addr, binary):
+def SystemSymbolizerFactory(system, addr, binary, arch):
   if system == 'Darwin':
-    return DarwinSymbolizer(addr, binary)
+    return DarwinSymbolizer(addr, binary, arch)
   elif system == 'Linux' or system == 'FreeBSD':
     return Addr2LineSymbolizer(binary)
 
 
 class BreakpadSymbolizer(Symbolizer):
   def __init__(self, filename):
     super(BreakpadSymbolizer, self).__init__()
     self.filename = filename
else:
       if self.system not in ['Linux', 'Darwin', 'FreeBSD']:
         raise Exception('Unknown system')
       self.llvm_symbolizers = {}
       self.last_llvm_symbolizer = None
       self.dsym_hints = set([])
       self.frame_no = 0
       self.process_line = self.process_line_posix
 
-  def symbolize_address(self, addr, binary, offset):
+  def symbolize_address(self, addr, binary, offset, arch):
     # On non-Darwin (i.e. on platforms without .dSYM debug info) always use
     # a single symbolizer binary.
     # On Darwin, if the dsym hint producer is present:
     #  1. check whether we've seen this binary already; if so,
     #     use |llvm_symbolizers[binary]|, which has already loaded the debug
     #     info for this binary (might not be the case for
     #     |last_llvm_symbolizer|);
     #  2. otherwise check if we've seen all the hints for this binary already;
     #     if so, reuse |last_llvm_symbolizer| which has the full set of hints;
     #  3. otherwise create a new symbolizer and pass all currently known
     #     .dSYM hints to it.
+    result = None
+    if not force_system_symbolizer:
       if not binary in self.llvm_symbolizers:
         use_new_symbolizer = True
         if self.system == 'Darwin' and self.dsym_hint_producer:
           dsym_hints_for_binary = set(self.dsym_hint_producer(binary))
           use_new_symbolizer = bool(dsym_hints_for_binary - self.dsym_hints)
           self.dsym_hints |= dsym_hints_for_binary
         if self.last_llvm_symbolizer and not use_new_symbolizer:
             self.llvm_symbolizers[binary] = self.last_llvm_symbolizer
         else:
           self.last_llvm_symbolizer = LLVMSymbolizerFactory(
-            self.system, guess_arch(addr), self.dsym_hints)
+              self.system, arch, self.dsym_hints)
           self.llvm_symbolizers[binary] = self.last_llvm_symbolizer
       # Use the chain of symbolizers:
       # Breakpad symbolizer -> LLVM symbolizer -> addr2line/atos
       # (fall back to next symbolizer if the previous one fails).
       if not binary in symbolizers:
         symbolizers[binary] = ChainSymbolizer(
             [BreakpadSymbolizerFactory(binary), self.llvm_symbolizers[binary]])
       result = symbolizers[binary].symbolize(addr, binary, offset)
+    else:
+      symbolizers[binary] = ChainSymbolizer([])
     if result is None:
       if not allow_system_symbolizer:
         raise Exception('Failed to launch or use llvm-symbolizer.')
       # Initialize system symbolizer only if other symbolizers failed.
       symbolizers[binary].append_symbolizer(
-          SystemSymbolizerFactory(self.system, addr, binary))
+          SystemSymbolizerFactory(self.system, addr, binary, arch))
       result = symbolizers[binary].symbolize(addr, binary, offset)
     # The system symbolizer must produce some result.
     assert result
     return result
 
   def get_symbolized_lines(self, symbolized_lines):
     if not symbolized_lines:
       return [self.current_line]
def process_line_posix(self, line):
     stack_trace_line_format = (
         '^( *#([0-9]+) *)(0x[0-9a-f]+) *\((.*)\+(0x[0-9a-f]+)\)')
     match = re.match(stack_trace_line_format, line)
     if not match:
       return [self.current_line]
     if DEBUG:
       print line
     _, frameno_str, addr, binary, offset = match.groups()
+    arch = ""
+    # Arch can be embedded in the filename, e.g.: "libabc.dylib:x86_64h"
+    colon_pos = binary.rfind(":")
+    if colon_pos != -1:
+      maybe_arch = binary[colon_pos+1:]
+      if is_valid_arch(maybe_arch):
+        arch = maybe_arch
+        binary = binary[0:colon_pos]
+    if arch == "":
+      arch = guess_arch(addr)
     if frameno_str == '0':
       # Assume that frame #0 is the first frame of new stack trace.
       self.frame_no = 0
     original_binary = binary
     if self.binary_name_filter:
       binary = self.binary_name_filter(binary)
-    symbolized_line = self.symbolize_address(addr, binary, offset)
+    symbolized_line = self.symbolize_address(addr, binary, offset, arch)
     if not symbolized_line:
       if original_binary != binary:
-        symbolized_line = self.symbolize_address(addr, binary, offset)
+        symbolized_line = self.symbolize_address(addr, binary, offset, arch)
     return self.get_symbolized_lines(symbolized_line)
 
 
 if __name__ == '__main__':
   parser = argparse.ArgumentParser(
       formatter_class=argparse.RawDescriptionHelpFormatter,
       description='ASan symbolization script',
       epilog='Example of use:\n'
              'asan_symbolize.py -c "$HOME/opt/cross/bin/arm-linux-gnueabi-" '
              '-s "$HOME/SymbolFiles" < asan.log')
   parser.add_argument('path_to_cut', nargs='*',
                       help='pattern to be cut from the result file path ')
   parser.add_argument('-d','--demangle', action='store_true',
                       help='demangle function names')
   parser.add_argument('-s', metavar='SYSROOT',
                       help='set path to sysroot for sanitized binaries')
   parser.add_argument('-c', metavar='CROSS_COMPILE',
                       help='set prefix for binutils')
   parser.add_argument('-l','--logfile', default=sys.stdin,
                       type=argparse.FileType('r'),
                       help='set log file name to parse, default is stdin')
+  parser.add_argument('--force-system-symbolizer', action='store_true',
+                      help='don\'t use llvm-symbolizer')
   args = parser.parse_args()
   if args.path_to_cut:
     fix_filename_patterns = args.path_to_cut
   if args.demangle:
     demangle = True
   if args.s:
     binary_name_filter = sysroot_path_filter
     sysroot_path = args.s
   if args.c:
     binutils_prefix = args.c
   if args.logfile:
     logfile = args.logfile
   else:
     logfile = sys.stdin
+  if args.force_system_symbolizer:
+    force_system_symbolizer = True
+  if force_system_symbolizer:
+    assert(allow_system_symbolizer)
   loop = SymbolizationLoop(binary_name_filter)
   loop.process_logfile()