tools/cygprofile/symbolize.py

   1 #!/usr/bin/python
   2 # Copyright 2013 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """Symbolize log file produced by cypgofile instrumentation.
   7
   8 Given a log file and the binary being profiled (e.g. executable, shared
   9 library), the script can produce three different outputs: 1) symbols for the
  10 addresses, 2) function and line numbers for the addresses, or 3) an order file.
  11 """
  12
  13 import optparse
  14 import os
  15 import string
  16 import subprocess
  17 import sys
  18
  19
  20 def ParseLogLines(log_file_lines):
  21   """Parse a log file produced by the profiled run of clank.
  22
  23   Args:
  24     log_file_lines: array of lines in log file produced by profiled run
  25     lib_name: library or executable containing symbols
  26
  27     Below is an example of a small log file:
  28     5086e000-52e92000 r-xp 00000000 b3:02 51276      libchromeview.so
  29     secs       usecs      pid:threadid    func
  30     START
  31     1314897086 795828     3587:1074648168 0x509e105c
  32     1314897086 795874     3587:1074648168 0x509e0eb4
  33     1314897086 796326     3587:1074648168 0x509e0e3c
  34     1314897086 796552     3587:1074648168 0x509e07bc
  35     END
  36
  37   Returns:
  38     call_info list with list of tuples of the format (sec, usec, call id,
  39     function address called)
  40   """
  41   call_lines = []
  42   has_started = False
  43   vm_start = 0
  44   line = log_file_lines[0]
  45   assert("r-xp" in line)
  46   end_index = line.find('-')
  47   vm_start = int(line[:end_index], 16)
  48   for line in log_file_lines[2:]:
  49   # print hex(vm_start)
  50     fields = line.split()
  51     if len(fields) == 4:
  52       call_lines.append(fields)
  53
  54   # Convert strings to int in fields.
  55   call_info = []
  56   for call_line in call_lines:
  57     (sec_timestamp, usec_timestamp) = map(int, call_line[0:2])
  58     callee_id = call_line[2]
  59     addr = int(call_line[3], 16)
  60     if vm_start < addr:
  61       addr -= vm_start
  62       call_info.append((sec_timestamp, usec_timestamp, callee_id, addr))
  63
  64   return call_info
  65
  66
  67 def ParseLibSymbols(lib_file):
  68   """Get output from running nm and greping for text symbols.
  69
  70   Args:
  71     lib_file: the library or executable that contains the profiled code
  72
  73   Returns:
  74     list of sorted unique addresses and corresponding size of function symbols
  75     in lib_file and map of addresses to all symbols at a particular address
  76   """
  77   cmd = ['nm', '-S', '-n', lib_file]
  78   nm_p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
  79   output = nm_p.communicate()[0]
  80   nm_lines = output.split('\n')
  81
  82   nm_symbols = []
  83   for nm_line in nm_lines:
  84     if any(str in nm_line for str in (' t ', ' W ', ' T ')):
  85       nm_symbols.append(nm_line)
  86
  87   nm_index = 0
  88   unique_addrs = []
  89   address_map = {}
  90   while nm_index < len(nm_symbols):
  91
  92     # If the length of the split line is not 4, then it does not contain all the
  93     # information needed to symbolize (i.e. address, size and symbol name).
  94     if len(nm_symbols[nm_index].split()) == 4:
  95       (addr, size) = [int(x, 16) for x in nm_symbols[nm_index].split()[0:2]]
  96
  97       # Multiple symbols may be at the same address.  This is do to aliasing
  98       # done by the compiler.  Since there is no way to be sure which one was
  99       # called in profiled run, we will symbolize to include all symbol names at
 100       # a particular address.
 101       fnames = []
 102       while (nm_index < len(nm_symbols) and
 103              addr == int(nm_symbols[nm_index].split()[0], 16)):
 104         if len(nm_symbols[nm_index].split()) == 4:
 105           fnames.append(nm_symbols[nm_index].split()[3])
 106         nm_index += 1
 107       address_map[addr] = fnames
 108       unique_addrs.append((addr, size))
 109     else:
 110       nm_index += 1
 111
 112   return (unique_addrs, address_map)
 113
 114 class SymbolNotFoundException(Exception):
 115   def __init__(self,value):
 116     self.value = value
 117   def __str__(self):
 118     return repr(self.value)
 119
 120 def BinarySearchAddresses(addr, start, end, arr):
 121   """Find starting address of a symbol at a particular address.
 122
 123   The reason we can not directly use the address provided by the log file is
 124   that the log file may give an address after the start of the symbol.  The
 125   logged address is often one byte after the start.  By using this search
 126   function rather than just subtracting one from the logged address allows
 127   the logging instrumentation to log any address in a function.
 128
 129   Args:
 130     addr: the address being searched for
 131     start: the starting index for the binary search
 132     end: the ending index for the binary search
 133     arr: the list being searched containing tuple of address and size
 134
 135   Returns:
 136     the starting address of the symbol at address addr
 137
 138   Raises:
 139     Exception: if address not found.  Functions expects all logged addresses
 140     to be found
 141   """
 142   # print "addr: " + str(addr) + " start: " + str(start) + " end: " + str(end)
 143   if start >= end or start == end - 1:
 144     # arr[i] is a tuple of address and size.  Check if addr inside range
 145     if addr >= arr[start][0] and addr < arr[start][0] + arr[start][1]:
 146       return arr[start][0]
 147     elif addr >= arr[end][0] and addr < arr[end][0] + arr[end][1]:
 148       return arr[end][0]
 149     else:
 150       raise SymbolNotFoundException(addr)
 151   else:
 152     halfway = (start + end) / 2
 153     (nm_addr, size) = arr[halfway]
 154     # print "nm_addr: " + str(nm_addr) + " halfway: " + str(halfway)
 155     if addr >= nm_addr and addr < nm_addr + size:
 156       return nm_addr
 157     elif addr < nm_addr:
 158       return BinarySearchAddresses(addr, start, halfway-1, arr)
 159     else:
 160       # Condition (addr >= nm_addr + size) must be true.
 161       return BinarySearchAddresses(addr, halfway+1, end, arr)
 162
 163
 164 def FindFunctions(addr, unique_addrs, address_map):
 165   """Find function symbol names at address addr."""
 166   return address_map[BinarySearchAddresses(addr, 0, len(unique_addrs) - 1,
 167                                            unique_addrs)]
 168
 169
 170 def AddrToLine(addr, lib_file):
 171   """Use addr2line to determine line info of a particular address."""
 172   cmd = ['addr2line', '-f', '-e', lib_file, hex(addr)]
 173   p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 174   output = (p.communicate()[0]).split('\n')
 175   line = output[0]
 176   index = 1
 177   while index < len(output):
 178     line = line + ':' + output[index]
 179     index += 1
 180   return line
 181
 182
 183 def main():
 184   """Write output for profiled run to standard out.
 185
 186   The format of the output depends on the output type specified as the third
 187   command line argument.  The default output type is to symbolize the addresses
 188   of the functions called.
 189   """
 190   parser = optparse.OptionParser('usage: %prog [options] log_file lib_file')
 191   parser.add_option('-t', '--outputType', dest='output_type',
 192                     default='symbolize', type='string',
 193                     help='lineize or symbolize or orderfile')
 194
 195   # Option for output type.  The log file and lib file arguments are required
 196   # by the script and therefore are not options.
 197   (options, args) = parser.parse_args()
 198   if len(args) != 2:
 199     parser.error('expected 2 args: log_file lib_file')
 200
 201   (log_file, lib_file) = args
 202   output_type = options.output_type
 203
 204   lib_name = lib_file.split('/')[-1].strip()
 205   log_file_lines = map(string.rstrip, open(log_file).readlines())
 206   call_info = ParseLogLines(log_file_lines)
 207   (unique_addrs, address_map) = ParseLibSymbols(lib_file)
 208
 209   # Check for duplicate addresses in the log file, and print a warning if
 210   # duplicates are found. The instrumentation that produces the log file
 211   # should only print the first time a function is entered.
 212   addr_list = []
 213   for call in call_info:
 214     addr = call[3]
 215     if addr not in addr_list:
 216       addr_list.append(addr)
 217     else:
 218       print('WARNING: Address ' + hex(addr) + ' (line= ' +
 219             AddrToLine(addr, lib_file) + ') already profiled.')
 220
 221   for call in call_info:
 222     if output_type == 'lineize':
 223       symbol = AddrToLine(call[3], lib_file)
 224       print(str(call[0]) + ' ' + str(call[1]) + '\t' + str(call[2]) + '\t'
 225             + symbol)
 226     elif output_type == 'orderfile':
 227       try:
 228         symbols = FindFunctions(call[3], unique_addrs, address_map)
 229         for symbol in symbols:
 230           print '.text.' + symbol
 231         print ''
 232       except SymbolNotFoundException as e:
 233         sys.stderr.write('WARNING: Did not find function in binary. addr: '
 234                       + hex(addr) + '\n')
 235     else:
 236       try:
 237         symbols = FindFunctions(call[3], unique_addrs, address_map)
 238         print(str(call[0]) + ' ' + str(call[1]) + '\t' + str(call[2]) + '\t'
 239               + symbols[0])
 240         first_symbol = True
 241         for symbol in symbols:
 242           if not first_symbol:
 243             print '\t\t\t\t\t' + symbol
 244           else:
 245             first_symbol = False
 246       except SymbolNotFoundException as e:
 247         sys.stderr.write('WARNING: Did not find function in binary. addr: '
 248                       + hex(addr) + '\n')
 249
 250 if __name__ == '__main__':
 251   main()