Merge bleeding edge up to 8774 into the GC branch.

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 144 matching lines @@
   // As code and functions are in the same address space,
   // it is safe to put them in a single code map.
   var func = this.codeMap_.findDynamicEntryByStartAddress(funcAddr);
   if (!func) {
     func = new Profile.FunctionEntry(name);
     this.codeMap_.addCode(funcAddr, func);
   } else if (func.name !== name) {
     // Function object has been overwritten with a new one.
     func.name = name;
   }
-  var entry = new Profile.DynamicFuncCodeEntry(size, type, func, state);
-  this.codeMap_.addCode(start, entry);
+  var entry = this.codeMap_.findDynamicEntryByStartAddress(start);
+  if (entry) {
+    if (entry.size === size && entry.func === func) {
+      // Entry state has changed.
+      entry.state = state;
+    }
+  } else {
+    entry = new Profile.DynamicFuncCodeEntry(size, type, func, state);
+    this.codeMap_.addCode(start, entry);
+  }
   return entry;
 };
 
 
 /**
  * Reports about moving of a dynamic code entry.
  *
  * @param {number} from Current code entry address.
  * @param {number} to New code entry address.
  */
@@ skipping 190 matching lines @@
   } else {
     // Propagate weights so percents can be calculated correctly.
     counters.getRoot().selfWeight = root.selfWeight;
     counters.getRoot().totalWeight = root.totalWeight;
   }
   return counters;
 };
 
 
 /**
+ * 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;
+    }
+  }
+  for (var i = 0, l = entries.length; i < l; ++i) {
+    if ("func" in entries[i][1]) {
+      entries[i][1].func.used = true;
+    }
+  }
+  for (var i = 0, l = entries.length; i < l; ++i) {
+    if (entries[i][1].constructor === Profile.FunctionEntry &&
+        !entries[i][1].used) {
+      this.codeMap_.deleteCode(entries[i][0]);
+    }
+  }
+};
+
+
+/**
  * 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;
@@ skipping 14 matching lines @@
 Profile.DynamicCodeEntry.prototype.getRawName = function() {
   return this.name;
 };
 
 
 Profile.DynamicCodeEntry.prototype.isJSFunction = function() {
   return false;
 };
 
 
+Profile.DynamicCodeEntry.prototype.toString = function() {
+  return this.getName() + ': ' + this.size.toString(16);
+};
+
+
 /**
  * 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) {
@@ skipping 20 matching lines @@
 Profile.DynamicFuncCodeEntry.prototype.getRawName = function() {
   return this.func.getName();
 };
 
 
 Profile.DynamicFuncCodeEntry.prototype.isJSFunction = function() {
   return true;
 };
 
 
+Profile.DynamicFuncCodeEntry.prototype.toString = function() {
+  return this.getName() + ': ' + this.size.toString(16);
+};
+
+
 /**
  * Creates a shared function object entry.
  *
  * @param {string} name Function name.
  * @constructor
  */
 Profile.FunctionEntry = function(name) {
   CodeMap.CodeEntry.call(this, 0, name);
 };
 
 
 /**
  * Returns node name.
  */
 Profile.FunctionEntry.prototype.getName = function() {
   var name = this.name;
   if (name.length == 0) {
     name = '<anonymous>';
   } else if (name.charAt(0) == ' ') {
     // An anonymous function with location: " aaa.js:10".
     name = '<anonymous>' + name;
   }
   return name;
 };
 
+Profile.FunctionEntry.prototype.toString = CodeMap.CodeEntry.prototype.toString;
 
 /**
  * Constructs a call graph.
  *
  * @constructor
  */
 function CallTree() {
   this.root_ = new CallTree.Node(
       CallTree.ROOT_NODE_LABEL);
 };
@@ skipping 256 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;
 };