Eliminate the need for code delete events in CPU profiler.

test/cctest/log-eq-of-logging-and-traversal.js

 // Copyright 2011 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 25 matching lines @@
   throw new Error("unknown code state: " + s);
 }
 
 function LogProcessor() {
   LogReader.call(this, {
       'code-creation': {
           parsers: [null, parseInt, parseInt, null, 'var-args'],
           processor: this.processCodeCreation },
       'code-move': { parsers: [parseInt, parseInt],
           processor: this.processCodeMove },
-      'code-delete': { parsers: [parseInt],
-          processor: this.processCodeDelete },
+      'code-delete': null,
       'sfi-move': { parsers: [parseInt, parseInt],
           processor: this.processFunctionMove },
       'shared-library': null,
       'profiler': null,
       'tick': null });
   this.profile = new Profile();
 
 }
 LogProcessor.prototype.__proto__ = LogReader.prototype;
 
 LogProcessor.prototype.processCodeCreation = function(
     type, start, size, name, maybe_func) {
   if (type != "LazyCompile" && type != "Script" && type != "Function") return;
   // Discard types to avoid discrepancies in "LazyCompile" vs. "Function".
   type = "";
   if (maybe_func.length) {
     var funcAddr = parseInt(maybe_func[0]);
     var state = parseState(maybe_func[1]);
     this.profile.addFuncCode(type, name, start, size, funcAddr, state);
   } else {
     this.profile.addCode(type, name, start, size);
   }
 };
 
 LogProcessor.prototype.processCodeMove = function(from, to) {
   this.profile.moveCode(from, to);
 };
 
-LogProcessor.prototype.processCodeDelete = function(start) {
-  this.profile.deleteCode(start);
-};
-
 LogProcessor.prototype.processFunctionMove = function(from, to) {
   this.profile.moveFunc(from, to);
 };
 
 function RunTest() {
   // _log must be provided externally.
   var log_lines = _log.split("\n");
   var line, pos = 0, log_lines_length = log_lines.length;
   if (log_lines_length < 2)
     return "log_lines_length < 2";
@@ skipping 35 matching lines @@
       return true;
     }
     if (entityNamesEqual.builtins.indexOf(entityB.getName()) !== -1) return true;
     return entityA.getName() === entityB.getName();
   }
   entityNamesEqual.builtins =
     ["Boolean", "Function", "Number", "Object",
      "Script", "String", "RegExp", "Date", "Error"];
 
   function entitiesEqual(entityA, entityB) {
-    if (entityA === null && entityB !== null) return true;
-    if (entityA !== null && entityB === null) return false;
+    if ((entityA === null && entityB !== null) ||
+      (entityA !== null && entityB === null)) return true;
     return entityA.size === entityB.size && entityNamesEqual(entityA, entityB);
   }
 
   var l_pos = 0, t_pos = 0;
   var l_len = logging_entries.length, t_len = traversal_entries.length;
   var comparison = [];
   var equal = true;
   // Do a merge-like comparison of entries. At the same address we expect to
   // find the same entries. We skip builtins during log parsing, but compiled
   // functions traversal may erroneously recognize them as functions, so we are
   // expecting more functions in traversal vs. logging.
+  // Since we don't track code deletions, logging can also report more entries
+  // than traversal.
   while (l_pos < l_len && t_pos < t_len) {
     var entryA = logging_entries[l_pos];
     var entryB = traversal_entries[t_pos];
     var cmp = addressComparator(entryA, entryB);
     var entityA = entryA[1], entityB = entryB[1];
     var address = entryA[0];
     if (cmp < 0) {
       ++l_pos;
       entityB = null;
     } else if (cmp > 0) {
       ++t_pos;
       entityA = null;
       address = entryB[0];
     } else {
       ++l_pos;
       ++t_pos;
     }
     var entities_equal = entitiesEqual(entityA, entityB);
     if (!entities_equal) equal = false;
     comparison.push([entities_equal, address, entityA, entityB]);
   }
-  if (l_pos < l_len) equal = false;
-  while (l_pos < l_len) {
-    var entryA = logging_entries[l_pos++];
-    comparison.push([false, entryA[0], entryA[1], null]);
-  }
   return [equal, comparison];
 }
 
 var result = RunTest();
 if (typeof result !== "string") {
   var out = [];
   if (!result[0]) {
     var comparison = result[1];
     for (var i = 0, l = comparison.length; i < l; ++i) {
       var c = comparison[i];
       out.push((c[0] ? "  " : "* ") +
                c[1].toString(16) + " " +
                (c[2] ? c[2] : "---") + " " +
                (c[3] ? c[3] : "---"));
     }
   }
   result[0] ? true : out.join("\n");
 } else {
   result;
 }