Skip to content

V
V8
Commit 477f0055 authored by yangguo's avatar yangguo Committed by Commit bot
Browse files
Options

Introduce mkgrokdump to update tools/v8heapconst.py. 

- 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-Original-Commit-Position: refs/heads/master@{#44687}
Committed: https://chromium.googlesource.com/v8/v8/+/0cc0c130fa56f129c90c2a74cb01bda85df5e42a
Review-Url: https://codereview.chromium.org/2809653003
Cr-Commit-Position: refs/heads/master@{#44710}
parent 07e163bd
Hide whitespace changes
Inline Side-by-side
Showing with 606 additions and 405 deletions
Makefile
View file @ 477f0055
......@@ -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' > $@
......
gypfiles/all.gyp
View file @ 477f0055
......@@ -10,6 +10,7 @@
'dependencies': [
'../src/d8.gyp:d8',
'../test/inspector/inspector.gyp:*',
'../test/mkgrokdump/mkgrokdump.gyp:*',
],
'conditions': [
['component!="shared_library"', {
......
src/d8.cc
View file @ 477f0055
......@@ -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
......
src/d8.h
View file @ 477f0055
......@@ -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;
......
src/heap/heap.cc
View file @ 477f0055
......@@ -2926,7 +2926,6 @@ bool Heap::RootCanBeWrittenAfterInitialization(Heap::RootListIndex root_index) {
case kInstanceofCacheMapRootIndex:
case kInstanceofCacheAnswerRootIndex:
case kCodeStubsRootIndex:
case kEmptyScriptRootIndex:
case kScriptListRootIndex:
case kMaterializedObjectsRootIndex:
case kMicrotaskQueueRootIndex:
......
src/heap/heap.h
View file @ 477f0055
......@@ -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(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(CatchContextMap) \
V(WithContextMap) \
V(BlockContextMap) \
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(EvalContextMap) \
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(UndefinedMap) \
V(SharedFunctionInfoMap) \
V(SloppyArgumentsElementsMap) \
V(SpeciesProtector) \
V(StaleRegister) \
V(StringLengthProtector) \
V(SymbolMap) \
V(TerminationException) \
V(TheHoleMap) \
V(NullMap) \
V(BooleanMap) \
V(TheHoleValue) \
V(TransitionArrayMap) \
V(TrueValue) \
V(TwoPointerFillerMap) \
V(UndefinedCell) \
V(UndefinedMap) \
V(UndefinedValue) \
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(empty_string) \
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);
......
test/BUILD.gn
View file @ 477f0055
......@@ -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",
......
test/bot_default.isolate
View file @ 477f0055
......@@ -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',
......
test/default.isolate
View file @ 477f0055
......@@ -15,6 +15,7 @@
'intl/intl.isolate',
'message/message.isolate',
'mjsunit/mjsunit.isolate',
'mkgrokdump/mkgrokdump.isolate',
'preparser/preparser.isolate',
'unittests/unittests.isolate',
],
......
test/mkgrokdump/BUILD.gn 0 → 100644
View file @ 477f0055
# 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",
]
}
test/mkgrokdump/DEPS 0 → 100644
View file @ 477f0055
include_rules = [
"+src",
]
test/mkgrokdump/mkgrokdump.cc 0 → 100644
View file @ 477f0055
// 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]); }
test/mkgrokdump/mkgrokdump.gyp 0 → 100644
View file @ 477f0055
# 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',
],
},
],
}],
],
}
test/mkgrokdump/mkgrokdump.isolate 0 → 100644
View file @ 477f0055
# 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',
],
}
test/mkgrokdump/mkgrokdump.status 0 → 100644
View file @ 477f0055
# 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
]
test/mkgrokdump/testcfg.py 0 → 100644
View file @ 477f0055
# 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()
actual_lines = output.stdout.splitlines()
output.stdout = "%s differs from mkgrokdump output:\n\n" % expected_path
output.stdout += '\n'.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)
tools/run-tests.py
View file @ 477f0055
......@@ -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",
......
tools/v8heapconst.py
View file @ 477f0055
......@@ -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.
tools/v8heapconst.py.tmpl deleted 100644 → 0
View file @ 07e163bd
# 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.
tools/verify_source_deps.py
View file @ 477f0055
......@@ -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):
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment