f0b21ef72c
R=peria@chromium.org, vogelheim@chromium.org BUG=chromium:617892 NOPRESUBMIT=true Review-Url: https://codereview.chromium.org/2495213003 Cr-Commit-Position: refs/heads/master@{#40981}
453 lines
19 KiB
C++
453 lines
19 KiB
C++
// Copyright 2016 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 "src/external-reference-table.h"
|
|
|
|
#include "src/accessors.h"
|
|
#include "src/assembler.h"
|
|
#include "src/builtins/builtins.h"
|
|
#include "src/counters.h"
|
|
#include "src/deoptimizer.h"
|
|
#include "src/ic/stub-cache.h"
|
|
|
|
#if defined(DEBUG) && defined(V8_OS_LINUX) && !defined(V8_OS_ANDROID)
|
|
#define SYMBOLIZE_FUNCTION
|
|
#include <execinfo.h>
|
|
#endif // DEBUG && V8_OS_LINUX && !V8_OS_ANDROID
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
// Forward declarations for C++ builtins.
|
|
#define FORWARD_DECLARE(Name) \
|
|
Object* Builtin_##Name(int argc, Object** args, Isolate* isolate);
|
|
BUILTIN_LIST_C(FORWARD_DECLARE)
|
|
#undef FORWARD_DECLARE
|
|
|
|
ExternalReferenceTable* ExternalReferenceTable::instance(Isolate* isolate) {
|
|
ExternalReferenceTable* external_reference_table =
|
|
isolate->external_reference_table();
|
|
if (external_reference_table == NULL) {
|
|
external_reference_table = new ExternalReferenceTable(isolate);
|
|
isolate->set_external_reference_table(external_reference_table);
|
|
}
|
|
return external_reference_table;
|
|
}
|
|
|
|
ExternalReferenceTable::ExternalReferenceTable(Isolate* isolate) {
|
|
// nullptr is preserved through serialization/deserialization.
|
|
Add(nullptr, "nullptr");
|
|
AddReferences(isolate);
|
|
AddBuiltins(isolate);
|
|
AddRuntimeFunctions(isolate);
|
|
AddIsolateAddresses(isolate);
|
|
AddAccessors(isolate);
|
|
AddStubCache(isolate);
|
|
AddDeoptEntries(isolate);
|
|
AddApiReferences(isolate);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void ExternalReferenceTable::ResetCount() {
|
|
for (ExternalReferenceEntry& entry : refs_) entry.count = 0;
|
|
}
|
|
|
|
void ExternalReferenceTable::PrintCount() {
|
|
for (int i = 0; i < refs_.length(); i++) {
|
|
v8::base::OS::Print("index=%5d count=%5d %-60s\n", i, refs_[i].count,
|
|
refs_[i].name);
|
|
}
|
|
}
|
|
#endif // DEBUG
|
|
|
|
// static
|
|
const char* ExternalReferenceTable::ResolveSymbol(void* address) {
|
|
#ifdef SYMBOLIZE_FUNCTION
|
|
return backtrace_symbols(&address, 1)[0];
|
|
#else
|
|
return "<unresolved>";
|
|
#endif // SYMBOLIZE_FUNCTION
|
|
}
|
|
|
|
void ExternalReferenceTable::AddReferences(Isolate* isolate) {
|
|
// Miscellaneous
|
|
Add(ExternalReference::roots_array_start(isolate).address(),
|
|
"Heap::roots_array_start()");
|
|
Add(ExternalReference::address_of_stack_limit(isolate).address(),
|
|
"StackGuard::address_of_jslimit()");
|
|
Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
|
|
"StackGuard::address_of_real_jslimit()");
|
|
Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
|
|
"Heap::NewSpaceAllocationLimitAddress()");
|
|
Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
|
|
"Heap::NewSpaceAllocationTopAddress()");
|
|
Add(ExternalReference::mod_two_doubles_operation(isolate).address(),
|
|
"mod_two_doubles");
|
|
Add(ExternalReference::handle_scope_next_address(isolate).address(),
|
|
"HandleScope::next");
|
|
Add(ExternalReference::handle_scope_limit_address(isolate).address(),
|
|
"HandleScope::limit");
|
|
Add(ExternalReference::handle_scope_level_address(isolate).address(),
|
|
"HandleScope::level");
|
|
Add(ExternalReference::new_deoptimizer_function(isolate).address(),
|
|
"Deoptimizer::New()");
|
|
Add(ExternalReference::compute_output_frames_function(isolate).address(),
|
|
"Deoptimizer::ComputeOutputFrames()");
|
|
Add(ExternalReference::address_of_min_int().address(),
|
|
"LDoubleConstant::min_int");
|
|
Add(ExternalReference::address_of_one_half().address(),
|
|
"LDoubleConstant::one_half");
|
|
Add(ExternalReference::isolate_address(isolate).address(), "isolate");
|
|
Add(ExternalReference::interpreter_dispatch_table_address(isolate).address(),
|
|
"Interpreter::dispatch_table_address");
|
|
Add(ExternalReference::address_of_negative_infinity().address(),
|
|
"LDoubleConstant::negative_infinity");
|
|
Add(ExternalReference::power_double_double_function(isolate).address(),
|
|
"power_double_double_function");
|
|
Add(ExternalReference::ieee754_acos_function(isolate).address(),
|
|
"base::ieee754::acos");
|
|
Add(ExternalReference::ieee754_acosh_function(isolate).address(),
|
|
"base::ieee754::acosh");
|
|
Add(ExternalReference::ieee754_asin_function(isolate).address(),
|
|
"base::ieee754::asin");
|
|
Add(ExternalReference::ieee754_asinh_function(isolate).address(),
|
|
"base::ieee754::asinh");
|
|
Add(ExternalReference::ieee754_atan_function(isolate).address(),
|
|
"base::ieee754::atan");
|
|
Add(ExternalReference::ieee754_atanh_function(isolate).address(),
|
|
"base::ieee754::atanh");
|
|
Add(ExternalReference::ieee754_atan2_function(isolate).address(),
|
|
"base::ieee754::atan2");
|
|
Add(ExternalReference::ieee754_cbrt_function(isolate).address(),
|
|
"base::ieee754::cbrt");
|
|
Add(ExternalReference::ieee754_cos_function(isolate).address(),
|
|
"base::ieee754::cos");
|
|
Add(ExternalReference::ieee754_cosh_function(isolate).address(),
|
|
"base::ieee754::cosh");
|
|
Add(ExternalReference::ieee754_exp_function(isolate).address(),
|
|
"base::ieee754::exp");
|
|
Add(ExternalReference::ieee754_expm1_function(isolate).address(),
|
|
"base::ieee754::expm1");
|
|
Add(ExternalReference::ieee754_log_function(isolate).address(),
|
|
"base::ieee754::log");
|
|
Add(ExternalReference::ieee754_log1p_function(isolate).address(),
|
|
"base::ieee754::log1p");
|
|
Add(ExternalReference::ieee754_log10_function(isolate).address(),
|
|
"base::ieee754::log10");
|
|
Add(ExternalReference::ieee754_log2_function(isolate).address(),
|
|
"base::ieee754::log2");
|
|
Add(ExternalReference::ieee754_sin_function(isolate).address(),
|
|
"base::ieee754::sin");
|
|
Add(ExternalReference::ieee754_sinh_function(isolate).address(),
|
|
"base::ieee754::sinh");
|
|
Add(ExternalReference::ieee754_tan_function(isolate).address(),
|
|
"base::ieee754::tan");
|
|
Add(ExternalReference::ieee754_tanh_function(isolate).address(),
|
|
"base::ieee754::tanh");
|
|
Add(ExternalReference::store_buffer_top(isolate).address(),
|
|
"store_buffer_top");
|
|
Add(ExternalReference::address_of_the_hole_nan().address(), "the_hole_nan");
|
|
Add(ExternalReference::get_date_field_function(isolate).address(),
|
|
"JSDate::GetField");
|
|
Add(ExternalReference::date_cache_stamp(isolate).address(),
|
|
"date_cache_stamp");
|
|
Add(ExternalReference::address_of_pending_message_obj(isolate).address(),
|
|
"address_of_pending_message_obj");
|
|
Add(ExternalReference::get_make_code_young_function(isolate).address(),
|
|
"Code::MakeCodeYoung");
|
|
Add(ExternalReference::cpu_features().address(), "cpu_features");
|
|
Add(ExternalReference::old_space_allocation_top_address(isolate).address(),
|
|
"Heap::OldSpaceAllocationTopAddress");
|
|
Add(ExternalReference::old_space_allocation_limit_address(isolate).address(),
|
|
"Heap::OldSpaceAllocationLimitAddress");
|
|
Add(ExternalReference::allocation_sites_list_address(isolate).address(),
|
|
"Heap::allocation_sites_list_address()");
|
|
Add(ExternalReference::address_of_uint32_bias().address(), "uint32_bias");
|
|
Add(ExternalReference::get_mark_code_as_executed_function(isolate).address(),
|
|
"Code::MarkCodeAsExecuted");
|
|
Add(ExternalReference::is_profiling_address(isolate).address(),
|
|
"Isolate::is_profiling");
|
|
Add(ExternalReference::scheduled_exception_address(isolate).address(),
|
|
"Isolate::scheduled_exception");
|
|
Add(ExternalReference::invoke_function_callback(isolate).address(),
|
|
"InvokeFunctionCallback");
|
|
Add(ExternalReference::invoke_accessor_getter_callback(isolate).address(),
|
|
"InvokeAccessorGetterCallback");
|
|
Add(ExternalReference::wasm_f32_trunc(isolate).address(),
|
|
"wasm::f32_trunc_wrapper");
|
|
Add(ExternalReference::wasm_f32_floor(isolate).address(),
|
|
"wasm::f32_floor_wrapper");
|
|
Add(ExternalReference::wasm_f32_ceil(isolate).address(),
|
|
"wasm::f32_ceil_wrapper");
|
|
Add(ExternalReference::wasm_f32_nearest_int(isolate).address(),
|
|
"wasm::f32_nearest_int_wrapper");
|
|
Add(ExternalReference::wasm_f64_trunc(isolate).address(),
|
|
"wasm::f64_trunc_wrapper");
|
|
Add(ExternalReference::wasm_f64_floor(isolate).address(),
|
|
"wasm::f64_floor_wrapper");
|
|
Add(ExternalReference::wasm_f64_ceil(isolate).address(),
|
|
"wasm::f64_ceil_wrapper");
|
|
Add(ExternalReference::wasm_f64_nearest_int(isolate).address(),
|
|
"wasm::f64_nearest_int_wrapper");
|
|
Add(ExternalReference::wasm_int64_to_float32(isolate).address(),
|
|
"wasm::int64_to_float32_wrapper");
|
|
Add(ExternalReference::wasm_uint64_to_float32(isolate).address(),
|
|
"wasm::uint64_to_float32_wrapper");
|
|
Add(ExternalReference::wasm_int64_to_float64(isolate).address(),
|
|
"wasm::int64_to_float64_wrapper");
|
|
Add(ExternalReference::wasm_uint64_to_float64(isolate).address(),
|
|
"wasm::uint64_to_float64_wrapper");
|
|
Add(ExternalReference::wasm_float32_to_int64(isolate).address(),
|
|
"wasm::float32_to_int64_wrapper");
|
|
Add(ExternalReference::wasm_float32_to_uint64(isolate).address(),
|
|
"wasm::float32_to_uint64_wrapper");
|
|
Add(ExternalReference::wasm_float64_to_int64(isolate).address(),
|
|
"wasm::float64_to_int64_wrapper");
|
|
Add(ExternalReference::wasm_float64_to_uint64(isolate).address(),
|
|
"wasm::float64_to_uint64_wrapper");
|
|
Add(ExternalReference::wasm_float64_pow(isolate).address(),
|
|
"wasm::float64_pow");
|
|
Add(ExternalReference::wasm_int64_div(isolate).address(), "wasm::int64_div");
|
|
Add(ExternalReference::wasm_int64_mod(isolate).address(), "wasm::int64_mod");
|
|
Add(ExternalReference::wasm_uint64_div(isolate).address(),
|
|
"wasm::uint64_div");
|
|
Add(ExternalReference::wasm_uint64_mod(isolate).address(),
|
|
"wasm::uint64_mod");
|
|
Add(ExternalReference::wasm_word32_ctz(isolate).address(),
|
|
"wasm::word32_ctz");
|
|
Add(ExternalReference::wasm_word64_ctz(isolate).address(),
|
|
"wasm::word64_ctz");
|
|
Add(ExternalReference::wasm_word32_popcnt(isolate).address(),
|
|
"wasm::word32_popcnt");
|
|
Add(ExternalReference::wasm_word64_popcnt(isolate).address(),
|
|
"wasm::word64_popcnt");
|
|
Add(ExternalReference::f64_acos_wrapper_function(isolate).address(),
|
|
"f64_acos_wrapper");
|
|
Add(ExternalReference::f64_asin_wrapper_function(isolate).address(),
|
|
"f64_asin_wrapper");
|
|
Add(ExternalReference::f64_mod_wrapper_function(isolate).address(),
|
|
"f64_mod_wrapper");
|
|
Add(ExternalReference::log_enter_external_function(isolate).address(),
|
|
"Logger::EnterExternal");
|
|
Add(ExternalReference::log_leave_external_function(isolate).address(),
|
|
"Logger::LeaveExternal");
|
|
Add(ExternalReference::address_of_minus_one_half().address(),
|
|
"double_constants.minus_one_half");
|
|
Add(ExternalReference::stress_deopt_count(isolate).address(),
|
|
"Isolate::stress_deopt_count_address()");
|
|
Add(ExternalReference::runtime_function_table_address(isolate).address(),
|
|
"Runtime::runtime_function_table_address()");
|
|
Add(ExternalReference::is_tail_call_elimination_enabled_address(isolate)
|
|
.address(),
|
|
"Isolate::is_tail_call_elimination_enabled_address()");
|
|
Add(ExternalReference::address_of_float_abs_constant().address(),
|
|
"float_absolute_constant");
|
|
Add(ExternalReference::address_of_float_neg_constant().address(),
|
|
"float_negate_constant");
|
|
Add(ExternalReference::address_of_double_abs_constant().address(),
|
|
"double_absolute_constant");
|
|
Add(ExternalReference::address_of_double_neg_constant().address(),
|
|
"double_negate_constant");
|
|
|
|
// Debug addresses
|
|
Add(ExternalReference::debug_after_break_target_address(isolate).address(),
|
|
"Debug::after_break_target_address()");
|
|
Add(ExternalReference::debug_is_active_address(isolate).address(),
|
|
"Debug::is_active_address()");
|
|
Add(ExternalReference::debug_last_step_action_address(isolate).address(),
|
|
"Debug::step_in_enabled_address()");
|
|
Add(ExternalReference::debug_suspended_generator_address(isolate).address(),
|
|
"Debug::step_suspended_generator_address()");
|
|
|
|
#ifndef V8_INTERPRETED_REGEXP
|
|
Add(ExternalReference::re_case_insensitive_compare_uc16(isolate).address(),
|
|
"NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16()");
|
|
Add(ExternalReference::re_check_stack_guard_state(isolate).address(),
|
|
"RegExpMacroAssembler*::CheckStackGuardState()");
|
|
Add(ExternalReference::re_grow_stack(isolate).address(),
|
|
"NativeRegExpMacroAssembler::GrowStack()");
|
|
Add(ExternalReference::re_word_character_map().address(),
|
|
"NativeRegExpMacroAssembler::word_character_map");
|
|
Add(ExternalReference::address_of_regexp_stack_limit(isolate).address(),
|
|
"RegExpStack::limit_address()");
|
|
Add(ExternalReference::address_of_regexp_stack_memory_address(isolate)
|
|
.address(),
|
|
"RegExpStack::memory_address()");
|
|
Add(ExternalReference::address_of_regexp_stack_memory_size(isolate).address(),
|
|
"RegExpStack::memory_size()");
|
|
Add(ExternalReference::address_of_static_offsets_vector(isolate).address(),
|
|
"OffsetsVector::static_offsets_vector");
|
|
#endif // V8_INTERPRETED_REGEXP
|
|
|
|
// Runtime entries
|
|
Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
|
|
"HandleScope::DeleteExtensions");
|
|
Add(ExternalReference::incremental_marking_record_write_function(isolate)
|
|
.address(),
|
|
"IncrementalMarking::RecordWrite");
|
|
Add(ExternalReference::incremental_marking_record_write_code_entry_function(
|
|
isolate)
|
|
.address(),
|
|
"IncrementalMarking::RecordWriteOfCodeEntryFromCode");
|
|
Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
|
|
"StoreBuffer::StoreBufferOverflow");
|
|
}
|
|
|
|
void ExternalReferenceTable::AddBuiltins(Isolate* isolate) {
|
|
struct CBuiltinEntry {
|
|
Address address;
|
|
const char* name;
|
|
};
|
|
static const CBuiltinEntry c_builtins[] = {
|
|
#define DEF_ENTRY(Name, ...) {FUNCTION_ADDR(&Builtin_##Name), "Builtin_" #Name},
|
|
BUILTIN_LIST_C(DEF_ENTRY)
|
|
#undef DEF_ENTRY
|
|
};
|
|
for (unsigned i = 0; i < arraysize(c_builtins); ++i) {
|
|
Add(ExternalReference(c_builtins[i].address, isolate).address(),
|
|
c_builtins[i].name);
|
|
}
|
|
|
|
struct BuiltinEntry {
|
|
Builtins::Name id;
|
|
const char* name;
|
|
};
|
|
static const BuiltinEntry builtins[] = {
|
|
#define DEF_ENTRY(Name, ...) {Builtins::k##Name, "Builtin_" #Name},
|
|
BUILTIN_LIST_C(DEF_ENTRY) BUILTIN_LIST_A(DEF_ENTRY)
|
|
#undef DEF_ENTRY
|
|
};
|
|
for (unsigned i = 0; i < arraysize(builtins); ++i) {
|
|
Add(isolate->builtins()->builtin_address(builtins[i].id), builtins[i].name);
|
|
}
|
|
}
|
|
|
|
void ExternalReferenceTable::AddRuntimeFunctions(Isolate* isolate) {
|
|
struct RuntimeEntry {
|
|
Runtime::FunctionId id;
|
|
const char* name;
|
|
};
|
|
|
|
static const RuntimeEntry runtime_functions[] = {
|
|
#define RUNTIME_ENTRY(name, i1, i2) {Runtime::k##name, "Runtime::" #name},
|
|
FOR_EACH_INTRINSIC(RUNTIME_ENTRY)
|
|
#undef RUNTIME_ENTRY
|
|
};
|
|
|
|
for (unsigned i = 0; i < arraysize(runtime_functions); ++i) {
|
|
ExternalReference ref(runtime_functions[i].id, isolate);
|
|
Add(ref.address(), runtime_functions[i].name);
|
|
}
|
|
}
|
|
|
|
void ExternalReferenceTable::AddIsolateAddresses(Isolate* isolate) {
|
|
// Top addresses
|
|
static const char* address_names[] = {
|
|
#define BUILD_NAME_LITERAL(Name, name) "Isolate::" #name "_address",
|
|
FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL) NULL
|
|
#undef BUILD_NAME_LITERAL
|
|
};
|
|
|
|
for (int i = 0; i < Isolate::kIsolateAddressCount; ++i) {
|
|
Add(isolate->get_address_from_id(static_cast<Isolate::AddressId>(i)),
|
|
address_names[i]);
|
|
}
|
|
}
|
|
|
|
void ExternalReferenceTable::AddAccessors(Isolate* isolate) {
|
|
// Accessors
|
|
struct AccessorRefTable {
|
|
Address address;
|
|
const char* name;
|
|
};
|
|
|
|
static const AccessorRefTable getters[] = {
|
|
#define ACCESSOR_INFO_DECLARATION(name) \
|
|
{ FUNCTION_ADDR(&Accessors::name##Getter), \
|
|
"Redirect to Accessors::" #name "Getter"},
|
|
ACCESSOR_INFO_LIST(ACCESSOR_INFO_DECLARATION)
|
|
#undef ACCESSOR_INFO_DECLARATION
|
|
};
|
|
static const AccessorRefTable setters[] = {
|
|
#define ACCESSOR_SETTER_DECLARATION(name) \
|
|
{ FUNCTION_ADDR(&Accessors::name), "Accessors::" #name},
|
|
ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION)
|
|
#undef ACCESSOR_INFO_DECLARATION
|
|
};
|
|
|
|
for (unsigned i = 0; i < arraysize(getters); ++i) {
|
|
const char* name = getters[i].name + 12; // Skip "Redirect to " prefix.
|
|
Add(getters[i].address, name);
|
|
Add(AccessorInfo::redirect(isolate, getters[i].address, ACCESSOR_GETTER),
|
|
getters[i].name);
|
|
}
|
|
|
|
for (unsigned i = 0; i < arraysize(setters); ++i) {
|
|
Add(setters[i].address, setters[i].name);
|
|
}
|
|
}
|
|
|
|
void ExternalReferenceTable::AddStubCache(Isolate* isolate) {
|
|
StubCache* load_stub_cache = isolate->load_stub_cache();
|
|
|
|
// Stub cache tables
|
|
Add(load_stub_cache->key_reference(StubCache::kPrimary).address(),
|
|
"Load StubCache::primary_->key");
|
|
Add(load_stub_cache->value_reference(StubCache::kPrimary).address(),
|
|
"Load StubCache::primary_->value");
|
|
Add(load_stub_cache->map_reference(StubCache::kPrimary).address(),
|
|
"Load StubCache::primary_->map");
|
|
Add(load_stub_cache->key_reference(StubCache::kSecondary).address(),
|
|
"Load StubCache::secondary_->key");
|
|
Add(load_stub_cache->value_reference(StubCache::kSecondary).address(),
|
|
"Load StubCache::secondary_->value");
|
|
Add(load_stub_cache->map_reference(StubCache::kSecondary).address(),
|
|
"Load StubCache::secondary_->map");
|
|
|
|
StubCache* store_stub_cache = isolate->store_stub_cache();
|
|
|
|
// Stub cache tables
|
|
Add(store_stub_cache->key_reference(StubCache::kPrimary).address(),
|
|
"Store StubCache::primary_->key");
|
|
Add(store_stub_cache->value_reference(StubCache::kPrimary).address(),
|
|
"Store StubCache::primary_->value");
|
|
Add(store_stub_cache->map_reference(StubCache::kPrimary).address(),
|
|
"Store StubCache::primary_->map");
|
|
Add(store_stub_cache->key_reference(StubCache::kSecondary).address(),
|
|
"Store StubCache::secondary_->key");
|
|
Add(store_stub_cache->value_reference(StubCache::kSecondary).address(),
|
|
"Store StubCache::secondary_->value");
|
|
Add(store_stub_cache->map_reference(StubCache::kSecondary).address(),
|
|
"Store StubCache::secondary_->map");
|
|
}
|
|
|
|
void ExternalReferenceTable::AddDeoptEntries(Isolate* isolate) {
|
|
// Add a small set of deopt entry addresses to encoder without generating
|
|
// the
|
|
// deopt table code, which isn't possible at deserialization time.
|
|
HandleScope scope(isolate);
|
|
for (int entry = 0; entry < kDeoptTableSerializeEntryCount; ++entry) {
|
|
Address address = Deoptimizer::GetDeoptimizationEntry(
|
|
isolate, entry, Deoptimizer::LAZY,
|
|
Deoptimizer::CALCULATE_ENTRY_ADDRESS);
|
|
Add(address, "lazy_deopt");
|
|
}
|
|
}
|
|
|
|
void ExternalReferenceTable::AddApiReferences(Isolate* isolate) {
|
|
// Add external references provided by the embedder (a null-terminated
|
|
// array).
|
|
intptr_t* api_external_references = isolate->api_external_references();
|
|
if (api_external_references != nullptr) {
|
|
while (*api_external_references != 0) {
|
|
Address address = reinterpret_cast<Address>(*api_external_references);
|
|
Add(address, ResolveSymbol(address));
|
|
api_external_references++;
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace v8
|