Don't keep data about JS code that is never executed, optimize static symbols loading

tools/tickprocessor.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 81 matching lines @@
 TickProcessor.VmStates = {
   JS: 0,
   GC: 1,
   COMPILER: 2,
   OTHER: 3,
   EXTERNAL: 4
 };
 
 
 TickProcessor.CodeTypes = {
-  JS: 0,
-  CPP: 1,
-  SHARED_LIB: 2
+  CPP: 0,
+  SHARED_LIB: 1
 };
+// Otherwise, this is JS-related code. We are not adding it to
+// codeTypes_ map because there can be zillions of them.
 
 
 TickProcessor.RecordsDispatch = {
   'shared-library': { parsers: [null, parseInt, parseInt],
                       processor: 'processSharedLibrary' },
   'code-creation': { parsers: [null, parseInt, parseInt, null],
                    processor: 'processCodeCreation' },
   'code-move': { parsers: [parseInt, parseInt],
                  processor: 'processCodeMove' },
   'code-delete': { parsers: [parseInt], processor: 'processCodeDelete' },
@@ skipping 19 matching lines @@
   return this.codeTypes_[name] == TickProcessor.CodeTypes.SHARED_LIB;
 };
 
 
 TickProcessor.prototype.isCppCode = function(name) {
   return this.codeTypes_[name] == TickProcessor.CodeTypes.CPP;
 };
 
 
 TickProcessor.prototype.isJsCode = function(name) {
-  return this.codeTypes_[name] == TickProcessor.CodeTypes.JS;
+  return !(name in this.codeTypes_);
 };
 
 
 TickProcessor.prototype.processLogFile = function(fileName) {
   this.lastLogFileName_ = fileName;
   var contents = readFile(fileName);
   this.processLog(contents.split('\n'));
 };
 
 
