TickProcessor: more accurate mapping of statically compiled code on Linux.

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 156 matching lines @@
 
 TickProcessor.prototype.processLogFile = function(fileName) {
   this.lastLogFileName_ = fileName;
   var contents = readFile(fileName);
   this.processLogChunk(contents);
 };
 
 
 TickProcessor.prototype.processSharedLibrary = function(
     name, startAddr, endAddr) {
-  var entry = this.profile_.addStaticCode(name, startAddr, endAddr);
+  var entry = this.profile_.addLibrary(name, startAddr, endAddr);
   this.setCodeType(entry.getName(), 'SHARED_LIB');
 
   var self = this;
   var libFuncs = this.cppEntriesProvider_.parseVmSymbols(
       name, startAddr, endAddr, function(fName, fStart, fEnd) {
     self.profile_.addStaticCode(fName, fStart, fEnd);
     self.setCodeType(fName, 'CPP');
   });
 };
 
@@ skipping 185 matching lines @@
 function CppEntriesProvider() {
 };
 
 
 CppEntriesProvider.prototype.parseVmSymbols = function(
     libName, libStart, libEnd, processorFunc) {
   this.loadSymbols(libName);
 
   var prevEntry;
 
-  function addPrevEntry(end) {
+  function addEntry(funcInfo) {
     // Several functions can be mapped onto the same address. To avoid
     // creating zero-sized entries, skip such duplicates.
     // Also double-check that function belongs to the library address space.
-    if (prevEntry && prevEntry.start < end &&
-        prevEntry.start >= libStart && end <= libEnd) {
-      processorFunc(prevEntry.name, prevEntry.start, end);
+    if (prevEntry && !('end' in prevEntry) &&

[Kasper Lund, 2009/07/14 07:52:57]

The 'end' in prevEntry stuff looks a bit weird to me. I think it would be more
common just to use prevEntry.end, unless you worry about it being zero.

[Mikhail Naganov, 2009/07/14 09:45:47]

You're right, zero is a forbidden value here. Changed to value check.

+        prevEntry.start < funcInfo.start &&
+        prevEntry.start >= libStart && funcInfo.start <= libEnd) {
+      processorFunc(prevEntry.name, prevEntry.start, funcInfo.start);
     }
+    if ('end' in funcInfo &&
+        (!prevEntry || prevEntry.start != funcInfo.start) &&
+        funcInfo.start >= libStart && funcInfo.end <= libEnd) {
+      processorFunc(funcInfo.name, funcInfo.start, funcInfo.end);
+    }
+    prevEntry = 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;
+    if ('size' in funcInfo) {

[Kasper Lund, 2009/07/14 07:52:57]

Is this because you worry that size can be zero?

[Mikhail Naganov, 2009/07/14 09:45:47]

Done.

+      funcInfo.end = funcInfo.start + funcInfo.size;
+    }
+    addEntry(funcInfo);
   }
-  addPrevEntry(libEnd);
+  addEntry({name: '', start: libEnd});
 };
 
 
 CppEntriesProvider.prototype.loadSymbols = function(libName) {
 };
 
 
 CppEntriesProvider.prototype.parseNextLine = function() {
   return false;
 };
 
 
 function UnixCppEntriesProvider(nmExec) {
   this.symbols = [];
   this.parsePos = 0;
   this.nmExec = nmExec;
 };
 inherits(UnixCppEntriesProvider, CppEntriesProvider);
 
 
-UnixCppEntriesProvider.FUNC_RE = /^([0-9a-fA-F]{8}) [tTwW] (.*)$/;
+UnixCppEntriesProvider.FUNC_RE =
+    /^([0-9a-fA-F]{8}) ([0-9a-fA-F]{8} )?[tTwW] (.*)$/;
 
 
 UnixCppEntriesProvider.prototype.loadSymbols = function(libName) {
   this.parsePos = 0;
   try {
     this.symbols = [
-      os.system(this.nmExec, ['-C', '-n', libName], -1, -1),
-      os.system(this.nmExec, ['-C', '-n', '-D', libName], -1, -1)
+      os.system(this.nmExec, ['-C', '-n', '-S', libName], -1, -1),
+      os.system(this.nmExec, ['-C', '-n', '-S', '-D', libName], -1, -1)
     ];
   } catch (e) {
     // If the library cannot be found on this system let's not panic.
     this.symbols = ['', ''];
   }
 };
 
 
 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;
+  var funcInfo = null;
+  if (fields) {
+    funcInfo = { name: fields[3], start: parseInt(fields[1], 16) };
+    if (fields[2]) {
+      funcInfo.size = parseInt(fields[2], 16);
+    }
+  }
+  return funcInfo;
 };
 
 
 function WindowsCppEntriesProvider() {
   this.symbols = '';
   this.parsePos = 0;
 };
 inherits(WindowsCppEntriesProvider, CppEntriesProvider);
 
 
@@ skipping 144 matching lines @@
       if (arg !== synArg && dispatch === this.argsDispatch_[synArg]) {
         synonims.push(synArg);
         delete this.argsDispatch_[synArg];
       }
     }
     print('  ' + padRight(synonims.join(', '), 20) + dispatch[2]);
   }
   quit(2);
 };