Support for separate debug info files in asan symbolize script

[m.guseva]

Summary

The patch allows asan symbolize script to use separate debug info files on Linux system using ELF debug link or build ID for debug info files locating. These are methods provided currently by GNU Binutils. Added functionality replicates the GDB algorithm https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html

[samsonov]

Why can't you use llvm-symbolizer? This tool implements searching for separate debug info files (looking at /usr/lib/debug, calculating crc32 hashes and so on). I was sure that addr2line does this as well. This should be the responsibility of the tools we invoke through asan_symbolize.py script, not the script itself.

[m.guseva]

In D4902#4, @samsonov wrote:

Why can't you use llvm-symbolizer? This tool implements searching for separate debug info files (looking at /usr/lib/debug, calculating crc32 hashes and so on). I was sure that addr2line does this as well. This should be the responsibility of the tools we invoke through asan_symbolize.py script, not the script itself.

I am using gcc and GNU binutils, not llvm. You are right, the separate debug info is supported by addr2line tool. But I need it to work with sysroot defined also. The other way could be to add such functionality to addr2line instead of patching the script.
So if you don't find the patch generally useful I agree it must be rejected.

[emaste]

I think the functionality is generally useful, but it's the responsibility of the individual tools (binutils and LLVM equivalents) to handle standalone debug, not every script or tool that invokes them.

lib/asan/scripts/asan_symbolize.py

596

Standalone debug works the same way on FreeBSD too, so == 'Linux' is too restrictive.

[samsonov]

I think that adding support for standalone debug info to asan_symbolize.py is not an option. This logic is already implemented in the symbolization tools, if you want them to work with custom sysroot (so that debug versions of binaries could be found at /path/to/my/sysroot/usr/lib/debug), just add the --sysroot flag to the tools. I can review and submit this kind of patch to llvm-symbolizer tool.

lib/asan/scripts/asan_symbolize.py

 #!/usr/bin/env python
 #===- lib/asan/scripts/asan_symbolize.py -----------------------------------===#
 #
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 #
 #===------------------------------------------------------------------------===#
 import argparse
+import array
+import binascii
 import bisect