@@ skipping 57 matching lines @@
       name, startAddr, endAddr, function(fName, fStart, fEnd) {
     self.profile_.addStaticCode(fName, fStart, fEnd);
     self.setCodeType(fName, 'CPP');
   });
 };
 
 
 TickProcessor.prototype.processCodeCreation = function(
     type, start, size, name) {
   var entry = this.profile_.addCode(type, name, start, size);
-  this.setCodeType(entry.getName(), 'JS');
 };
 
 
 TickProcessor.prototype.processCodeMove = function(from, to) {
   this.profile_.moveCode(from, to);
 };
 
 
 TickProcessor.prototype.processCodeDelete = function(start) {
   this.profile_.deleteCode(start);
@@ skipping 174 matching lines @@
   });
 };
 
 
 function CppEntriesProvider() {
 };
 
 
 CppEntriesProvider.prototype.parseVmSymbols = function(
     libName, libStart, libEnd, processorFunc) {
-  var syms = this.loadSymbols(libName);
-  if (syms.length == 0) return;
+  this.loadSymbols(libName);
 
   var prevEntry;
 
   function addPrevEntry(end) {
     // Several functions can be mapped onto the same address. To avoid
     // creating zero-sized entries, skip such duplicates.
     if (prevEntry && prevEntry.start != end) {
       processorFunc(prevEntry.name, prevEntry.start, end);
     }
   }
 
-  for (var i = 0, n = syms.length; i < n; ++i) {
-    var line = syms[i];
-    var funcInfo = this.parseLine(line);
-    if (!funcInfo) {
+  while (true) {
+    var funcInfo = this.parseNextLine();
+    if (funcInfo === null) {
       continue;
+    } else if (funcInfo === false) {
+      break;
     }
     if (funcInfo.start < libStart && funcInfo.start < libEnd - libStart) {
       funcInfo.start += libStart;
     }
     addPrevEntry(funcInfo.start);
     prevEntry = funcInfo;
   }
   addPrevEntry(libEnd);
 };
 
 
 CppEntriesProvider.prototype.loadSymbols = function(libName) {
-  return [];
 };
 
 
-CppEntriesProvider.prototype.parseLine = function(line) {
-  return { name: '', start: 0 };
+CppEntriesProvider.prototype.parseNextLine = function() {
+  return false;
 };
 
 
 function inherits(childCtor, parentCtor) {
   function tempCtor() {};
   tempCtor.prototype = parentCtor.prototype;
   childCtor.prototype = new tempCtor();
 };
 
 
 function UnixCppEntriesProvider() {
+  this.symbols = [];
+  this.parsePos = 0;
 };
 inherits(UnixCppEntriesProvider, CppEntriesProvider);
 
 
 UnixCppEntriesProvider.FUNC_RE = /^([0-9a-fA-F]{8}) . (.*)$/;
 
 
 UnixCppEntriesProvider.prototype.loadSymbols = function(libName) {
-  var normalSyms = os.system('nm', ['-C', '-n', libName], -1, -1);
-  var dynaSyms = os.system('nm', ['-C', '-n', '-D', libName], -1, -1);
-  var syms = (normalSyms + dynaSyms).split('\n');
-  return syms;
+  this.symbols = [
+    os.system('nm', ['-C', '-n', libName], -1, -1),
+    os.system('nm', ['-C', '-n', '-D', libName], -1, -1)
+  ];
+  this.parsePos = 0;
 };
 
 
-UnixCppEntriesProvider.prototype.parseLine = function(line) {
+UnixCppEntriesProvider.prototype.parseNextLine = function() {
+  if (this.symbols.length == 0) {
+    return false;
+  }
+  var lineEndPos = this.symbols[0].indexOf('\n', this.parsePos);
+  if (lineEndPos == -1) {
+    this.symbols.shift();
+    this.parsePos = 0;
+    return this.parseNextLine();
+  }
+
+  var line = this.symbols[0].substring(this.parsePos, lineEndPos);
+  this.parsePos = lineEndPos + 1;
   var fields = line.match(UnixCppEntriesProvider.FUNC_RE);
   return fields ? { name: fields[2], start: parseInt(fields[1], 16) } : null;
 };
 
 
 function WindowsCppEntriesProvider() {
+  this.symbols = '';
+  this.parsePos = 0;
 };
 inherits(WindowsCppEntriesProvider, CppEntriesProvider);
 
 
 WindowsCppEntriesProvider.FILENAME_RE = /^(.*)\.exe$/;
 
 
 WindowsCppEntriesProvider.FUNC_RE =
     /^ 0001:[0-9a-fA-F]{8}\s+([_\?@$0-9a-zA-Z]+)\s+([0-9a-fA-F]{8}).*$/;
 
 
 WindowsCppEntriesProvider.prototype.loadSymbols = function(libName) {
   var fileNameFields = libName.match(WindowsCppEntriesProvider.FILENAME_RE);
   // Only try to load symbols for the .exe file.
-  if (!fileNameFields) return [];
+  if (!fileNameFields) return;
   var mapFileName = fileNameFields[1] + '.map';
-  return readFile(mapFileName).split('\r\n');
+  this.symbols = readFile(mapFileName);
 };
 
 
-WindowsCppEntriesProvider.prototype.parseLine = function(line) {
+WindowsCppEntriesProvider.prototype.parseNextLine = function() {
+  var lineEndPos = this.symbols.indexOf('\r\n', this.parsePos);
+  if (lineEndPos == -1) {
+    return false;
+  }
+
+  var line = this.symbols.substring(this.parsePos, lineEndPos);
+  this.parsePos = lineEndPos + 2;
   var fields = line.match(WindowsCppEntriesProvider.FUNC_RE);
   return fields ?
       { name: this.unmangleName(fields[1]), start: parseInt(fields[2], 16) } :
       null;
 };
 
 
 /**
  * Performs very simple unmangling of C++ names.
  *
@@ skipping 96 matching lines @@
 
 var params = processArguments(arguments);
 var tickProcessor = new TickProcessor(
     params.platform == 'unix' ? new UnixCppEntriesProvider() :
         new WindowsCppEntriesProvider(),
     params.separateIc,
     params.ignoreUnknown,
     params.stateFilter);
 tickProcessor.processLogFile(params.logFileName);
 tickProcessor.printStatistics();