2009-07-09 06:39:38 +00:00
// 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
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// 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.
2018-08-10 17:09:34 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test-func-info.log
2021-04-22 13:18:24 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test-func-info.log.symbols.json
// Resources: test/mjsunit/tools/tickprocessor-test-large.default
// Resources: test/mjsunit/tools/tickprocessor-test-large.log
// Resources: test/mjsunit/tools/tickprocessor-test-large.log.symbols.json
2018-08-10 17:09:34 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test.default
// Resources: test/mjsunit/tools/tickprocessor-test.func-info
// Resources: test/mjsunit/tools/tickprocessor-test.gc-state
// Resources: test/mjsunit/tools/tickprocessor-test.ignore-unknown
// Resources: test/mjsunit/tools/tickprocessor-test.log
2021-04-22 13:18:24 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test.log.symbols.json
2018-08-10 17:09:34 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test.only-summary
2021-04-22 13:18:24 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test.separate-baseline-handlers
// Resources: test/mjsunit/tools/tickprocessor-test.separate-bytecodes
2018-08-10 17:09:34 +00:00
// Resources: test/mjsunit/tools/tickprocessor-test.separate-ic
2009-07-09 06:39:38 +00:00
// Env: TEST_FILE_NAME
2020-09-28 13:50:56 +00:00
import {
TickProcessor , ArgumentsProcessor , UnixCppEntriesProvider ,
MacCppEntriesProvider , WindowsCppEntriesProvider , readFile
} from "../../../tools/tickprocessor.mjs" ;
2009-07-14 09:47:44 +00:00
2009-07-09 06:39:38 +00:00
( function testArgumentsProcessor ( ) {
var p _default = new ArgumentsProcessor ( [ ] ) ;
assertTrue ( p _default . parse ( ) ) ;
2017-10-23 22:47:02 +00:00
assertEquals ( p _default . getDefaultResults ( ) , p _default . result ( ) ) ;
2009-07-09 06:39:38 +00:00
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' ] ) ;
assertTrue ( p _platformAndLog . parse ( ) ) ;
assertEquals ( 'windows' , p _platformAndLog . result ( ) . platform ) ;
assertEquals ( 'winlog.log' , p _platformAndLog . result ( ) . logFileName ) ;
2017-04-11 09:56:03 +00:00
var p _flags = new ArgumentsProcessor ( [ '--gc' , '--separate-ic=true' ] ) ;
2009-07-09 06:39:38 +00:00
assertTrue ( p _flags . parse ( ) ) ;
assertEquals ( TickProcessor . VmStates . GC , p _flags . result ( ) . stateFilter ) ;
assertTrue ( p _flags . result ( ) . separateIc ) ;
2017-04-11 09:56:03 +00:00
var p _flags = new ArgumentsProcessor ( [ '--gc' , '--separate-ic=false' ] ) ;
assertTrue ( p _flags . parse ( ) ) ;
assertEquals ( TickProcessor . VmStates . GC , p _flags . result ( ) . stateFilter ) ;
assertFalse ( p _flags . result ( ) . separateIc ) ;
2009-07-09 06:39:38 +00:00
var p _nmAndLog = new ArgumentsProcessor ( [ '--nm=mn' , 'nmlog.log' ] ) ;
assertTrue ( p _nmAndLog . parse ( ) ) ;
assertEquals ( 'mn' , p _nmAndLog . result ( ) . nm ) ;
assertEquals ( 'nmlog.log' , p _nmAndLog . result ( ) . logFileName ) ;
var p _bad = new ArgumentsProcessor ( [ '--unknown' , 'badlog.log' ] ) ;
assertFalse ( p _bad . parse ( ) ) ;
} ) ( ) ;
( 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' ,
2009-07-14 09:47:44 +00:00
'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*)' ,
2009-07-09 06:39:38 +00:00
' w __gmon_start__' ,
2009-07-14 09:47:44 +00:00
'081f08a0 00000004 B stdout\n'
2009-07-09 06:39:38 +00:00
] . join ( '\n' ) , '' ] ;
} ;
var shell _prov = new UnixCppEntriesProvider ( ) ;
var shell _syms = [ ] ;
2016-05-02 08:00:48 +00:00
shell _prov . parseVmSymbols ( 'shell' , 0x08048000 , 0x081ee000 , 0 ,
2009-07-09 06:39:38 +00:00
function ( name , start , end ) {
shell _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
[ [ '_init' , 0x08049790 , 0x08049f50 ] ,
[ '_start' , 0x08049f50 , 0x08139150 ] ,
2009-07-14 09:47:44 +00:00
[ '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 ] ] ,
2009-07-09 06:39:38 +00:00
shell _syms ) ;
// libc library
UnixCppEntriesProvider . prototype . loadSymbols = function ( libName ) {
this . symbols = [ [
2009-07-14 09:47:44 +00:00
'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\n' ] . join ( '\n' ) , '' ] ;
2009-07-09 06:39:38 +00:00
} ;
var libc _prov = new UnixCppEntriesProvider ( ) ;
var libc _syms = [ ] ;
2016-05-02 08:00:48 +00:00
libc _prov . parseVmSymbols ( 'libc' , 0xf7c5c000 , 0xf7da5000 , 0 ,
2009-07-09 06:39:38 +00:00
function ( name , start , end ) {
libc _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
2009-07-14 09:47:44 +00:00
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 ) ;
2009-07-09 06:39:38 +00:00
2019-05-24 11:29:54 +00:00
// Android library with zero length duplicates.
UnixCppEntriesProvider . prototype . loadSymbols = function ( libName ) {
this . symbols = [ [
'00000000013a1088 0000000000000224 t v8::internal::interpreter::BytecodeGenerator::BytecodeGenerator(v8::internal::UnoptimizedCompilationInfo*)' ,
'00000000013a1088 0000000000000224 t v8::internal::interpreter::BytecodeGenerator::BytecodeGenerator(v8::internal::UnoptimizedCompilationInfo*)' ,
'00000000013a12ac t $x.4' ,
'00000000013a12ac 00000000000000d0 t v8::internal::interpreter::BytecodeGenerator::FinalizeBytecode(v8::internal::Isolate*, v8::internal::Handle<v8::internal::Script>)' ,
'00000000013a137c t $x.5' ,
'00000000013a137c 0000000000000528 t v8::internal::interpreter::BytecodeGenerator::AllocateDeferredConstants(v8::internal::Isolate*, v8::internal::Handle<v8::internal::Script>)' ,
'00000000013a1578 N $d.46' ,
'00000000013a18a4 t $x.6' ,
'00000000013a18a4 0000000000000 t v8::internal::interpreter::BytecodeGenerator::GlobalDeclarationsBuilder::AllocateDeclarations(v8::internal::UnoptimizedCompilationInfo*, v8::internal::Handle<v8::internal::Script>, v8::internal::Isolate*)' ,
'00000000013a19e0 t $x.7' ,
'00000000013a19e0 0000000000000244 t v8::internal::interpreter::BytecodeGenerator::GenerateBytecode(unsigned long)' ,
'00000000013a1a88 N $d.7' ,
'00000000013a1ac8 N $d.5' ,
'00000000013a1af8 N $d.35' ,
'00000000013a1c24 t $x.8' ,
'00000000013a1c24 000000000000009c t v8::internal::interpreter::BytecodeGenerator::ContextScope::ContextScope(v8::internal::interpreter::BytecodeGenerator*, v8::internal::Scope*)\n' ,
] . join ( '\n' ) , '' ] ;
} ;
var android _prov = new UnixCppEntriesProvider ( ) ;
var android _syms = [ ] ;
android _prov . parseVmSymbols ( 'libmonochrome' , 0xf7c5c000 , 0xf9c5c000 , 0 ,
function ( name , start , end ) {
android _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
var android _ref _syms = [
[ 'v8::internal::interpreter::BytecodeGenerator::BytecodeGenerator(v8::internal::UnoptimizedCompilationInfo*)' , 0x013a1088 , 0x013a1088 + 0x224 ] ,
[ 'v8::internal::interpreter::BytecodeGenerator::FinalizeBytecode(v8::internal::Isolate*, v8::internal::Handle<v8::internal::Script>)' , 0x013a12ac , 0x013a12ac + 0xd0 ] ,
[ 'v8::internal::interpreter::BytecodeGenerator::AllocateDeferredConstants(v8::internal::Isolate*, v8::internal::Handle<v8::internal::Script>)' , 0x013a137c , 0x013a137c + 0x528 ] ,
[ 'v8::internal::interpreter::BytecodeGenerator::GlobalDeclarationsBuilder::AllocateDeclarations(v8::internal::UnoptimizedCompilationInfo*, v8::internal::Handle<v8::internal::Script>, v8::internal::Isolate*)' , 0x013a18a4 , 0x013a18a4 + 0x13c ] ,
[ 'v8::internal::interpreter::BytecodeGenerator::GenerateBytecode(unsigned long)' , 0x013a19e0 , 0x013a19e0 + 0x244 ] ,
[ 'v8::internal::interpreter::BytecodeGenerator::ContextScope::ContextScope(v8::internal::interpreter::BytecodeGenerator*, v8::internal::Scope*)' , 0x013a1c24 , 0x013a1c24 + 0x9c ] ,
] ;
for ( var i = 0 ; i < android _ref _syms . length ; ++ i ) {
android _ref _syms [ i ] [ 1 ] += 0xf7c5c000 ;
android _ref _syms [ i ] [ 2 ] += 0xf7c5c000 ;
}
assertEquals ( android _ref _syms , android _syms ) ;
2009-07-09 06:39:38 +00:00
UnixCppEntriesProvider . prototype . loadSymbols = oldLoadSymbols ;
} ) ( ) ;
2009-07-14 09:47:44 +00:00
( function testMacCppEntriesProvider ( ) {
var oldLoadSymbols = MacCppEntriesProvider . prototype . loadSymbols ;
// shell executable
MacCppEntriesProvider . prototype . loadSymbols = function ( libName ) {
this . symbols = [ [
2017-03-04 13:04:58 +00:00
' operator delete[]' ,
'00001000 __mh_execute_header' ,
'00001b00 start' ,
'00001b40 dyld_stub_binding_helper' ,
'0011b710 v8::internal::RegExpMacroAssembler::CheckPosition' ,
'00134250 v8::internal::Runtime_StringReplaceRegExpWithString' ,
'00137220 v8::internal::Runtime::GetElementOrCharAt' ,
'00137400 v8::internal::Runtime_DebugGetPropertyDetails\n'
2009-07-14 09:47:44 +00:00
] . join ( '\n' ) , '' ] ;
} ;
var shell _prov = new MacCppEntriesProvider ( ) ;
var shell _syms = [ ] ;
2016-05-02 08:00:48 +00:00
shell _prov . parseVmSymbols ( 'shell' , 0x00001c00 , 0x00163256 , 0x100 ,
2009-07-14 09:47:44 +00:00
function ( name , start , end ) {
shell _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
2016-05-02 08:00:48 +00:00
[ [ 'start' , 0x00001c00 , 0x00001c40 ] ,
[ 'dyld_stub_binding_helper' , 0x00001c40 , 0x0011b810 ] ,
[ 'v8::internal::RegExpMacroAssembler::CheckPosition' , 0x0011b810 , 0x00134350 ] ,
[ 'v8::internal::Runtime_StringReplaceRegExpWithString' , 0x00134350 , 0x00137320 ] ,
[ 'v8::internal::Runtime::GetElementOrCharAt' , 0x00137320 , 0x00137500 ] ,
[ 'v8::internal::Runtime_DebugGetPropertyDetails' , 0x00137500 , 0x00163256 ] ] ,
2009-07-14 09:47:44 +00:00
shell _syms ) ;
// stdc++ library
MacCppEntriesProvider . prototype . loadSymbols = function ( libName ) {
this . symbols = [ [
2017-03-04 13:04:58 +00:00
'0000107a __gnu_cxx::balloc::__mini_vector<std::pair<__gnu_cxx::bitmap_allocator<char>::_Alloc_block*, __gnu_cxx::bitmap_allocator<char>::_Alloc_block*> >::__mini_vector' ,
'0002c410 std::basic_streambuf<char, std::char_traits<char> >::pubseekoff' ,
'0002c488 std::basic_streambuf<char, std::char_traits<char> >::pubseekpos' ,
'000466aa ___cxa_pure_virtual\n' ] . join ( '\n' ) , '' ] ;
2009-07-14 09:47:44 +00:00
} ;
var stdc _prov = new MacCppEntriesProvider ( ) ;
var stdc _syms = [ ] ;
2016-05-02 08:00:48 +00:00
stdc _prov . parseVmSymbols ( 'stdc++' , 0x95728fb4 , 0x95770005 , 0 ,
2009-07-14 09:47:44 +00:00
function ( name , start , end ) {
stdc _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
var stdc _ref _syms = [ [ '__gnu_cxx::balloc::__mini_vector<std::pair<__gnu_cxx::bitmap_allocator<char>::_Alloc_block*, __gnu_cxx::bitmap_allocator<char>::_Alloc_block*> >::__mini_vector' , 0x0000107a , 0x0002c410 ] ,
[ 'std::basic_streambuf<char, std::char_traits<char> >::pubseekoff' , 0x0002c410 , 0x0002c488 ] ,
[ 'std::basic_streambuf<char, std::char_traits<char> >::pubseekpos' , 0x0002c488 , 0x000466aa ] ,
[ '___cxa_pure_virtual' , 0x000466aa , 0x95770005 - 0x95728fb4 ] ] ;
for ( var i = 0 ; i < stdc _ref _syms . length ; ++ i ) {
stdc _ref _syms [ i ] [ 1 ] += 0x95728fb4 ;
stdc _ref _syms [ i ] [ 2 ] += 0x95728fb4 ;
}
assertEquals ( stdc _ref _syms , stdc _syms ) ;
MacCppEntriesProvider . prototype . loadSymbols = oldLoadSymbols ;
} ) ( ) ;
2009-07-09 06:39:38 +00:00
( function testWindowsCppEntriesProvider ( ) {
var oldLoadSymbols = WindowsCppEntriesProvider . prototype . loadSymbols ;
WindowsCppEntriesProvider . prototype . loadSymbols = function ( libName ) {
this . symbols = [
' Start Length Name Class' ,
' 0001:00000000 000ac902H .text CODE' ,
' 0001:000ac910 000005e2H .text$yc CODE' ,
' Address Publics by Value Rva+Base Lib:Object' ,
' 0000:00000000 __except_list 00000000 <absolute>' ,
' 0001:00000000 ?ReadFile@@YA?AV?$Handle@VString@v8@@@v8@@PBD@Z 00401000 f shell.obj' ,
' 0001:000000a0 ?Print@@YA?AV?$Handle@VValue@v8@@@v8@@ABVArguments@2@@Z 004010a0 f shell.obj' ,
' 0001:00001230 ??1UTF8Buffer@internal@v8@@QAE@XZ 00402230 f v8_snapshot:scanner.obj' ,
' 0001:00001230 ??1Utf8Value@String@v8@@QAE@XZ 00402230 f v8_snapshot:api.obj' ,
' 0001:000954ba __fclose_nolock 004964ba f LIBCMT:fclose.obj' ,
' 0002:00000000 __imp__SetThreadPriority@8 004af000 kernel32:KERNEL32.dll' ,
' 0003:00000418 ?in_use_list_@PreallocatedStorage@internal@v8@@0V123@A 00544418 v8_snapshot:allocation.obj' ,
' Static symbols' ,
' 0001:00000b70 ?DefaultFatalErrorHandler@v8@@YAXPBD0@Z 00401b70 f v8_snapshot:api.obj' ,
' 0001:000010b0 ?EnsureInitialized@v8@@YAXPBD@Z 004020b0 f v8_snapshot:api.obj' ,
' 0001:000ad17b ??__Fnomem@?5???2@YAPAXI@Z@YAXXZ 004ae17b f LIBCMT:new.obj'
] . join ( '\r\n' ) ;
} ;
var shell _prov = new WindowsCppEntriesProvider ( ) ;
var shell _syms = [ ] ;
2016-05-02 08:00:48 +00:00
shell _prov . parseVmSymbols ( 'shell.exe' , 0x00400000 , 0x0057c000 , 0 ,
2009-07-09 06:39:38 +00:00
function ( name , start , end ) {
shell _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
[ [ 'ReadFile' , 0x00401000 , 0x004010a0 ] ,
[ 'Print' , 0x004010a0 , 0x00402230 ] ,
[ 'v8::String::?1Utf8Value' , 0x00402230 , 0x004964ba ] ,
[ 'v8::DefaultFatalErrorHandler' , 0x00401b70 , 0x004020b0 ] ,
[ 'v8::EnsureInitialized' , 0x004020b0 , 0x0057c000 ] ] ,
shell _syms ) ;
WindowsCppEntriesProvider . prototype . loadSymbols = oldLoadSymbols ;
} ) ( ) ;
2009-08-17 13:45:03 +00:00
// http://code.google.com/p/v8/issues/detail?id=427
( function testWindowsProcessExeAndDllMapFile ( ) {
function exeSymbols ( exeName ) {
return [
' 0000:00000000 ___ImageBase 00400000 <linker-defined>' ,
' 0001:00000780 ?RunMain@@YAHHQAPAD@Z 00401780 f shell.obj' ,
' 0001:00000ac0 _main 00401ac0 f shell.obj' ,
''
] . join ( '\r\n' ) ;
}
function dllSymbols ( dllName ) {
return [
' 0000:00000000 ___ImageBase 01c30000 <linker-defined>' ,
' 0001:00000780 _DllMain@12 01c31780 f libcmt:dllmain.obj' ,
' 0001:00000ac0 ___DllMainCRTStartup 01c31ac0 f libcmt:dllcrt0.obj' ,
''
] . join ( '\r\n' ) ;
}
var oldRead = read ;
read = exeSymbols ;
var exe _exe _syms = [ ] ;
( new WindowsCppEntriesProvider ( ) ) . parseVmSymbols (
2016-05-02 08:00:48 +00:00
'chrome.exe' , 0x00400000 , 0x00472000 , 0 ,
2009-08-17 13:45:03 +00:00
function ( name , start , end ) {
exe _exe _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
[ [ 'RunMain' , 0x00401780 , 0x00401ac0 ] ,
[ '_main' , 0x00401ac0 , 0x00472000 ] ] ,
exe _exe _syms , '.exe with .exe symbols' ) ;
read = dllSymbols ;
var exe _dll _syms = [ ] ;
( new WindowsCppEntriesProvider ( ) ) . parseVmSymbols (
2016-05-02 08:00:48 +00:00
'chrome.exe' , 0x00400000 , 0x00472000 , 0 ,
2009-08-17 13:45:03 +00:00
function ( name , start , end ) {
exe _dll _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
[ ] ,
exe _dll _syms , '.exe with .dll symbols' ) ;
read = dllSymbols ;
var dll _dll _syms = [ ] ;
( new WindowsCppEntriesProvider ( ) ) . parseVmSymbols (
2016-05-02 08:00:48 +00:00
'chrome.dll' , 0x01c30000 , 0x02b80000 , 0 ,
2009-08-17 13:45:03 +00:00
function ( name , start , end ) {
dll _dll _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
[ [ '_DllMain@12' , 0x01c31780 , 0x01c31ac0 ] ,
[ '___DllMainCRTStartup' , 0x01c31ac0 , 0x02b80000 ] ] ,
dll _dll _syms , '.dll with .dll symbols' ) ;
read = exeSymbols ;
var dll _exe _syms = [ ] ;
( new WindowsCppEntriesProvider ( ) ) . parseVmSymbols (
2016-05-02 08:00:48 +00:00
'chrome.dll' , 0x01c30000 , 0x02b80000 , 0 ,
2009-08-17 13:45:03 +00:00
function ( name , start , end ) {
dll _exe _syms . push ( Array . prototype . slice . apply ( arguments , [ 0 ] ) ) ;
} ) ;
assertEquals (
[ ] ,
dll _exe _syms , '.dll with .exe symbols' ) ;
read = oldRead ;
} ) ( ) ;
2021-04-20 16:57:36 +00:00
class CppEntriesProviderMock {
constructor ( filename ) {
this . isLoaded = false ;
this . symbols = JSON . parse ( readFile ( filename ) ) ;
2009-07-09 06:39:38 +00:00
}
2021-04-20 16:57:36 +00:00
parseVmSymbols ( name , startAddr , endAddr , slideAddr , symbolAdder ) {
if ( this . isLoaded ) return ;
this . isLoaded = true ;
for ( let symbol of this . symbols ) {
symbolAdder . apply ( null , symbol ) ;
}
}
}
2009-07-09 06:39:38 +00:00
2021-04-20 16:57:36 +00:00
class PrintMonitor {
constructor ( outputOrFileName ) {
this . expectedOut = outputOrFileName ;
this . outputFile = undefined ;
if ( typeof outputOrFileName == 'string' ) {
this . expectedOut = this . loadExpectedOutput ( outputOrFileName )
this . outputFile = outputOrFileName ;
}
var expectedOut = this . expectedOut ;
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 ) {
var s = strSplit [ i ] ;
realOut . push ( s ) ;
if ( outputPos < expectedOut . length ) {
if ( expectedOut [ outputPos ] != s ) {
diffs . push ( 'line ' + outputPos + ': expected <' +
expectedOut [ outputPos ] + '> found <' + s + '>\n' ) ;
}
outputPos ++ ;
} else {
unexpectedOut = true ;
2009-07-14 09:47:44 +00:00
}
2009-07-09 06:39:38 +00:00
}
2021-04-20 16:57:36 +00:00
} ;
}
2009-07-09 06:39:38 +00:00
2021-04-20 16:57:36 +00:00
loadExpectedOutput ( fileName ) {
var output = readFile ( fileName ) ;
return output . split ( '\n' ) ;
}
2009-07-09 06:39:38 +00:00
2021-04-20 16:57:36 +00:00
finish ( ) {
print = this . oldPrint ;
if ( this . diffs . length > 0 || this . unexpectedOut != null ) {
console . log ( "===== actual output: =====" ) ;
console . log ( this . realOut . join ( '\n' ) ) ;
console . log ( "===== expected output: =====" ) ;
if ( this . outputFile ) {
console . log ( "===== File: " + this . outputFile + " =====" ) ;
}
console . log ( this . expectedOut . join ( '\n' ) ) ;
if ( this . diffs . length > 0 ) {
this . diffs . forEach ( line => console . log ( line ) )
assertEquals ( [ ] , this . diffs ) ;
}
assertNull ( this . unexpectedOut ) ;
2017-03-10 10:06:06 +00:00
}
2009-07-09 06:39:38 +00:00
}
2021-04-20 16:57:36 +00:00
}
2009-07-09 06:39:38 +00:00
function driveTickProcessorTest (
2017-04-11 09:56:03 +00:00
separateIc , separateBytecodes , separateBuiltins , separateStubs ,
2021-04-20 16:57:36 +00:00
separateBaselineHandlers , ignoreUnknown , stateFilter , logInput ,
refOutput , onlySummary ) {
2009-07-09 06:39:38 +00:00
// TEST_FILE_NAME must be provided by test runner.
assertEquals ( 'string' , typeof TEST _FILE _NAME ) ;
var pathLen = TEST _FILE _NAME . lastIndexOf ( '/' ) ;
if ( pathLen == - 1 ) {
pathLen = TEST _FILE _NAME . lastIndexOf ( '\\' ) ;
}
assertTrue ( pathLen != - 1 ) ;
2021-04-20 16:57:36 +00:00
const testsPath = TEST _FILE _NAME . substr ( 0 , pathLen + 1 ) ;
const symbolsFile = testsPath + logInput + '.symbols.json' ;
const tp = new TickProcessor ( new CppEntriesProviderMock ( symbolsFile ) ,
2012-02-13 10:24:55 +00:00
separateIc ,
2017-04-11 09:56:03 +00:00
separateBytecodes ,
separateBuiltins ,
separateStubs ,
2021-04-20 16:57:36 +00:00
separateBaselineHandlers ,
2012-02-13 10:24:55 +00:00
TickProcessor . CALL _GRAPH _SIZE ,
ignoreUnknown ,
2013-01-29 14:41:02 +00:00
stateFilter ,
"0" ,
2015-01-20 16:06:03 +00:00
"auto,auto" ,
2021-04-20 16:57:36 +00:00
null ,
2015-09-03 18:01:40 +00:00
false ,
false ,
onlySummary ) ;
2021-04-20 16:57:36 +00:00
const pm = new PrintMonitor ( testsPath + refOutput ) ;
2010-02-08 08:55:01 +00:00
tp . processLogFileInTest ( testsPath + logInput ) ;
2009-07-09 06:39:38 +00:00
tp . printStatistics ( ) ;
pm . finish ( ) ;
} ;
( function testProcessing ( ) {
var testData = {
'Default' : [
2021-04-20 16:57:36 +00:00
false , false , true , true , false , false , null ,
2015-09-03 18:01:40 +00:00
'tickprocessor-test.log' , 'tickprocessor-test.default' , false ] ,
2021-04-20 16:57:36 +00:00
'SeparateBytecodes' : [
false , true , true , true , false , false , null ,
'tickprocessor-test.log' , 'tickprocessor-test.separate-bytecodes' , false ] ,
'SeparateBaselineHandlers' : [
false , false , true , true , true , false , null ,
'tickprocessor-test.log' , 'tickprocessor-test.separate-baseline-handlers' , false ] ,
2009-07-09 06:39:38 +00:00
'SeparateIc' : [
2021-04-20 16:57:36 +00:00
true , false , true , true , false , false , null ,
2015-09-03 18:01:40 +00:00
'tickprocessor-test.log' , 'tickprocessor-test.separate-ic' , false ] ,
2009-07-09 06:39:38 +00:00
'IgnoreUnknown' : [
2021-04-20 16:57:36 +00:00
false , false , true , true , false , true , null ,
2015-09-03 18:01:40 +00:00
'tickprocessor-test.log' , 'tickprocessor-test.ignore-unknown' , false ] ,
2009-07-09 06:39:38 +00:00
'GcState' : [
2021-04-20 16:57:36 +00:00
false , false , true , true , false , false , TickProcessor . VmStates . GC ,
2015-09-03 18:01:40 +00:00
'tickprocessor-test.log' , 'tickprocessor-test.gc-state' , false ] ,
2021-04-20 16:57:36 +00:00
'OnlySummary' : [
false , false , true , true , false , false , null ,
'tickprocessor-test.log' , 'tickprocessor-test.only-summary' , true ] ,
Fix issue 553: function frame is skipped in profile when compare stub is called.
The problem appeared due to a fact that stubs doesn't create a stack
frame, reusing the stack frame of the caller function. When building
stack traces, the current function is retrieved from PC, and its
callees are retrieved by traversing the stack backwards. Thus, for
stubs, the stub itself was discovered via PC, and then stub's caller's
caller was retrieved from stack.
To fix this problem, a pointer to JSFunction object is now captured
from the topmost stack frame, and is saved into stack trace log
record. Then a simple heuristics is applied whether a referred
function should be added to decoded stack, or not, to avoid reporting
the same function twice (from PC and from the pointer.)
BUG=553
TEST=added to mjsunit/tools/tickprocessor
Review URL: http://codereview.chromium.org/546089
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@3673 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2010-01-21 16:42:41 +00:00
'FunctionInfo' : [
2021-04-20 16:57:36 +00:00
false , false , true , true , false , false , null ,
2015-09-03 18:01:40 +00:00
'tickprocessor-test-func-info.log' , 'tickprocessor-test.func-info' ,
false ] ,
2021-04-20 16:57:36 +00:00
'DefaultLarge' : [
false , false , true , true , false , false , null ,
'tickprocessor-test-large.log' , 'tickprocessor-test-large.default' , false ] ,
2009-07-09 06:39:38 +00:00
} ;
for ( var testName in testData ) {
2021-04-20 16:57:36 +00:00
console . log ( '=== testProcessing-' + testName + ' ===' ) ;
driveTickProcessorTest ( ... testData [ testName ] ) ;
2009-07-09 06:39:38 +00:00
}
} ) ( ) ;