Breakdown memory usage by source file names in dmprof.

tools/find_runtime_symbols/static_symbols.py

 # Copyright (c) 2012 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 bisect
 import re
 
 
 _ARGUMENT_TYPE_PATTERN = re.compile('\([^()]*\)(\s*const)?')
 _TEMPLATE_ARGUMENT_PATTERN = re.compile('<[^<>]*>')
@@ skipping 15 matching lines @@
 
   def append(self, start, entry):
     self._symbol_map[start] = entry
 
   def find(self, address):
     return self._symbol_map.get(address)
 
 
 class RangeAddressMapping(AddressMapping):
   def __init__(self):
-    AddressMapping.__init__(self)
+    super(RangeAddressMapping, self).__init__()
     self._sorted_start_list = []
     self._is_sorted = True
 
   def append(self, start, entry):
     if self._sorted_start_list:
       if self._sorted_start_list[-1] > start:
         self._is_sorted = False
       elif self._sorted_start_list[-1] == start:
         return
     self._sorted_start_list.append(start)
     self._symbol_map[start] = entry
 
   def find(self, address):
+    if not self._sorted_start_list:
+      return None
     if not self._is_sorted:
       self._sorted_start_list.sort()
       self._is_sorted = True
     found_index = bisect.bisect_left(self._sorted_start_list, address)
     found_start_address = self._sorted_start_list[found_index - 1]
     return self._symbol_map[found_start_address]
 
 
 class Procedure(object):
   """A class for a procedure symbol and an address range for the symbol."""
@@ skipping 52 matching lines @@
     return '%x+%x(%x) %s' % (self.address, self.size, self.offset, self.name)
 
 
 class StaticSymbolsInFile(object):
   """Represents static symbol information in a binary file."""
 
   def __init__(self, my_name):
     self.my_name = my_name
     self._elf_sections = []
     self._procedures = RangeAddressMapping()
+    self._sourcefiles = RangeAddressMapping()
     self._typeinfos = AddressMapping()
 
   def _append_elf_section(self, elf_section):
     self._elf_sections.append(elf_section)
 
   def _append_procedure(self, start, procedure):
     self._procedures.append(start, procedure)
 
+  def _append_sourcefile(self, start, sourcefile):
+    self._sourcefiles.append(start, sourcefile)
+
   def _append_typeinfo(self, start, typeinfo):
     self._typeinfos.append(start, typeinfo)
 
   def _find_symbol_by_runtime_address(self, address, vma, target):
     if not (vma.begin <= address < vma.end):
       return None
 
     if vma.name != self.my_name:
       return None
 
     file_offset = address - (vma.begin - vma.offset)
     elf_address = None
     for section in self._elf_sections:
       if section.offset <= file_offset < (section.offset + section.size):
         elf_address = section.address + file_offset - section.offset
     if not elf_address:
       return None
 
     return target.find(elf_address)
 
   def find_procedure_by_runtime_address(self, address, vma):
     return self._find_symbol_by_runtime_address(address, vma, self._procedures)
 
+  def find_sourcefile_by_runtime_address(self, address, vma):
+    return self._find_symbol_by_runtime_address(address, vma, self._sourcefiles)
+
   def find_typeinfo_by_runtime_address(self, address, vma):
     return self._find_symbol_by_runtime_address(address, vma, self._typeinfos)
 
   def load_readelf_ew(self, f):
     found_header = False
     for line in f:
       if line.rstrip() == 'Section Headers:':
         found_header = True
         break
     if not found_header:
@@ skipping 13 matching lines @@
             matched.group(7), # es
             matched.group(8), # flg
             matched.group(9), # lk
             matched.group(10), # inf
             matched.group(11) # al
             ))
       else:
         if line in ('Key to Flags:', 'Program Headers:'):
           break
 
+  def load_readelf_debug_decodedline_file(self, input_file):
+    for line in input_file:
+      splitted = line.rstrip().split(None, 2)
+      self._append_sourcefile(int(splitted[0], 16), splitted[1])
+
   @staticmethod
   def _parse_nm_bsd_line(line):
     if line[8] == ' ':
       return line[0:8], line[9], line[11:]
     elif line[16] == ' ':
       return line[0:16], line[17], line[19:]
     raise ParsingException('Invalid nm output.')
 
   @staticmethod
   def _get_short_function_name(function):
@@ skipping 58 matching lines @@
       self._append_procedure(
           last_start, Procedure(last_start, start_val, routine))
 
       last_start = start_val
       routine = sym_name
 
     if not mangled:
       routine = self._get_short_function_name(routine)
     self._append_procedure(
         last_start, Procedure(last_start, last_start, routine))