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

test/mjsunit/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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Load implementations from <project root>/tools.
 // Files: tools/splaytree.js tools/codemap.js tools/csvparser.js
 // Files: tools/consarray.js tools/profile.js tools/profile_view.js
 // Files: tools/logreader.js tools/tickprocessor.js
 // Env: TEST_FILE_NAME
 
+
 (function testArgumentsProcessor() {
   var p_default = new ArgumentsProcessor([]);
   assertTrue(p_default.parse());
   assertEquals(ArgumentsProcessor.DEFAULTS, p_default.result());
 
   var p_logFile = new ArgumentsProcessor(['logfile.log']);
   assertTrue(p_logFile.parse());
   assertEquals('logfile.log', p_logFile.result().logFileName);
 
   var p_platformAndLog = new ArgumentsProcessor(['--windows', 'winlog.log']);
@@ skipping 18 matching lines @@
 
 (function testUnixCppEntriesProvider() {
   var oldLoadSymbols = UnixCppEntriesProvider.prototype.loadSymbols;
 
   // shell executable
   UnixCppEntriesProvider.prototype.loadSymbols = function(libName) {
     this.symbols = [[
       '         U operator delete[](void*)@@GLIBCXX_3.4',
       '08049790 T _init',
       '08049f50 T _start',
-      '08139150 t v8::internal::Runtime_StringReplaceRegExpWithString(v8::internal::Arguments)',
-      '08139ca0 T v8::internal::Runtime::GetElementOrCharAt(v8::internal::Handle<v8::internal::Object>, unsigned int)',
-      '0813a0b0 t v8::internal::Runtime_DebugGetPropertyDetails(v8::internal::Arguments)',
-      '08181d30 W v8::internal::RegExpMacroAssemblerIrregexp::stack_limit_slack()',
+      '08139150 00000b4b t v8::internal::Runtime_StringReplaceRegExpWithString(v8::internal::Arguments)',
+      '08139ca0 000003f1 T v8::internal::Runtime::GetElementOrCharAt(v8::internal::Handle<v8::internal::Object>, unsigned int)',
+      '0813a0b0 00000855 t v8::internal::Runtime_DebugGetPropertyDetails(v8::internal::Arguments)',
+      '0818b220 00000036 W v8::internal::RegExpMacroAssembler::CheckPosition(int, v8::internal::Label*)',
       '         w __gmon_start__',
-      '081f08a0 B stdout'
+      '081f08a0 00000004 B stdout'
     ].join('\n'), ''];
   };
 
   var shell_prov = new UnixCppEntriesProvider();
   var shell_syms = [];
   shell_prov.parseVmSymbols('shell', 0x08048000, 0x081ee000,
       function (name, start, end) {
         shell_syms.push(Array.prototype.slice.apply(arguments, [0]));
       });
   assertEquals(
       [['_init', 0x08049790, 0x08049f50],
        ['_start', 0x08049f50, 0x08139150],
-       ['v8::internal::Runtime_StringReplaceRegExpWithString(v8::internal::Arguments)', 0x08139150, 0x08139ca0],
-       ['v8::internal::Runtime::GetElementOrCharAt(v8::internal::Handle<v8::internal::Object>, unsigned int)', 0x08139ca0, 0x0813a0b0],
-       ['v8::internal::Runtime_DebugGetPropertyDetails(v8::internal::Arguments)', 0x0813a0b0, 0x08181d30],
-       ['v8::internal::RegExpMacroAssemblerIrregexp::stack_limit_slack()', 0x08181d30, 0x081ee000]],
+       ['v8::internal::Runtime_StringReplaceRegExpWithString(v8::internal::Arguments)', 0x08139150, 0x08139150 + 0xb4b],
+       ['v8::internal::Runtime::GetElementOrCharAt(v8::internal::Handle<v8::internal::Object>, unsigned int)', 0x08139ca0, 0x08139ca0 + 0x3f1],
+       ['v8::internal::Runtime_DebugGetPropertyDetails(v8::internal::Arguments)', 0x0813a0b0, 0x0813a0b0 + 0x855],
+       ['v8::internal::RegExpMacroAssembler::CheckPosition(int, v8::internal::Label*)', 0x0818b220, 0x0818b220 + 0x36]],
       shell_syms);
 
   // libc library
   UnixCppEntriesProvider.prototype.loadSymbols = function(libName) {
     this.symbols = [[
-        '000162a0 T __libc_init_first',
-        '0002a5f0 T __isnan',
-        '0002a5f0 W isnan',
-        '0002aaa0 W scalblnf',
-        '0002aaa0 W scalbnf',
-        '0011a340 T __libc_thread_freeres',
-        '00128860 R _itoa_lower_digits'].join('\n'), ''];
+        '000162a0 00000005 T __libc_init_first',
+        '0002a5f0 0000002d T __isnan',
+        '0002a5f0 0000002d W isnan',
+        '0002aaa0 0000000d W scalblnf',
+        '0002aaa0 0000000d W scalbnf',
+        '0011a340 00000048 T __libc_thread_freeres',
+        '00128860 00000024 R _itoa_lower_digits'].join('\n'), ''];
   };
   var libc_prov = new UnixCppEntriesProvider();
   var libc_syms = [];
   libc_prov.parseVmSymbols('libc', 0xf7c5c000, 0xf7da5000,
       function (name, start, end) {
         libc_syms.push(Array.prototype.slice.apply(arguments, [0]));
       });
-  assertEquals(
-      [['__libc_init_first', 0xf7c5c000 + 0x000162a0, 0xf7c5c000 + 0x0002a5f0],
-       ['isnan', 0xf7c5c000 + 0x0002a5f0, 0xf7c5c000 + 0x0002aaa0],
-       ['scalbnf', 0xf7c5c000 + 0x0002aaa0, 0xf7c5c000 + 0x0011a340],
-       ['__libc_thread_freeres', 0xf7c5c000 + 0x0011a340, 0xf7da5000]],
-      libc_syms);
+  var libc_ref_syms = [['__libc_init_first', 0x000162a0, 0x000162a0 + 0x5],
+       ['__isnan', 0x0002a5f0, 0x0002a5f0 + 0x2d],
+       ['scalblnf', 0x0002aaa0, 0x0002aaa0 + 0xd],
+       ['__libc_thread_freeres', 0x0011a340, 0x0011a340 + 0x48]];
+  for (var i = 0; i < libc_ref_syms.length; ++i) {
+    libc_ref_syms[i][1] += 0xf7c5c000;
+    libc_ref_syms[i][2] += 0xf7c5c000;
+  }
+  assertEquals(libc_ref_syms, libc_syms);
 
   UnixCppEntriesProvider.prototype.loadSymbols = oldLoadSymbols;
 })();
 
 
 (function testWindowsCppEntriesProvider() {
   var oldLoadSymbols = WindowsCppEntriesProvider.prototype.loadSymbols;
 
   WindowsCppEntriesProvider.prototype.loadSymbols = function(libName) {
     this.symbols = [
@@ skipping 38 matching lines @@
 
 
 CppEntriesProviderMock.prototype.parseVmSymbols = function(
     name, startAddr, endAddr, symbolAdder) {
   var symbols = {
     'shell':
         [['v8::internal::JSObject::LocalLookupRealNamedProperty(v8::internal::String*, v8::internal::LookupResult*)', 0x080f8800, 0x080f8d90],
          ['v8::internal::HashTable<v8::internal::StringDictionaryShape, v8::internal::String*>::FindEntry(v8::internal::String*)', 0x080f8210, 0x080f8800],
          ['v8::internal::Runtime_Math_exp(v8::internal::Arguments)', 0x08123b20, 0x08123b80]],
     '/lib32/libm-2.7.so':
-        [['exp', startAddr + 0x00009e80, startAddr + 0x00009f30],
-         ['fegetexcept', startAddr + 0x000061e0, startAddr + 0x00008b10]],
+        [['exp', startAddr + 0x00009e80, startAddr + 0x00009e80 + 0xa3],
+         ['fegetexcept', startAddr + 0x000061e0, startAddr + 0x000061e0 + 0x15]],
     'ffffe000-fffff000': []};
   assertTrue(name in symbols);
   var syms = symbols[name];
   for (var i = 0; i < syms.length; ++i) {
     symbolAdder.apply(null, syms[i]);
   }
 };
 
 
 function PrintMonitor(outputOrFileName) {
   var expectedOut = typeof outputOrFileName == 'string' ?
       this.loadExpectedOutput(outputOrFileName) : outputOrFileName;
   var outputPos = 0;
   var diffs = this.diffs = [];
   var realOut = this.realOut = [];
+  var unexpectedOut = this.unexpectedOut = null;
 
   this.oldPrint = print;
   print = function(str) {
     var strSplit = str.split('\n');
     for (var i = 0; i < strSplit.length; ++i) {
       s = strSplit[i];
       realOut.push(s);
-      assertTrue(outputPos < expectedOut.length,
-          'unexpected output: "' + s + '"');
-      if (expectedOut[outputPos] != s) {
-        diffs.push('line ' + outputPos + ': expected <' +
-                   expectedOut[outputPos] + '> found <' + s + '>\n');
+      if (outputPos < expectedOut.length) {
+        if (expectedOut[outputPos] != s) {
+          diffs.push('line ' + outputPos + ': expected <' +
+                     expectedOut[outputPos] + '> found <' + s + '>\n');
+        }
+        outputPos++;
+      } else {
+        unexpectedOut = true;
       }
-      outputPos++;
     }
   };
 };
 
 
 PrintMonitor.prototype.loadExpectedOutput = function(fileName) {
   var output = readFile(fileName);
   return output.split('\n');
 };
 
 
 PrintMonitor.prototype.finish = function() {
   print = this.oldPrint;
-  if (this.diffs.length > 0) {
+  if (this.diffs.length > 0 || this.unexpectedOut != null) {
     print(this.realOut.join('\n'));
     assertEquals([], this.diffs);
+    assertNull(this.unexpectedOut);
   }
 };
 
 
 function driveTickProcessorTest(
     separateIc, ignoreUnknown, stateFilter, logInput, refOutput) {
   // TEST_FILE_NAME must be provided by test runner.
   assertEquals('string', typeof TEST_FILE_NAME);
   var pathLen = TEST_FILE_NAME.lastIndexOf('/');
   if (pathLen == -1) {
@@ skipping 25 matching lines @@
       'tickprocessor-test.log', 'tickprocessor-test.ignore-unknown'],
     'GcState': [
       false, false, TickProcessor.VmStates.GC,
       'tickprocessor-test.log', 'tickprocessor-test.gc-state']
   };
   for (var testName in testData) {
     print('=== testProcessing-' + testName + ' ===');
     driveTickProcessorTest.apply(null, testData[testName]);
   }
 })();