Tick processor: Print C++ entry points

tools/profile.js

 // Copyright 2009 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 18 matching lines @@
 /**
  * Creates a profile object for processing profiling-related events
  * and calculating function execution times.
  *
  * @constructor
  */
 function Profile() {
   this.codeMap_ = new CodeMap();
   this.topDownTree_ = new CallTree();
   this.bottomUpTree_ = new CallTree();
+  this.c_entries_ = {};
 };
 
 
 /**
  * Returns whether a function with the specified name must be skipped.
  * Should be overriden by subclasses.
  *
  * @param {string} name Function name.
  */
 Profile.prototype.skipThisFunction = function(name) {
@@ skipping 46 matching lines @@
 /**
  * Registers a library.
  *
  * @param {string} name Code entry name.
  * @param {number} startAddr Starting address.
  * @param {number} endAddr Ending address.
  */
 Profile.prototype.addLibrary = function(
     name, startAddr, endAddr) {
   var entry = new CodeMap.CodeEntry(
-      endAddr - startAddr, name);
+      endAddr - startAddr, name, 'SHARED_LIB');
   this.codeMap_.addLibrary(startAddr, entry);
   return entry;
 };
 
 
 /**
  * Registers statically compiled code entry.
  *
  * @param {string} name Code entry name.
  * @param {number} startAddr Starting address.
  * @param {number} endAddr Ending address.
  */
 Profile.prototype.addStaticCode = function(
     name, startAddr, endAddr) {
   var entry = new CodeMap.CodeEntry(
-      endAddr - startAddr, name);
+      endAddr - startAddr, name, 'CPP');
   this.codeMap_.addStaticCode(startAddr, entry);
   return entry;
 };
 
 
 /**
  * Registers dynamic (JIT-compiled) code entry.
  *
  * @param {string} type Code entry type.
  * @param {string} name Code entry name.
@@ skipping 111 matching lines @@
 
 
 /**
  * Translates addresses into function names and filters unneeded
  * functions.
  *
  * @param {Array<number>} stack Stack sample.
  */
 Profile.prototype.resolveAndFilterFuncs_ = function(stack) {
   var result = [];
+  var last_seen_c_function = '';
+  var look_for_first_c_function = false;
   for (var i = 0; i < stack.length; ++i) {
     var entry = this.codeMap_.findEntry(stack[i]);
     if (entry) {
       var name = entry.getName();
+      if (i == 0 && (entry.type == 'CPP' || entry.type == 'SHARED_LIB')) {
+        look_for_first_c_function = true;
+      }
+      if (look_for_first_c_function) {
+        if (entry.type == 'CPP') {
+          last_seen_c_function = name;
+        } else if (i > 0 && last_seen_c_function != '') {
+          if (this.c_entries_[last_seen_c_function] === undefined) {
+            this.c_entries_[last_seen_c_function] = 0;
+          }
+          this.c_entries_[last_seen_c_function]++;
+          look_for_first_c_function = false;  // Found it, we're done.
+        }
+      }
       if (!this.skipThisFunction(name)) {
         result.push(name);
       }
     } else {
       this.handleUnknownCode(
           Profile.Operation.TICK, stack[i], i);
     }
   }
   return result;
 };
@@ skipping 107 matching lines @@
     counters.root_ = root;
   } else {
     // Propagate weights so percents can be calculated correctly.
     counters.getRoot().selfWeight = root.selfWeight;
     counters.getRoot().totalWeight = root.totalWeight;
   }
   return counters;
 };
 
 
+Profile.CEntryNode = function(name, ticks) {
+  this.name = name;
+  this.ticks = ticks;
+}
+
+
+Profile.prototype.getCEntryProfile = function() {
+  var result = [new Profile.CEntryNode("TOTAL", 0)];
+  var total_ticks = 0;
+  for (var f in this.c_entries_) {
+    var ticks = this.c_entries_[f];
+    total_ticks += ticks;
+    result.push(new Profile.CEntryNode(f, ticks));
+  }
+  result[0].ticks = total_ticks;  // Sorting will keep this at index 0.
+  result.sort(function(n1, n2) {
+    return n2.ticks - n1.ticks || (n2.name < n1.name ? -1 : 1)
+  });
+  return result;
+}
+
+
 /**
  * Cleans up function entries that are not referenced by code entries.
  */
 Profile.prototype.cleanUpFuncEntries = function() {
   var referencedFuncEntries = [];
   var entries = this.codeMap_.getAllDynamicEntriesWithAddresses();
   for (var i = 0, l = entries.length; i < l; ++i) {
     if (entries[i][1].constructor === Profile.FunctionEntry) {
       entries[i][1].used = false;
     }
@@ skipping 14 matching lines @@
 
 /**
  * Creates a dynamic code entry.
  *
  * @param {number} size Code size.
  * @param {string} type Code type.
  * @param {string} name Function name.
  * @constructor
  */
 Profile.DynamicCodeEntry = function(size, type, name) {
-  CodeMap.CodeEntry.call(this, size, name);
-  this.type = type;
+  CodeMap.CodeEntry.call(this, size, name, type);
 };
 
 
 /**
  * Returns node name.
  */
 Profile.DynamicCodeEntry.prototype.getName = function() {
   return this.type + ': ' + this.name;
 };
 
@@ skipping 19 matching lines @@
 /**
  * Creates a dynamic code entry.
  *
  * @param {number} size Code size.
  * @param {string} type Code type.
  * @param {Profile.FunctionEntry} func Shared function entry.
  * @param {Profile.CodeState} state Code optimization state.
  * @constructor
  */
 Profile.DynamicFuncCodeEntry = function(size, type, func, state) {
-  CodeMap.CodeEntry.call(this, size);
-  this.type = type;
+  CodeMap.CodeEntry.call(this, size, '', type);
   this.func = func;
   this.state = state;
 };
 
 Profile.DynamicFuncCodeEntry.STATE_PREFIX = ["", "~", "*"];
 
 /**
  * Returns node name.
  */
 Profile.DynamicFuncCodeEntry.prototype.getName = function() {
@@ skipping 315 matching lines @@
     labels, opt_f) {
   for (var pos = 0, curr = this; pos < labels.length && curr != null; pos++) {
     var child = curr.findChild(labels[pos]);
     if (opt_f) {
       opt_f(child, pos);
     }
     curr = child;
   }
   return curr;
 };