AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Introduce mkgrokdump to update tools/v8heapconst.py.

Browse Source 
- Migrate make grokdump to GYP and GN
- Move code from d8 into stand-alone execution
- Add test case to ensure it's up-to-date

Review-Url: https://codereview.chromium.org/2809653003
Cr-Commit-Position: refs/heads/master@{#44687}
This commit is contained in:
yangguo 2017-04-18 07:05:27 -07:00 committed by Commit bot
parent 81a0104540
commit 0cc0c130fa
20 changed files with 609 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Makefile
View File

@ -240,7 +240,6 @@ ifdef android_ndk_root
endif
# ----------------- available targets: --------------------
# - "grokdump": rebuilds heap constants lists used by grokdump
# - any arch listed in ARCHES (see below)
# - any mode listed in MODES
# - every combination <arch>.<mode>, e.g. "ia32.release"
@ -467,12 +466,6 @@ $(ENVFILE).new:
$(eval CXX_TARGET_ARCH:=$(subst x86_64,x64,$(CXX_TARGET_ARCH)))
@mkdir -p $(OUTDIR); echo "GYPFLAGS=$(GYPFLAGS) -Dtarget_arch=$(CXX_TARGET_ARCH)" > $(ENVFILE).new;
# Heap constants for grokdump.
DUMP_FILE = tools/v8heapconst.py
grokdump: ia32.release
@cat $(DUMP_FILE).tmpl > $(DUMP_FILE)
@$(OUTDIR)/ia32.release/d8 --dump-heap-constants >> $(DUMP_FILE)
# Support for the GNU GLOBAL Source Code Tag System.
gtags.files: $(GYPFILES) $(ENVFILE)
@find include src test -name '*.h' -o -name '*.cc' -o -name '*.c' > $@

1
gypfiles/all.gyp
View File

@ -10,6 +10,7 @@
'dependencies': [
'../src/d8.gyp:d8',
'../test/inspector/inspector.gyp:*',
'../test/mkgrokdump/mkgrokdump.gyp:*',
],
'conditions': [
['component!="shared_library"', {

75
src/d8.cc
View File

@ -2540,9 +2540,6 @@ bool Shell::SetOptions(int argc, char* argv[]) {
continue;
} else if (strcmp(argv[i], "--isolate") == 0) {
options.num_isolates++;
} else if (strcmp(argv[i], "--dump-heap-constants") == 0) {
options.dump_heap_constants = true;
argv[i] = NULL;
} else if (strcmp(argv[i], "--throws") == 0) {
options.expected_to_throw = true;
argv[i] = NULL;
@ -2923,73 +2920,6 @@ void Shell::CleanupWorkers() {
externalized_contents_.clear();
}
static void DumpHeapConstants(i::Isolate* isolate) {
i::Heap* heap = isolate->heap();
printf(
"# Copyright 2017 the V8 project authors. All rights reserved.\n"
"# Use of this source code is governed by a BSD-style license that can\n"
"# be found in the LICENSE file.\n\n");
// Dump the INSTANCE_TYPES table to the console.
printf("# List of known V8 instance types.\n");
#define DUMP_TYPE(T) printf(" %d: \"%s\",\n", i::T, #T);
printf("INSTANCE_TYPES = {\n");
INSTANCE_TYPE_LIST(DUMP_TYPE)
printf("}\n");
#undef DUMP_TYPE
// Dump the KNOWN_MAP table to the console.
printf("\n# List of known V8 maps.\n");
#define ROOT_LIST_CASE(type, name, camel_name) \
if (n == NULL && o == heap->name()) n = #camel_name;
#define STRUCT_LIST_CASE(upper_name, camel_name, name) \
if (n == NULL && o == heap->name##_map()) n = #camel_name "Map";
i::HeapObjectIterator it(heap->map_space());
printf("KNOWN_MAPS = {\n");
for (i::Object* o = it.Next(); o != NULL; o = it.Next()) {
i::Map* m = i::Map::cast(o);
const char* n = NULL;
intptr_t p = reinterpret_cast<intptr_t>(m) & 0x7ffff;
int t = m->instance_type();
ROOT_LIST(ROOT_LIST_CASE)
STRUCT_LIST(STRUCT_LIST_CASE)
if (n == NULL) continue;
printf(" 0x%05" V8PRIxPTR ": (%d, \"%s\"),\n", p, t, n);
}
printf("}\n");
#undef STRUCT_LIST_CASE
#undef ROOT_LIST_CASE
// Dump the KNOWN_OBJECTS table to the console.
printf("\n# List of known V8 objects.\n");
#define ROOT_LIST_CASE(type, name, camel_name) \
if (n == NULL && o == heap->name()) n = #camel_name;
i::OldSpaces spit(heap);
printf("KNOWN_OBJECTS = {\n");
for (i::PagedSpace* s = spit.next(); s != NULL; s = spit.next()) {
i::HeapObjectIterator it(s);
const char* sname = AllocationSpaceName(s->identity());
for (i::Object* o = it.Next(); o != NULL; o = it.Next()) {
const char* n = NULL;
intptr_t p = reinterpret_cast<intptr_t>(o) & 0x7ffff;
ROOT_LIST(ROOT_LIST_CASE)
if (n == NULL) continue;
printf(" (\"%s\", 0x%05" V8PRIxPTR "): \"%s\",\n", sname, p, n);
}
}
printf("}\n");
#undef ROOT_LIST_CASE
// Dump frame markers
printf("\n# List of known V8 Frame Markers.\n");
#define DUMP_MARKER(T, class) printf(" \"%s\",\n", #T);
printf("FRAME_MARKERS = (\n");
STACK_FRAME_TYPE_LIST(DUMP_MARKER)
printf(")\n");
#undef DUMP_TYPE
}
int Shell::Main(int argc, char* argv[]) {
std::ofstream trace_file;
#if (defined(_WIN32) || defined(_WIN64))
@ -3094,11 +3024,6 @@ int Shell::Main(int argc, char* argv[]) {
tracing_controller->StartTracing(trace_config);
}
if (options.dump_heap_constants) {
DumpHeapConstants(reinterpret_cast<i::Isolate*>(isolate));
return 0;
}
if (options.stress_opt || options.stress_deopt) {
Testing::SetStressRunType(options.stress_opt
? Testing::kStressTypeOpt

2
src/d8.h
View File

@ -292,7 +292,6 @@ class ShellOptions {
stress_runs(1),
interactive_shell(false),
test_shell(false),
dump_heap_constants(false),
expected_to_throw(false),
mock_arraybuffer_allocator(false),
enable_inspector(false),
@ -323,7 +322,6 @@ class ShellOptions {
int stress_runs;
bool interactive_shell;
bool test_shell;
bool dump_heap_constants;
bool expected_to_throw;
bool mock_arraybuffer_allocator;
bool enable_inspector;

1
src/heap/heap.cc
View File

@ -2924,7 +2924,6 @@ bool Heap::RootCanBeWrittenAfterInitialization(Heap::RootListIndex root_index) {
case kInstanceofCacheMapRootIndex:
case kInstanceofCacheAnswerRootIndex:
case kCodeStubsRootIndex:
case kEmptyScriptRootIndex:
case kScriptListRootIndex:
case kMaterializedObjectsRootIndex:
case kMicrotaskQueueRootIndex:

163
src/heap/heap.h
View File

@ -136,6 +136,17 @@ using v8::MemoryPressureLevel;
V(Map, fixed_float32_array_map, FixedFloat32ArrayMap) \
V(Map, fixed_float64_array_map, FixedFloat64ArrayMap) \
V(Map, fixed_uint8_clamped_array_map, FixedUint8ClampedArrayMap) \
/* Oddball maps */ \
V(Map, undefined_map, UndefinedMap) \
V(Map, the_hole_map, TheHoleMap) \
V(Map, null_map, NullMap) \
V(Map, boolean_map, BooleanMap) \
V(Map, uninitialized_map, UninitializedMap) \
V(Map, arguments_marker_map, ArgumentsMarkerMap) \
V(Map, exception_map, ExceptionMap) \
V(Map, termination_exception_map, TerminationExceptionMap) \
V(Map, optimized_out_map, OptimizedOutMap) \
V(Map, stale_register_map, StaleRegisterMap) \
/* Canonical empty values */ \
V(ByteArray, empty_byte_array, EmptyByteArray) \
V(FixedTypedArrayBase, empty_fixed_uint8_array, EmptyFixedUint8Array) \
@ -155,6 +166,7 @@ using v8::MemoryPressureLevel;
EmptySlowElementDictionary) \
V(PropertyCell, empty_property_cell, EmptyPropertyCell) \
V(WeakCell, empty_weak_cell, EmptyWeakCell) \
V(InterceptorInfo, noop_interceptor_info, NoOpInterceptorInfo) \
/* Protectors */ \
V(PropertyCell, array_protector, ArrayProtector) \
V(Cell, is_concat_spreadable_protector, IsConcatSpreadableProtector) \
@ -164,6 +176,9 @@ using v8::MemoryPressureLevel;
V(PropertyCell, array_iterator_protector, ArrayIteratorProtector) \
V(PropertyCell, array_buffer_neutering_protector, \
ArrayBufferNeuteringProtector) \
/* JS Entries */ \
V(Code, js_entry_code, JsEntryCode) \
V(Code, js_construct_entry_code, JsConstructEntryCode) \
/* Special numbers */ \
V(HeapNumber, nan_value, NanValue) \
V(HeapNumber, hole_nan_value, HoleNanValue) \
@ -201,22 +216,7 @@ using v8::MemoryPressureLevel;
V(Object, noscript_shared_function_infos, NoScriptSharedFunctionInfos) \
V(FixedArray, serialized_templates, SerializedTemplates) \
V(FixedArray, serialized_global_proxy_sizes, SerializedGlobalProxySizes) \
/* Configured values */ \
V(TemplateList, message_listeners, MessageListeners) \
V(InterceptorInfo, noop_interceptor_info, NoOpInterceptorInfo) \
V(Code, js_entry_code, JsEntryCode) \
V(Code, js_construct_entry_code, JsConstructEntryCode) \
/* Oddball maps */ \
V(Map, undefined_map, UndefinedMap) \
V(Map, the_hole_map, TheHoleMap) \
V(Map, null_map, NullMap) \
V(Map, boolean_map, BooleanMap) \
V(Map, uninitialized_map, UninitializedMap) \
V(Map, arguments_marker_map, ArgumentsMarkerMap) \
V(Map, exception_map, ExceptionMap) \
V(Map, termination_exception_map, TerminationExceptionMap) \
V(Map, optimized_out_map, OptimizedOutMap) \
V(Map, stale_register_map, StaleRegisterMap) \
/* per-Isolate map for JSPromiseCapability. */ \
/* TODO(caitp): Make this a Struct */ \
V(Map, js_promise_capability_map, JSPromiseCapabilityMap)
@ -248,64 +248,93 @@ using v8::MemoryPressureLevel;
// Heap roots that are known to be immortal immovable, for which we can safely
// skip write barriers. This list is not complete and has omissions.
#define IMMORTAL_IMMOVABLE_ROOT_LIST(V) \
V(ArgumentsMarker) \
V(ArgumentsMarkerMap) \
V(ArrayBufferNeuteringProtector) \
V(ArrayIteratorProtector) \
V(ArrayProtector) \
V(BlockContextMap) \
V(BooleanMap) \
V(ByteArrayMap) \
V(BytecodeArrayMap) \
V(FreeSpaceMap) \
V(OnePointerFillerMap) \
V(TwoPointerFillerMap) \
V(UndefinedValue) \
V(TheHoleValue) \
V(NullValue) \
V(TrueValue) \
V(FalseValue) \
V(UninitializedValue) \
V(CatchContextMap) \
V(CellMap) \
V(GlobalPropertyCellMap) \
V(SharedFunctionInfoMap) \
V(MetaMap) \
V(HeapNumberMap) \
V(MutableHeapNumberMap) \
V(NativeContextMap) \
V(FixedArrayMap) \
V(CodeMap) \
V(ScopeInfoMap) \
V(ModuleInfoMap) \
V(FixedCOWArrayMap) \
V(FixedDoubleArrayMap) \
V(WeakCellMap) \
V(TransitionArrayMap) \
V(HashTableMap) \
V(OrderedHashTableMap) \
V(EmptyFixedArray) \
V(EmptyByteArray) \
V(EmptyDescriptorArray) \
V(ArgumentsMarker) \
V(SymbolMap) \
V(SloppyArgumentsElementsMap) \
V(FunctionContextMap) \
V(CatchContextMap) \
V(WithContextMap) \
V(BlockContextMap) \
V(ModuleContextMap) \
V(EvalContextMap) \
V(ScriptContextMap) \
V(UndefinedMap) \
V(TheHoleMap) \
V(NullMap) \
V(BooleanMap) \
V(UninitializedMap) \
V(ArgumentsMarkerMap) \
V(JSMessageObjectMap) \
V(ForeignMap) \
V(NoClosuresCellMap) \
V(OneClosureCellMap) \
V(ManyClosuresCellMap) \
V(NanValue) \
V(InfinityValue) \
V(MinusZeroValue) \
V(MinusInfinityValue) \
V(EmptyWeakCell) \
V(EmptyFixedArray) \
V(EmptyFixedFloat32Array) \
V(EmptyFixedFloat64Array) \
V(EmptyFixedInt16Array) \
V(EmptyFixedInt32Array) \
V(EmptyFixedInt8Array) \
V(EmptyFixedUint16Array) \
V(EmptyFixedUint32Array) \
V(EmptyFixedUint8Array) \
V(EmptyFixedUint8ClampedArray) \
V(EmptyPropertyCell) \
V(EmptyScopeInfo) \
V(EmptyScript) \
V(EmptySloppyArgumentsElements) \
V(EmptySlowElementDictionary) \
V(empty_string) \
V(EmptyWeakCell) \
V(EvalContextMap) \
V(Exception) \
V(FalseValue) \
V(FastArrayIterationProtector) \
V(FixedArrayMap) \
V(FixedCOWArrayMap) \
V(FixedDoubleArrayMap) \
V(ForeignMap) \
V(FreeSpaceMap) \
V(FunctionContextMap) \
V(GlobalPropertyCellMap) \
V(HashTableMap) \
V(HeapNumberMap) \
V(HoleNanValue) \
V(InfinityValue) \
V(IsConcatSpreadableProtector) \
V(JsConstructEntryCode) \
V(JsEntryCode) \
V(JSMessageObjectMap) \
V(ManyClosuresCellMap) \
V(MetaMap) \
V(MinusInfinityValue) \
V(MinusZeroValue) \
V(ModuleContextMap) \
V(ModuleInfoMap) \
V(MutableHeapNumberMap) \
V(NanValue) \
V(NativeContextMap) \
V(NoClosuresCellMap) \
V(NullMap) \
V(NullValue) \
V(OneClosureCellMap) \
V(OnePointerFillerMap) \
V(OptimizedOut) \
V(OrderedHashTableMap) \
V(ScopeInfoMap) \
V(ScriptContextMap) \
V(SharedFunctionInfoMap) \
V(SloppyArgumentsElementsMap) \
V(SpeciesProtector) \
V(StaleRegister) \
V(StringLengthProtector) \
V(SymbolMap) \
V(TerminationException) \
V(TheHoleMap) \
V(TheHoleValue) \
V(TransitionArrayMap) \
V(TrueValue) \
V(TwoPointerFillerMap) \
V(UndefinedCell) \
V(UndefinedMap) \
V(UndefinedValue) \
V(UninitializedMap) \
V(UninitializedValue) \
V(WeakCellMap) \
V(WithContextMap) \
PRIVATE_SYMBOL_LIST(V)
// Forward declarations.
@ -666,7 +695,7 @@ class Heap {
static void FatalProcessOutOfMemory(const char* location,
bool is_heap_oom = false);
static bool RootIsImmortalImmovable(int root_index);
V8_EXPORT_PRIVATE static bool RootIsImmortalImmovable(int root_index);
// Checks whether the space is valid.
static bool IsValidAllocationSpace(AllocationSpace space);

10
test/BUILD.gn
View File

@ -11,6 +11,7 @@ group("gn_all") {
deps = [
":default_tests",
"inspector:inspector-test",
"mkgrokdump:mkgrokdump",
]
if (host_os != "mac" || !is_android) {
@ -48,6 +49,7 @@ group("default_tests") {
":intl_run",
":message_run",
":mjsunit_run",
":mkgrokdump_run",
":preparser_run",
":unittests_run",
]
@ -164,6 +166,14 @@ v8_isolate_run("mjsunit") {
isolate = "mjsunit/mjsunit.isolate"
}
v8_isolate_run("mkgrokdump") {
deps = [
"mkgrokdump:mkgrokdump",
]
isolate = "mkgrokdump/mkgrokdump.isolate"
}
v8_isolate_run("mozilla") {
deps = [
"..:d8_run",

1
test/bot_default.isolate
View File

@ -15,6 +15,7 @@
'intl/intl.isolate',
'message/message.isolate',
'mjsunit/mjsunit.isolate',
'mkgrokdump/mkgrokdump.isolate',
'preparser/preparser.isolate',
'unittests/unittests.isolate',
'webkit/webkit.isolate',

1
test/default.isolate
View File

@ -15,6 +15,7 @@
'intl/intl.isolate',
'message/message.isolate',
'mjsunit/mjsunit.isolate',
'mkgrokdump/mkgrokdump.isolate',
'preparser/preparser.isolate',
'unittests/unittests.isolate',
],

27
test/mkgrokdump/BUILD.gn Normal file
View File

@ -0,0 +1,27 @@
# Copyright 2017 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import("../../gni/v8.gni")
v8_executable("mkgrokdump") {
testonly = true
# mkgrokdump is used to create tools/v8heapconst.py.
sources = [
"mkgrokdump.cc",
]
configs = [ "../..:internal_config_base" ]
defines = []
deps = [
"../..:v8",
"../..:v8_libbase",
"../..:v8_libplatform",
"//build/config/sanitizers:deps",
"//build/win:default_exe_manifest",
]
}

3
test/mkgrokdump/DEPS Normal file
View File

@ -0,0 +1,3 @@
include_rules = [
"+src",
]

130
test/mkgrokdump/mkgrokdump.cc Normal file
View File

@ -0,0 +1,130 @@
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdio.h>
#include "include/libplatform/libplatform.h"
#include "include/v8.h"
#include "src/frames.h"
#include "src/heap/heap.h"
#include "src/heap/spaces.h"
#include "src/isolate.h"
#include "src/objects-inl.h"
namespace v8 {
static const char* kHeader =
"# Copyright 2017 the V8 project authors. All rights reserved.\n"
"# Use of this source code is governed by a BSD-style license that can\n"
"# be found in the LICENSE file.\n"
"\n"
"# This file is automatically generated by mkgrokdump and should not\n"
"# be modified manually.\n"
"\n"
"# List of known V8 instance types.\n";
// Non-snapshot builds allocate objects to different places.
// Debug builds emit debug code, affecting code object sizes.
#if defined(V8_USE_SNAPSHOT) && !defined(DEBUG)
static const char* kBuild = "shipping";
#else
static const char* kBuild = "non-shipping";
#endif
class MockArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
public:
void* Allocate(size_t length) override { return nullptr; }
void* AllocateUninitialized(size_t length) override { return nullptr; }
void Free(void* p, size_t) override {}
};
static int DumpHeapConstants(const char* argv0) {
// Start up V8.
v8::Platform* platform = v8::platform::CreateDefaultPlatform();
v8::V8::InitializePlatform(platform);
v8::V8::Initialize();
v8::V8::InitializeExternalStartupData(argv0);
Isolate::CreateParams create_params;
MockArrayBufferAllocator mock_arraybuffer_allocator;
create_params.array_buffer_allocator = &mock_arraybuffer_allocator;
Isolate* isolate = Isolate::New(create_params);
{
Isolate::Scope scope(isolate);
i::Heap* heap = reinterpret_cast<i::Isolate*>(isolate)->heap();
printf("%s", kHeader);
#define DUMP_TYPE(T) printf(" %d: \"%s\",\n", i::T, #T);
printf("INSTANCE_TYPES = {\n");
INSTANCE_TYPE_LIST(DUMP_TYPE)
printf("}\n");
#undef DUMP_TYPE
// Dump the KNOWN_MAP table to the console.
printf("\n# List of known V8 maps.\n");
#define ROOT_LIST_CASE(type, name, camel_name) \
if (n == NULL && o == heap->name()) n = #camel_name;
#define STRUCT_LIST_CASE(upper_name, camel_name, name) \
if (n == NULL && o == heap->name##_map()) n = #camel_name "Map";
i::HeapObjectIterator it(heap->map_space());
printf("KNOWN_MAPS = {\n");
for (i::Object* o = it.Next(); o != NULL; o = it.Next()) {
i::Map* m = i::Map::cast(o);
const char* n = NULL;
intptr_t p = reinterpret_cast<intptr_t>(m) & 0x7ffff;
int t = m->instance_type();
ROOT_LIST(ROOT_LIST_CASE)
STRUCT_LIST(STRUCT_LIST_CASE)
if (n == NULL) continue;
printf(" 0x%05" V8PRIxPTR ": (%d, \"%s\"),\n", p, t, n);
}
printf("}\n");
#undef STRUCT_LIST_CASE
#undef ROOT_LIST_CASE
// Dump the KNOWN_OBJECTS table to the console.
printf("\n# List of known V8 objects.\n");
#define ROOT_LIST_CASE(type, name, camel_name) \
if (n == NULL && o == heap->name()) { \
n = #camel_name; \
i = i::Heap::k##camel_name##RootIndex; \
}
i::OldSpaces spit(heap);
printf("KNOWN_OBJECTS = {\n");
for (i::PagedSpace* s = spit.next(); s != NULL; s = spit.next()) {
i::HeapObjectIterator it(s);
const char* sname = AllocationSpaceName(s->identity());
for (i::Object* o = it.Next(); o != NULL; o = it.Next()) {
const char* n = NULL;
i::Heap::RootListIndex i = i::Heap::kStrongRootListLength;
intptr_t p = reinterpret_cast<intptr_t>(o) & 0x7ffff;
ROOT_LIST(ROOT_LIST_CASE)
if (n == NULL) continue;
if (!i::Heap::RootIsImmortalImmovable(i)) continue;
printf(" (\"%s\", 0x%05" V8PRIxPTR "): \"%s\",\n", sname, p, n);
}
}
printf("}\n");
#undef ROOT_LIST_CASE
// Dump frame markers
printf("\n# List of known V8 Frame Markers.\n");
#define DUMP_MARKER(T, class) printf(" \"%s\",\n", #T);
printf("FRAME_MARKERS = (\n");
STACK_FRAME_TYPE_LIST(DUMP_MARKER)
printf(")\n");
#undef DUMP_TYPE
}
printf("\n# This set of constants is generated from a %s build.\n", kBuild);
// Teardown.
isolate->Dispose();
v8::V8::ShutdownPlatform();
delete platform;
return 0;
}
} // namespace v8
int main(int argc, char* argv[]) { return v8::DumpHeapConstants(argv[0]); }

46
test/mkgrokdump/mkgrokdump.gyp Normal file
View File

@ -0,0 +1,46 @@
# Copyright 2017 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
{
'variables': {
'v8_code': 1,
},
'includes': ['../../gypfiles/toolchain.gypi', '../../gypfiles/features.gypi'],
'targets': [
{
'target_name': 'mkgrokdump',
'type': 'executable',
'dependencies': [
'../../src/v8.gyp:v8',
'../../src/v8.gyp:v8_libbase',
'../../src/v8.gyp:v8_libplatform',
],
'include_dirs': [
'../..',
],
'sources': [
'mkgrokdump.cc',
],
},
],
'conditions': [
['test_isolation_mode != "noop"', {
'targets': [
{
'target_name': 'mkgrokdump_run',
'type': 'none',
'dependencies': [
'mkgrokdump',
],
'includes': [
'../../gypfiles/isolate.gypi',
],
'sources': [
'mkgrokdump.isolate',
],
},
],
}],
],
}

17
test/mkgrokdump/mkgrokdump.isolate Normal file
View File

@ -0,0 +1,17 @@
# Copyright 2017 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
{
'variables': {
'files': [
'./mkgrokdump.status',
'./testcfg.py',
'../../tools/v8heapconst.py',
'<(PRODUCT_DIR)/mkgrokdump<(EXECUTABLE_SUFFIX)',
],
},
'includes': [
'../../src/base.isolate',
'../../tools/testrunner/testrunner.isolate',
],
}

10
test/mkgrokdump/mkgrokdump.status Normal file
View File

@ -0,0 +1,10 @@
# Copyright 2017 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
[
# Only test for default mode x64.
['variant != default or arch != x64', {
'*': [SKIP],
}], # variant != default or arch != x64
]

44
test/mkgrokdump/testcfg.py Normal file
View File

@ -0,0 +1,44 @@
# Copyright 2017 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
import difflib
from testrunner.local import testsuite
from testrunner.objects import testcase
class MkGrokdump(testsuite.TestSuite):
def __init__(self, name, root):
super(MkGrokdump, self).__init__(name, root)
def ListTests(self, context):
test = testcase.TestCase(self, self.shell())
return [test]
def GetFlagsForTestCase(self, testcase, context):
return []
def IsFailureOutput(self, testcase):
output = testcase.output
v8_path = os.path.dirname(os.path.dirname(os.path.abspath(self.root)))
expected_path = os.path.join(v8_path, "tools", "v8heapconst.py")
with open(expected_path) as f:
expected = f.read()
if expected != output.stdout:
if "generated from a non-shipping build" in output.stdout:
return False
assert "generated from a shipping build" in output.stdout
expected_lines = expected.splitlines(1)
actual_lines = output.stdout.splitlines(1)
output.stdout = ''.join(difflib.unified_diff(expected_lines, actual_lines))
return True
return False
def shell(self):
return "mkgrokdump"
def GetSuite(name, root):
return MkGrokdump(name, root)

2
tools/run-tests.py
View File

@ -70,6 +70,7 @@ TEST_MAP = {
"cctest",
"inspector",
"webkit",
"mkgrokdump",
"fuzzer",
"message",
"preparser",
@ -82,6 +83,7 @@ TEST_MAP = {
"mjsunit",
"cctest",
"inspector",
"mkgrokdump",
"fuzzer",
"message",
"preparser",

444
tools/v8heapconst.py
View File

@ -2,6 +2,9 @@
# Use of this source code is governed by a BSD-style license that can
# be found in the LICENSE file.
# This file is automatically generated by mkgrokdump and should not
# be modified manually.
# List of known V8 instance types.
INSTANCE_TYPES = {
0: "INTERNALIZED_STRING_TYPE",
@ -51,97 +54,100 @@ INSTANCE_TYPES = {
150: "ACCESSOR_PAIR_TYPE",
151: "ACCESS_CHECK_INFO_TYPE",
152: "INTERCEPTOR_INFO_TYPE",
153: "CALL_HANDLER_INFO_TYPE",
154: "FUNCTION_TEMPLATE_INFO_TYPE",
155: "OBJECT_TEMPLATE_INFO_TYPE",
156: "ALLOCATION_SITE_TYPE",
157: "ALLOCATION_MEMENTO_TYPE",
158: "SCRIPT_TYPE",
159: "TYPE_FEEDBACK_INFO_TYPE",
160: "ALIASED_ARGUMENTS_ENTRY_TYPE",
161: "PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE",
162: "PROMISE_REACTION_JOB_INFO_TYPE",
163: "DEBUG_INFO_TYPE",
164: "BREAK_POINT_INFO_TYPE",
165: "PROTOTYPE_INFO_TYPE",
166: "TUPLE2_TYPE",
167: "TUPLE3_TYPE",
168: "CONTEXT_EXTENSION_TYPE",
169: "CONSTANT_ELEMENTS_PAIR_TYPE",
170: "MODULE_TYPE",
171: "MODULE_INFO_ENTRY_TYPE",
172: "FIXED_ARRAY_TYPE",
173: "TRANSITION_ARRAY_TYPE",
174: "SHARED_FUNCTION_INFO_TYPE",
175: "CELL_TYPE",
176: "WEAK_CELL_TYPE",
177: "PROPERTY_CELL_TYPE",
178: "JS_PROXY_TYPE",
179: "JS_GLOBAL_OBJECT_TYPE",
180: "JS_GLOBAL_PROXY_TYPE",
181: "JS_SPECIAL_API_OBJECT_TYPE",
182: "JS_VALUE_TYPE",
183: "JS_MESSAGE_OBJECT_TYPE",
184: "JS_DATE_TYPE",
185: "JS_API_OBJECT_TYPE",
186: "JS_OBJECT_TYPE",
187: "JS_ARGUMENTS_TYPE",
188: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
189: "JS_GENERATOR_OBJECT_TYPE",
190: "JS_MODULE_NAMESPACE_TYPE",
191: "JS_ARRAY_TYPE",
192: "JS_ARRAY_BUFFER_TYPE",
193: "JS_TYPED_ARRAY_TYPE",
194: "JS_DATA_VIEW_TYPE",
195: "JS_SET_TYPE",
196: "JS_MAP_TYPE",
197: "JS_SET_ITERATOR_TYPE",
198: "JS_MAP_ITERATOR_TYPE",
199: "JS_WEAK_MAP_TYPE",
200: "JS_WEAK_SET_TYPE",
201: "JS_PROMISE_CAPABILITY_TYPE",
202: "JS_PROMISE_TYPE",
203: "JS_REGEXP_TYPE",
204: "JS_ERROR_TYPE",
205: "JS_ASYNC_FROM_SYNC_ITERATOR_TYPE",
206: "JS_STRING_ITERATOR_TYPE",
207: "JS_TYPED_ARRAY_KEY_ITERATOR_TYPE",
208: "JS_FAST_ARRAY_KEY_ITERATOR_TYPE",
209: "JS_GENERIC_ARRAY_KEY_ITERATOR_TYPE",
210: "JS_UINT8_ARRAY_KEY_VALUE_ITERATOR_TYPE",
211: "JS_INT8_ARRAY_KEY_VALUE_ITERATOR_TYPE",
212: "JS_UINT16_ARRAY_KEY_VALUE_ITERATOR_TYPE",
213: "JS_INT16_ARRAY_KEY_VALUE_ITERATOR_TYPE",
214: "JS_UINT32_ARRAY_KEY_VALUE_ITERATOR_TYPE",
215: "JS_INT32_ARRAY_KEY_VALUE_ITERATOR_TYPE",
216: "JS_FLOAT32_ARRAY_KEY_VALUE_ITERATOR_TYPE",
217: "JS_FLOAT64_ARRAY_KEY_VALUE_ITERATOR_TYPE",
218: "JS_UINT8_CLAMPED_ARRAY_KEY_VALUE_ITERATOR_TYPE",
219: "JS_FAST_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE",
220: "JS_FAST_HOLEY_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE",
221: "JS_FAST_ARRAY_KEY_VALUE_ITERATOR_TYPE",
222: "JS_FAST_HOLEY_ARRAY_KEY_VALUE_ITERATOR_TYPE",
223: "JS_FAST_DOUBLE_ARRAY_KEY_VALUE_ITERATOR_TYPE",
224: "JS_FAST_HOLEY_DOUBLE_ARRAY_KEY_VALUE_ITERATOR_TYPE",
225: "JS_GENERIC_ARRAY_KEY_VALUE_ITERATOR_TYPE",
226: "JS_UINT8_ARRAY_VALUE_ITERATOR_TYPE",
227: "JS_INT8_ARRAY_VALUE_ITERATOR_TYPE",
228: "JS_UINT16_ARRAY_VALUE_ITERATOR_TYPE",
229: "JS_INT16_ARRAY_VALUE_ITERATOR_TYPE",
230: "JS_UINT32_ARRAY_VALUE_ITERATOR_TYPE",
231: "JS_INT32_ARRAY_VALUE_ITERATOR_TYPE",
232: "JS_FLOAT32_ARRAY_VALUE_ITERATOR_TYPE",
233: "JS_FLOAT64_ARRAY_VALUE_ITERATOR_TYPE",
234: "JS_UINT8_CLAMPED_ARRAY_VALUE_ITERATOR_TYPE",
235: "JS_FAST_SMI_ARRAY_VALUE_ITERATOR_TYPE",
236: "JS_FAST_HOLEY_SMI_ARRAY_VALUE_ITERATOR_TYPE",
237: "JS_FAST_ARRAY_VALUE_ITERATOR_TYPE",
238: "JS_FAST_HOLEY_ARRAY_VALUE_ITERATOR_TYPE",
239: "JS_FAST_DOUBLE_ARRAY_VALUE_ITERATOR_TYPE",
240: "JS_FAST_HOLEY_DOUBLE_ARRAY_VALUE_ITERATOR_TYPE",
241: "JS_GENERIC_ARRAY_VALUE_ITERATOR_TYPE",
242: "JS_BOUND_FUNCTION_TYPE",
243: "JS_FUNCTION_TYPE",
153: "FUNCTION_TEMPLATE_INFO_TYPE",
154: "OBJECT_TEMPLATE_INFO_TYPE",
155: "ALLOCATION_SITE_TYPE",
156: "ALLOCATION_MEMENTO_TYPE",
157: "SCRIPT_TYPE",
158: "ALIASED_ARGUMENTS_ENTRY_TYPE",
159: "PROMISE_RESOLVE_THENABLE_JOB_INFO_TYPE",
160: "PROMISE_REACTION_JOB_INFO_TYPE",
161: "DEBUG_INFO_TYPE",
162: "STACK_FRAME_INFO_TYPE",
163: "PROTOTYPE_INFO_TYPE",
164: "TUPLE2_TYPE",
165: "TUPLE3_TYPE",
166: "CONTEXT_EXTENSION_TYPE",
167: "MODULE_TYPE",
168: "MODULE_INFO_ENTRY_TYPE",
169: "ASYNC_GENERATOR_REQUEST_TYPE",
170: "FIXED_ARRAY_TYPE",
171: "TRANSITION_ARRAY_TYPE",
172: "SHARED_FUNCTION_INFO_TYPE",
173: "CELL_TYPE",
174: "WEAK_CELL_TYPE",
175: "PROPERTY_CELL_TYPE",
176: "PADDING_TYPE_1",
177: "PADDING_TYPE_2",
178: "PADDING_TYPE_3",
179: "PADDING_TYPE_4",
180: "JS_PROXY_TYPE",
181: "JS_GLOBAL_OBJECT_TYPE",
182: "JS_GLOBAL_PROXY_TYPE",
183: "JS_SPECIAL_API_OBJECT_TYPE",
184: "JS_VALUE_TYPE",
185: "JS_MESSAGE_OBJECT_TYPE",
186: "JS_DATE_TYPE",
187: "JS_API_OBJECT_TYPE",
188: "JS_OBJECT_TYPE",
189: "JS_ARGUMENTS_TYPE",
190: "JS_CONTEXT_EXTENSION_OBJECT_TYPE",
191: "JS_GENERATOR_OBJECT_TYPE",
192: "JS_ASYNC_GENERATOR_OBJECT_TYPE",
193: "JS_MODULE_NAMESPACE_TYPE",
194: "JS_ARRAY_TYPE",
195: "JS_ARRAY_BUFFER_TYPE",
196: "JS_TYPED_ARRAY_TYPE",
197: "JS_DATA_VIEW_TYPE",
198: "JS_SET_TYPE",
199: "JS_MAP_TYPE",
200: "JS_SET_ITERATOR_TYPE",
201: "JS_MAP_ITERATOR_TYPE",
202: "JS_WEAK_MAP_TYPE",
203: "JS_WEAK_SET_TYPE",
204: "JS_PROMISE_CAPABILITY_TYPE",
205: "JS_PROMISE_TYPE",
206: "JS_REGEXP_TYPE",
207: "JS_ERROR_TYPE",
208: "JS_ASYNC_FROM_SYNC_ITERATOR_TYPE",
209: "JS_STRING_ITERATOR_TYPE",
210: "JS_TYPED_ARRAY_KEY_ITERATOR_TYPE",
211: "JS_FAST_ARRAY_KEY_ITERATOR_TYPE",
212: "JS_GENERIC_ARRAY_KEY_ITERATOR_TYPE",
213: "JS_UINT8_ARRAY_KEY_VALUE_ITERATOR_TYPE",
214: "JS_INT8_ARRAY_KEY_VALUE_ITERATOR_TYPE",
215: "JS_UINT16_ARRAY_KEY_VALUE_ITERATOR_TYPE",
216: "JS_INT16_ARRAY_KEY_VALUE_ITERATOR_TYPE",
217: "JS_UINT32_ARRAY_KEY_VALUE_ITERATOR_TYPE",
218: "JS_INT32_ARRAY_KEY_VALUE_ITERATOR_TYPE",
219: "JS_FLOAT32_ARRAY_KEY_VALUE_ITERATOR_TYPE",
220: "JS_FLOAT64_ARRAY_KEY_VALUE_ITERATOR_TYPE",
221: "JS_UINT8_CLAMPED_ARRAY_KEY_VALUE_ITERATOR_TYPE",
222: "JS_FAST_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE",
223: "JS_FAST_HOLEY_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE",
224: "JS_FAST_ARRAY_KEY_VALUE_ITERATOR_TYPE",
225: "JS_FAST_HOLEY_ARRAY_KEY_VALUE_ITERATOR_TYPE",
226: "JS_FAST_DOUBLE_ARRAY_KEY_VALUE_ITERATOR_TYPE",
227: "JS_FAST_HOLEY_DOUBLE_ARRAY_KEY_VALUE_ITERATOR_TYPE",
228: "JS_GENERIC_ARRAY_KEY_VALUE_ITERATOR_TYPE",
229: "JS_UINT8_ARRAY_VALUE_ITERATOR_TYPE",
230: "JS_INT8_ARRAY_VALUE_ITERATOR_TYPE",
231: "JS_UINT16_ARRAY_VALUE_ITERATOR_TYPE",
232: "JS_INT16_ARRAY_VALUE_ITERATOR_TYPE",
233: "JS_UINT32_ARRAY_VALUE_ITERATOR_TYPE",
234: "JS_INT32_ARRAY_VALUE_ITERATOR_TYPE",
235: "JS_FLOAT32_ARRAY_VALUE_ITERATOR_TYPE",
236: "JS_FLOAT64_ARRAY_VALUE_ITERATOR_TYPE",
237: "JS_UINT8_CLAMPED_ARRAY_VALUE_ITERATOR_TYPE",
238: "JS_FAST_SMI_ARRAY_VALUE_ITERATOR_TYPE",
239: "JS_FAST_HOLEY_SMI_ARRAY_VALUE_ITERATOR_TYPE",
240: "JS_FAST_ARRAY_VALUE_ITERATOR_TYPE",
241: "JS_FAST_HOLEY_ARRAY_VALUE_ITERATOR_TYPE",
242: "JS_FAST_DOUBLE_ARRAY_VALUE_ITERATOR_TYPE",
243: "JS_FAST_HOLEY_DOUBLE_ARRAY_VALUE_ITERATOR_TYPE",
244: "JS_GENERIC_ARRAY_VALUE_ITERATOR_TYPE",
245: "JS_BOUND_FUNCTION_TYPE",
246: "JS_FUNCTION_TYPE",
}
# List of known V8 maps.
@ -149,7 +155,7 @@ KNOWN_MAPS = {
0x02201: (137, "FreeSpaceMap"),
0x02259: (131, "MetaMap"),
0x022b1: (130, "NullMap"),
0x02309: (172, "FixedArrayMap"),
0x02309: (170, "FixedArrayMap"),
0x02361: (8, "OneByteInternalizedStringMap"),
0x023b9: (148, "OnePointerFillerMap"),
0x02411: (148, "TwoPointerFillerMap"),
@ -159,100 +165,98 @@ KNOWN_MAPS = {
0x02571: (130, "TheHoleMap"),
0x025c9: (130, "BooleanMap"),
0x02621: (135, "ByteArrayMap"),
0x02679: (172, "FixedCOWArrayMap"),
0x026d1: (172, "HashTableMap"),
0x02679: (170, "FixedCOWArrayMap"),
0x026d1: (170, "HashTableMap"),
0x02729: (128, "SymbolMap"),
0x02781: (72, "OneByteStringMap"),
0x027d9: (172, "ScopeInfoMap"),
0x02831: (174, "SharedFunctionInfoMap"),
0x027d9: (170, "ScopeInfoMap"),
0x02831: (172, "SharedFunctionInfoMap"),
0x02889: (132, "CodeMap"),
0x028e1: (172, "FunctionContextMap"),
0x02939: (175, "CellMap"),
0x02991: (176, "WeakCellMap"),
0x029e9: (177, "GlobalPropertyCellMap"),
0x028e1: (170, "FunctionContextMap"),
0x02939: (173, "CellMap"),
0x02991: (174, "WeakCellMap"),
0x029e9: (175, "GlobalPropertyCellMap"),
0x02a41: (134, "ForeignMap"),
0x02a99: (173, "TransitionArrayMap"),
0x02a99: (171, "TransitionArrayMap"),
0x02af1: (130, "ArgumentsMarkerMap"),
0x02b49: (172, "NativeContextMap"),
0x02ba1: (172, "ModuleContextMap"),
0x02bf9: (172, "EvalContextMap"),
0x02c51: (172, "ScriptContextMap"),
0x02ca9: (172, "BlockContextMap"),
0x02d01: (172, "CatchContextMap"),
0x02d59: (172, "WithContextMap"),
0x02db1: (147, "FixedDoubleArrayMap"),
0x02e09: (133, "MutableHeapNumberMap"),
0x02e61: (172, "OrderedHashTableMap"),
0x02eb9: (172, "SloppyArgumentsElementsMap"),
0x02f11: (183, "JSMessageObjectMap"),
0x02f69: (136, "BytecodeArrayMap"),
0x02fc1: (172, "ModuleInfoMap"),
0x03019: (175, "NoClosuresCellMap"),
0x03071: (175, "OneClosureCellMap"),
0x030c9: (175, "ManyClosuresCellMap"),
0x03121: (64, "StringMap"),
0x03179: (73, "ConsOneByteStringMap"),
0x031d1: (65, "ConsStringMap"),
0x03229: (77, "ThinOneByteStringMap"),
0x03281: (69, "ThinStringMap"),
0x032d9: (67, "SlicedStringMap"),
0x03331: (75, "SlicedOneByteStringMap"),
0x03389: (66, "ExternalStringMap"),
0x033e1: (82, "ExternalStringWithOneByteDataMap"),
0x03439: (74, "ExternalOneByteStringMap"),
0x03491: (98, "ShortExternalStringMap"),
0x034e9: (114, "ShortExternalStringWithOneByteDataMap"),
0x03541: (0, "InternalizedStringMap"),
0x03599: (2, "ExternalInternalizedStringMap"),
0x035f1: (18, "ExternalInternalizedStringWithOneByteDataMap"),
0x03649: (10, "ExternalOneByteInternalizedStringMap"),
0x036a1: (34, "ShortExternalInternalizedStringMap"),
0x036f9: (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
0x03751: (42, "ShortExternalOneByteInternalizedStringMap"),
0x037a9: (106, "ShortExternalOneByteStringMap"),
0x03801: (172, "FeedbackVectorMap"),
0x03859: (130, "ExceptionMap"),
0x038b1: (130, "TerminationExceptionMap"),
0x03909: (130, "OptimizedOutMap"),
0x03961: (130, "StaleRegisterMap"),
0x039b9: (172, "DebugEvaluateContextMap"),
0x03a11: (172, "ScriptContextTableMap"),
0x03a69: (172, "UnseededNumberDictionaryMap"),
0x03ac1: (186, "ExternalMap"),
0x03b19: (106, "NativeSourceStringMap"),
0x03b71: (139, "FixedUint8ArrayMap"),
0x03bc9: (138, "FixedInt8ArrayMap"),
0x03c21: (141, "FixedUint16ArrayMap"),
0x03c79: (140, "FixedInt16ArrayMap"),
0x03cd1: (143, "FixedUint32ArrayMap"),
0x03d29: (142, "FixedInt32ArrayMap"),
0x03d81: (144, "FixedFloat32ArrayMap"),
0x03dd9: (145, "FixedFloat64ArrayMap"),
0x03e31: (146, "FixedUint8ClampedArrayMap"),
0x03e89: (158, "ScriptMap"),
0x02b49: (130, "ExceptionMap"),
0x02ba1: (130, "TerminationExceptionMap"),
0x02bf9: (130, "OptimizedOutMap"),
0x02c51: (130, "StaleRegisterMap"),
0x02ca9: (170, "NativeContextMap"),
0x02d01: (170, "ModuleContextMap"),
0x02d59: (170, "EvalContextMap"),
0x02db1: (170, "ScriptContextMap"),
0x02e09: (170, "BlockContextMap"),
0x02e61: (170, "CatchContextMap"),
0x02eb9: (170, "WithContextMap"),
0x02f11: (147, "FixedDoubleArrayMap"),
0x02f69: (133, "MutableHeapNumberMap"),
0x02fc1: (170, "OrderedHashTableMap"),
0x03019: (170, "SloppyArgumentsElementsMap"),
0x03071: (185, "JSMessageObjectMap"),
0x030c9: (136, "BytecodeArrayMap"),
0x03121: (170, "ModuleInfoMap"),
0x03179: (173, "NoClosuresCellMap"),
0x031d1: (173, "OneClosureCellMap"),
0x03229: (173, "ManyClosuresCellMap"),
0x03281: (64, "StringMap"),
0x032d9: (73, "ConsOneByteStringMap"),
0x03331: (65, "ConsStringMap"),
0x03389: (77, "ThinOneByteStringMap"),
0x033e1: (69, "ThinStringMap"),
0x03439: (67, "SlicedStringMap"),
0x03491: (75, "SlicedOneByteStringMap"),
0x034e9: (66, "ExternalStringMap"),
0x03541: (82, "ExternalStringWithOneByteDataMap"),
0x03599: (74, "ExternalOneByteStringMap"),
0x035f1: (98, "ShortExternalStringMap"),
0x03649: (114, "ShortExternalStringWithOneByteDataMap"),
0x036a1: (0, "InternalizedStringMap"),
0x036f9: (2, "ExternalInternalizedStringMap"),
0x03751: (18, "ExternalInternalizedStringWithOneByteDataMap"),
0x037a9: (10, "ExternalOneByteInternalizedStringMap"),
0x03801: (34, "ShortExternalInternalizedStringMap"),
0x03859: (50, "ShortExternalInternalizedStringWithOneByteDataMap"),
0x038b1: (42, "ShortExternalOneByteInternalizedStringMap"),
0x03909: (106, "ShortExternalOneByteStringMap"),
0x03961: (139, "FixedUint8ArrayMap"),
0x039b9: (138, "FixedInt8ArrayMap"),
0x03a11: (141, "FixedUint16ArrayMap"),
0x03a69: (140, "FixedInt16ArrayMap"),
0x03ac1: (143, "FixedUint32ArrayMap"),
0x03b19: (142, "FixedInt32ArrayMap"),
0x03b71: (144, "FixedFloat32ArrayMap"),
0x03bc9: (145, "FixedFloat64ArrayMap"),
0x03c21: (146, "FixedUint8ClampedArrayMap"),
0x03c79: (157, "ScriptMap"),
0x03cd1: (170, "FeedbackVectorMap"),
0x03d29: (170, "DebugEvaluateContextMap"),
0x03d81: (170, "ScriptContextTableMap"),
0x03dd9: (170, "UnseededNumberDictionaryMap"),
0x03e31: (188, "ExternalMap"),
0x03e89: (106, "NativeSourceStringMap"),
0x03ee1: (152, "InterceptorInfoMap"),
0x03f39: (201, "JSPromiseCapabilityMap"),
0x03f39: (204, "JSPromiseCapabilityMap"),
0x03f91: (149, "AccessorInfoMap"),
0x03fe9: (150, "AccessorPairMap"),
0x04041: (151, "AccessCheckInfoMap"),
0x04099: (153, "CallHandlerInfoMap"),
0x040f1: (154, "FunctionTemplateInfoMap"),
0x04149: (155, "ObjectTemplateInfoMap"),
0x041a1: (156, "AllocationSiteMap"),
0x041f9: (157, "AllocationMementoMap"),
0x04251: (159, "TypeFeedbackInfoMap"),
0x042a9: (160, "AliasedArgumentsEntryMap"),
0x04301: (161, "PromiseResolveThenableJobInfoMap"),
0x04359: (162, "PromiseReactionJobInfoMap"),
0x043b1: (163, "DebugInfoMap"),
0x04409: (164, "BreakPointInfoMap"),
0x04461: (165, "PrototypeInfoMap"),
0x044b9: (166, "Tuple2Map"),
0x04511: (167, "Tuple3Map"),
0x04569: (168, "ContextExtensionMap"),
0x045c1: (169, "ConstantElementsPairMap"),
0x04619: (170, "ModuleMap"),
0x04671: (171, "ModuleInfoEntryMap"),
0x04099: (153, "FunctionTemplateInfoMap"),
0x040f1: (154, "ObjectTemplateInfoMap"),
0x04149: (155, "AllocationSiteMap"),
0x041a1: (156, "AllocationMementoMap"),
0x041f9: (158, "AliasedArgumentsEntryMap"),
0x04251: (159, "PromiseResolveThenableJobInfoMap"),
0x042a9: (160, "PromiseReactionJobInfoMap"),
0x04301: (161, "DebugInfoMap"),
0x04359: (162, "StackFrameInfoMap"),
0x043b1: (163, "PrototypeInfoMap"),
0x04409: (164, "Tuple2Map"),
0x04461: (165, "Tuple3Map"),
0x044b9: (166, "ContextExtensionMap"),
0x04511: (167, "ModuleMap"),
0x04569: (168, "ModuleInfoEntryMap"),
0x045c1: (169, "AsyncGeneratorRequestMap"),
}
# List of known V8 objects.
@ -268,56 +272,40 @@ KNOWN_OBJECTS = {
("OLD_SPACE", 0x023b1): "TrueValue",
("OLD_SPACE", 0x02421): "FalseValue",
("OLD_SPACE", 0x02471): "empty_string",
("OLD_SPACE", 0x02489): "ArgumentsMarker",
("OLD_SPACE", 0x024e1): "EmptyByteArray",
("OLD_SPACE", 0x024f1): "EmptyWeakCell",
("OLD_SPACE", 0x02509): "InfinityValue",
("OLD_SPACE", 0x02519): "MinusZeroValue",
("OLD_SPACE", 0x02529): "MinusInfinityValue",
("OLD_SPACE", 0x04979): "EmptyScopeInfo",
("OLD_SPACE", 0x04989): "Exception",
("OLD_SPACE", 0x049e1): "TerminationException",
("OLD_SPACE", 0x04a41): "OptimizedOut",
("OLD_SPACE", 0x04a99): "StaleRegister",
("OLD_SPACE", 0x04af1): "EmptyFixedUint8Array",
("OLD_SPACE", 0x04b11): "EmptyFixedInt8Array",
("OLD_SPACE", 0x04b31): "EmptyFixedUint16Array",
("OLD_SPACE", 0x04b51): "EmptyFixedInt16Array",
("OLD_SPACE", 0x04b71): "EmptyFixedUint32Array",
("OLD_SPACE", 0x04b91): "EmptyFixedInt32Array",
("OLD_SPACE", 0x04bb1): "EmptyFixedFloat32Array",
("OLD_SPACE", 0x04bd1): "EmptyFixedFloat64Array",
("OLD_SPACE", 0x04bf1): "EmptyFixedUint8ClampedArray",
("OLD_SPACE", 0x04c11): "EmptyScript",
("OLD_SPACE", 0x04c99): "UndefinedCell",
("OLD_SPACE", 0x04ca9): "EmptySloppyArgumentsElements",
("OLD_SPACE", 0x04cc9): "EmptySlowElementDictionary",
("OLD_SPACE", 0x04d19): "EmptyPropertyCell",
("OLD_SPACE", 0x04d39): "ArrayProtector",
("OLD_SPACE", 0x04d59): "IsConcatSpreadableProtector",
("OLD_SPACE", 0x04d69): "SpeciesProtector",
("OLD_SPACE", 0x04d79): "StringLengthProtector",
("OLD_SPACE", 0x04d99): "FastArrayIterationProtector",
("OLD_SPACE", 0x04da9): "ArrayIteratorProtector",
("OLD_SPACE", 0x04dc9): "ArrayBufferNeuteringProtector",
("OLD_SPACE", 0x04de9): "NumberStringCache",
("OLD_SPACE", 0x05df9): "SingleCharacterStringCache",
("OLD_SPACE", 0x06669): "StringSplitCache",
("OLD_SPACE", 0x06e79): "RegExpMultipleCache",
("OLD_SPACE", 0x07689): "NativesSourceCache",
("OLD_SPACE", 0x07931): "ExtraNativesSourceCache",
("OLD_SPACE", 0x07969): "ExperimentalExtraNativesSourceCache",
("OLD_SPACE", 0x07981): "EmptyPropertiesDictionary",
("OLD_SPACE", 0x079d1): "ScriptList",
("OLD_SPACE", 0x22019): "CodeStubs",
("OLD_SPACE", 0x2f199): "WeakObjectToCodeTable",
("OLD_SPACE", 0x2f3c1): "WeakNewSpaceObjectToCodeList",
("OLD_SPACE", 0x2f451): "NoScriptSharedFunctionInfos",
("OLD_SPACE", 0x4abd9): "MessageListeners",
("OLD_SPACE", 0x4abf9): "NoOpInterceptorInfo",
("OLD_SPACE", 0x531d1): "StringTable",
("CODE_SPACE", 0x2cde1): "JsEntryCode",
("CODE_SPACE", 0x31241): "JsConstructEntryCode",
("OLD_SPACE", 0x02489): "EmptyScopeInfo",
("OLD_SPACE", 0x02499): "ArgumentsMarker",
("OLD_SPACE", 0x024f1): "Exception",
("OLD_SPACE", 0x02549): "TerminationException",
("OLD_SPACE", 0x025a9): "OptimizedOut",
("OLD_SPACE", 0x02601): "StaleRegister",
("OLD_SPACE", 0x02659): "EmptyByteArray",
("OLD_SPACE", 0x02669): "EmptyFixedUint8Array",
("OLD_SPACE", 0x02689): "EmptyFixedInt8Array",
("OLD_SPACE", 0x026a9): "EmptyFixedUint16Array",
("OLD_SPACE", 0x026c9): "EmptyFixedInt16Array",
("OLD_SPACE", 0x026e9): "EmptyFixedUint32Array",
("OLD_SPACE", 0x02709): "EmptyFixedInt32Array",
("OLD_SPACE", 0x02729): "EmptyFixedFloat32Array",
("OLD_SPACE", 0x02749): "EmptyFixedFloat64Array",
("OLD_SPACE", 0x02769): "EmptyFixedUint8ClampedArray",
("OLD_SPACE", 0x02789): "EmptyScript",
("OLD_SPACE", 0x02811): "UndefinedCell",
("OLD_SPACE", 0x02821): "EmptySloppyArgumentsElements",
("OLD_SPACE", 0x02841): "EmptySlowElementDictionary",
("OLD_SPACE", 0x02891): "EmptyPropertyCell",
("OLD_SPACE", 0x028b1): "EmptyWeakCell",
("OLD_SPACE", 0x028c9): "ArrayProtector",
("OLD_SPACE", 0x028e9): "IsConcatSpreadableProtector",
("OLD_SPACE", 0x028f9): "SpeciesProtector",
("OLD_SPACE", 0x02909): "StringLengthProtector",
("OLD_SPACE", 0x02929): "FastArrayIterationProtector",
("OLD_SPACE", 0x02939): "ArrayIteratorProtector",
("OLD_SPACE", 0x02959): "ArrayBufferNeuteringProtector",
("OLD_SPACE", 0x029f9): "InfinityValue",
("OLD_SPACE", 0x02a09): "MinusZeroValue",
("OLD_SPACE", 0x02a19): "MinusInfinityValue",
("CODE_SPACE", 0x04001): "JsEntryCode",
("CODE_SPACE", 0x04181): "JsConstructEntryCode",
}
# List of known V8 Frame Markers.
@ -340,3 +328,5 @@ FRAME_MARKERS = (
"BUILTIN",
"BUILTIN_EXIT",
)
# This set of constants is generated from a shipping build.

30
tools/v8heapconst.py.tmpl
View File

@ -1,30 +0,0 @@
# Copyright 2013 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.
# This file is automatically generated from the V8 source and should not
# be modified manually, run 'make grokdump' instead to update this file.

4
tools/verify_source_deps.py
View File

@ -31,6 +31,7 @@ GYP_FILES = [
os.path.join(V8_BASE, 'test', 'fuzzer', 'fuzzer.gyp'),
os.path.join(V8_BASE, 'test', 'unittests', 'unittests.gyp'),
os.path.join(V8_BASE, 'test', 'inspector', 'inspector.gyp'),
os.path.join(V8_BASE, 'test', 'mkgrokdump', 'mkgrokdump.gyp'),
os.path.join(V8_BASE, 'testing', 'gmock.gyp'),
os.path.join(V8_BASE, 'testing', 'gtest.gyp'),
os.path.join(V8_BASE, 'tools', 'parser-shell.gyp'),
@ -49,6 +50,7 @@ ALL_GYP_PREFIXES = [
os.path.join('test', 'fuzzer'),
os.path.join('test', 'unittests'),
os.path.join('test', 'inspector'),
os.path.join('test', 'mkgrokdump'),
]
GYP_UNSUPPORTED_FEATURES = [
@ -64,6 +66,7 @@ GN_FILES = [
os.path.join(V8_BASE, 'test', 'cctest', 'BUILD.gn'),
os.path.join(V8_BASE, 'test', 'unittests', 'BUILD.gn'),
os.path.join(V8_BASE, 'test', 'inspector', 'BUILD.gn'),
os.path.join(V8_BASE, 'test', 'mkgrokdump', 'BUILD.gn'),
os.path.join(V8_BASE, 'tools', 'BUILD.gn'),
]
@ -88,6 +91,7 @@ ALL_GN_PREFIXES = [
os.path.join('test', 'cctest'),
os.path.join('test', 'unittests'),
os.path.join('test', 'inspector'),
os.path.join('test', 'mkgrokdump'),
]
def pathsplit(path):