-import getopt
 import os
 import pty
 import re
 import subprocess
 import sys
 import termios
 
 symbolizers = {}
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 use_binutils_prefix(tool_name):
+  if binutils_prefix:
+    tool_name = binutils_prefix + tool_name
+  return tool_name
+
+def print_error_message(message):
+  print >> sys.stderr, 'Error occured during symbolizisation: ' + message
+
+class DebugInfoHandler(object):
+  def __init__(self, binary_name_filter=None):
+    self.binary_name_filter = binary_name_filter
+    self.global_debug_directory = "/usr/lib/debug"
+
+  def use_name_filter(self, binary_name):
+    if self.binary_name_filter:
+      binary_name = self.binary_name_filter(binary_name)
+    return binary_name
+
+  def calc_crc32(self, filename):
+    buf = open(filename,'rb').read()
+    buf = (binascii.crc32(buf, 0) & 0xFFFFFFFF)
+    return "%08X" % buf
+
+  def readelf_binary(self, options, binary):
+    cmd = [use_binutils_prefix('readelf'), options, binary]
+    try:
+      process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=open(os.devnull, 'w'))
+    except:
+      print_error_message('the following command failed:\n''"' + ' '.join(cmd) + '"')
+      return
+    (readelf_out, _) = process.communicate()
+    if process.returncode == 0:
+      return readelf_out
+
+  def has_debuginfo(self, binary):
+    readelf_out = self.readelf_binary('-S', binary)
+    return  readelf_out and (".debug_" in readelf_out)
+
+  def get_buildid(self, binary):
+    readelf_out = self.readelf_binary('-nw', binary)
+    '''
+    Build ID is 40-length hex value following after "Build ID:".
+    e.g.:
+    Notes at offset 0x00000274 with length 0x00000024:
+      Owner                 Data size       Description
+      GNU                  0x00000014       NT_GNU_BUILD_ID (unique build ID bitstring)
+            Build ID: 977b1d1375ba6791d5f6dd38d8d55b95f9fca33a
+    '''
+    if readelf_out:
+      readelf_lines = readelf_out.split("\n");
+      buildid_lines = filter(re.compile('Build ID:').search, readelf_lines)
+      for line in buildid_lines:
+        match = re.search('[a-f0-9]{40}', line)
+        if match:
+          return match.group(0)
+      else:
+          print_error_message('failed to read Build ID value from ' + binary)
+
+  def get_debuglink_name(self, binary):
+    readelf_out = self.readelf_binary('--string-dump=.gnu_debuglink', binary)
+    '''
+    "debug link" is the last word in the first line of dump.
+    e.g.:
+    String dump of section '.gnu_debuglink':
+      [     0]  HeapOutOfBounds.out.debug
+    '''
+    if readelf_out:
+      readelf_lines = filter(None, readelf_out.split("\n"));
+      headline ="String dump of section '.gnu_debuglink':"
+      try:
+        debuglink_line_idx = readelf_lines.index(headline) + 1
+      except ValueError:
+        # There is no gnu_debuglink section in this binary
+        return
+      if len(readelf_lines) > debuglink_line_idx:
+        return readelf_lines[debuglink_line_idx].split()[-1]
+      else:
+        print_error_message('failed to read debuglink value from ' + binary)
+
+  def get_debuglink_crc(self, binary):
+    readelf_out = self.readelf_binary('--hex-dump=.gnu_debuglink', binary)
+    '''
+    crc is the last hex group (before string representation) in the last line of dump.
+    e.g. (crc is f89f21c2) :
+    Hex dump of section '.gnu_debuglink':
+      0x00000000 48656170 4f75744f 66426f75 6e64732e HeapOutOfBounds.
+      0x00000010 6f75742e 64656275 67000000 f89f21c2 out.debug.....!.
+    '''
+    if readelf_out:
+      # get last non-empty line
+      crc_line = filter(None, readelf_out.split("\n"))[-1]
+      # remove last 16 characters (string dump) from line
+      crc_line = crc_line[:-16]
+      # crc is last word in string
+      crc = crc_line.split()[-1]
+      match = re.match('[a-f0-9]{8}', crc)
+      if match:
+        if sys.byteorder == 'little':
+          crc = array.array('i', binascii.unhexlify(crc) )
+          crc.byteswap()
+          crc = binascii.hexlify(crc)
+        return crc
+      else:
+        print_error_message('failed to get crc checksum from debuglink in ' + binary)
+
+  def lookfor_debuginfo(self, debugfile, orig_binary_name, debuginfo_locate_fun):
+    # Get debuginfo file accoding to debuginfo_location function
+    debuginfo = debuginfo_locate_fun(debugfile, orig_binary_name)
+    if debuginfo:
+      debuginfo = self.use_name_filter(debuginfo)
+      # Check if such file exists
+      if os.path.isfile(debuginfo):
+        return debuginfo
+
+  def locate_in_orig_dir(self, debuginfo, orig_binary_name):
+    return os.path.join(os.path.dirname(orig_binary_name), debuginfo)
+
+  def locate_in_debug_subdir(self, debuginfo, orig_binary_name):
+    return os.path.join(os.path.dirname(orig_binary_name), '.debug', debuginfo)
+
+  def locate_in_global_debug_dir(self, debuginfo, orig_binary_name):
+    return self.global_debug_directory + self.locate_in_orig_dir(debuginfo, orig_binary_name)
+
+  def locate_in_buildid_dir(self, debuginfo, orig_binary_name):
+    dir_name = debuginfo[0:2]
+    file_name = debuginfo[2:] + ".debug"
+    return os.path.join(self.global_debug_directory, ".build-id", dir_name, file_name)
+
+  def get_debuginfo(self,binary_name):
+    orig_binary_name = binary_name
+    # First apply sysroot path if defined to get real binary
+    real_binary = self.use_name_filter(binary_name)
+    if self.has_debuginfo(real_binary):
+        return real_binary
+    # Look for debuginfo file according to GDB rules
+    # 1) "build-id" method
+    buildid_name = self.get_buildid(real_binary)
+    if buildid_name:
+      binary_name = self.lookfor_debuginfo(buildid_name, orig_binary_name, self.locate_in_buildid_dir)
+      if binary_name:
+        return binary_name
+    # 2) "debug link" method
+    debuglink_name = self.get_debuglink_name(real_binary)
+    debuglink_crc = self.get_debuglink_crc(real_binary)
+    if debuglink_name and debuglink_crc:
+      debuglink_locate_list = [
+        self.locate_in_orig_dir,
+        self.locate_in_debug_subdir,
+        self.locate_in_global_debug_dir ]
+      for debuglink_locate_function in debuglink_locate_list:
+        binary_name = self.lookfor_debuginfo(debuglink_name, orig_binary_name, debuglink_locate_function)
+        if binary_name:
+          binary_crc = self.calc_crc32(binary_name)
+          if int(debuglink_crc,16) == int(binary_crc, 16):
+            return binary_name
+    print_error_message('No debuginfo found for ' + orig_binary_name)
+    return real_binary
+
 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):

 
 class Addr2LineSymbolizer(Symbolizer):
   def __init__(self, binary):
     super(Addr2LineSymbolizer, self).__init__()
     self.binary = binary
     self.pipe = self.open_addr2line()
 
   def open_addr2line(self):
-    addr2line_tool = 'addr2line'
-    if binutils_prefix:
-      addr2line_tool = binutils_prefix + addr2line_tool
-    cmd = [addr2line_tool, '-f']
+    cmd = [use_binutils_prefix('addr2line'), '-f']
     if demangle:
       cmd += ['--demangle']
     cmd += ['-e', self.binary]
     if DEBUG:
       print ' '.join(cmd)
     return subprocess.Popen(cmd,
                             stdin=subprocess.PIPE, stdout=subprocess.PIPE)
 
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 os.uname()[0] == 'Linux':
+    debug_info_handler = DebugInfoHandler(binary_name_filter)
+    binary_name_filter = debug_info_handler.get_debuginfo
   loop = SymbolizationLoop(binary_name_filter)
   loop.process_logfile()