Fix issue 553: function frame is skipped in profile when compare stub is called.

tools/tickprocessor.py

 # Copyright 2008 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 41 matching lines @@
 
   def ToString(self):
     return self.name
 
   def IsSharedLibraryEntry(self):
     return False
 
   def IsICEntry(self):
     return False
 
+  def IsJSFunction(self):
+    return False
 
 class SharedLibraryEntry(CodeEntry):
 
   def __init__(self, start_addr, name):
     CodeEntry.__init__(self, start_addr, name)
 
   def IsSharedLibraryEntry(self):
     return True
 
 
@@ skipping 45 matching lines @@
     if name == '':
       name = '<anonymous>'
     elif name.startswith(' '):
       name = '<anonymous>' + name
     return self.type + ': ' + name
 
   def IsICEntry(self):
     return self.type in ('CallIC', 'LoadIC', 'StoreIC') or \
       (self.type == 'Builtin' and self.builtin_ic_re.match(self.name))
 
+  def IsJSFunction(self):
+    return self.type in ('Function', 'LazyCompile', 'Script')
 
 class CodeRegion(object):
 
   def __init__(self, start_offset, name):
     self.start_offset = start_offset
     self.name = name
     self.end_offset = None
 
   def Contains(self, pc):
     return (self.start_offset <= pc) and (pc <= self.end_offset)
@@ skipping 68 matching lines @@
       logfile = open(filename, 'rb')
     except IOError:
       sys.exit("Could not open logfile: " + filename)
     try:
       try:
         logreader = csv.reader(logfile)
         row_num = 1
         for row in logreader:
           row_num += 1
           if row[0] == 'tick':
-            self.ProcessTick(int(row[1], 16), int(row[2], 16), int(row[3]), self.PreprocessStack(row[4:]))
+            self.ProcessTick(int(row[1], 16), int(row[2], 16), int(row[3], 16), int(row[4]), self.PreprocessStack(row[5:]))
           elif row[0] == 'code-creation':
             self.ProcessCodeCreation(row[1], int(row[2], 16), int(row[3]), row[4])
           elif row[0] == 'code-move':
             self.ProcessCodeMove(int(row[1], 16), int(row[2], 16))
           elif row[0] == 'code-delete':
             self.ProcessCodeDelete(int(row[1], 16))
+          elif row[0] == 'function-creation':
+            self.ProcessFunctionCreation(int(row[1], 16), int(row[2], 16))
+          elif row[0] == 'function-move':
+            self.ProcessFunctionMove(int(row[1], 16), int(row[2], 16))
+          elif row[0] == 'function-delete':
+            self.ProcessFunctionDelete(int(row[1], 16))
           elif row[0] == 'shared-library':
             self.AddSharedLibraryEntry(row[1], int(row[2], 16), int(row[3], 16))
             self.ParseVMSymbols(row[1], int(row[2], 16), int(row[3], 16))
           elif row[0] == 'begin-code-region':
             self.ProcessBeginCodeRegion(int(row[1], 16), int(row[2], 16), int(row[3], 16), row[4])
           elif row[0] == 'end-code-region':
             self.ProcessEndCodeRegion(int(row[1], 16), int(row[2], 16), int(row[3], 16))
           elif row[0] == 'code-allocate':
             self.ProcessCodeAllocate(int(row[1], 16), int(row[2], 16))
       except csv.Error:
@@ skipping 36 matching lines @@
     except splaytree.KeyNotFoundError:
       print('Code move event for unknown code: 0x%x' % from_addr)
 
   def ProcessCodeDelete(self, from_addr):
     try:
       removed_node = self.js_entries.Remove(from_addr)
       self.deleted_code.append(removed_node.value)
     except splaytree.KeyNotFoundError:
       print('Code delete event for unknown code: 0x%x' % from_addr)
 
+  def ProcessFunctionCreation(self, func_addr, code_addr):
+    js_entry_node = self.js_entries.Find(code_addr)
+    if js_entry_node:
+      js_entry = js_entry_node.value
+      self.js_entries.Insert(func_addr, JSCodeEntry(func_addr, js_entry.name, js_entry.type, 1, None))
+
+  def ProcessFunctionMove(self, from_addr, to_addr):
+    try:
+      removed_node = self.js_entries.Remove(from_addr)
+      removed_node.value.SetStartAddress(to_addr);
+      self.js_entries.Insert(to_addr, removed_node.value)
+    except splaytree.KeyNotFoundError:
+      return
+
+  def ProcessFunctionDelete(self, from_addr):
+    try:
+      removed_node = self.js_entries.Remove(from_addr)
+      self.deleted_code.append(removed_node.value)
+    except splaytree.KeyNotFoundError:
+      return
+
   def ProcessBeginCodeRegion(self, id, assm, start, name):
     if not assm in self.pending_assemblers:
       self.pending_assemblers[assm] = Assembler()
     assembler = self.pending_assemblers[assm]
     assembler.pending_regions[id] = CodeRegion(start, name)
 
   def ProcessEndCodeRegion(self, id, assm, end):
     assm = self.pending_assemblers[assm]
     region = assm.pending_regions.pop(id)
     region.end_offset = end
@@ skipping 25 matching lines @@
     return result
 
   def ProcessStack(self, stack):
     result = []
     for frame in stack:
       entry = self.FindEntry(frame)
       if entry != None:
         result.append(entry.ToString())
     return result
 
-  def ProcessTick(self, pc, sp, state, stack):
+  def ProcessTick(self, pc, sp, func, state, stack):
     if state == VMStates['GC']:
       self.number_of_gc_ticks += 1
     if not self.IncludeTick(pc, sp, state):
       self.excluded_number_of_ticks += 1;
       return
     self.total_number_of_ticks += 1
     entry = self.FindEntry(pc)
     if entry == None:
       self.unaccounted_number_of_ticks += 1
       return
     if entry.IsSharedLibraryEntry():
       self.number_of_library_ticks += 1
     if entry.IsICEntry() and not self.separate_ic:
       if len(stack) > 0:
         caller_pc = stack.pop(0)
         self.total_number_of_ticks -= 1
-        self.ProcessTick(caller_pc, sp, state, stack)
+        self.ProcessTick(caller_pc, sp, func, state, stack)
       else:
         self.unaccounted_number_of_ticks += 1
     else:
-      entry.Tick(pc, self.ProcessStack(stack))
+      processed_stack = self.ProcessStack(stack)
+      if not entry.IsSharedLibraryEntry() and not entry.IsJSFunction():
+        func_entry_node = self.js_entries.Find(func)
+        if func_entry_node and func_entry_node.value.IsJSFunction():
+          processed_stack.insert(0, func_entry_node.value.ToString())
+      entry.Tick(pc, processed_stack)
       if self.call_graph_json:
         self.AddToPackedStacks(pc, stack)
 
   def AddToPackedStacks(self, pc, stack):
     full_stack = stack
     full_stack.insert(0, pc)
     func_names = self.ProcessStack(full_stack)
     func_ids = []
     for func in func_names:
       func_ids.append(self.func_enum.GetFunctionId(func))
@@ skipping 171 matching lines @@
     })
     sys.exit(2)
 
   def RunLogfileProcessing(self, tick_processor):
     tick_processor.ProcessLogfile(self.log_file, self.state, self.ignore_unknown,
                                   self.separate_ic, self.call_graph_json)
 
 
 if __name__ == '__main__':
   sys.exit('You probably want to run windows-tick-processor.py or linux-tick-processor.py.')