diff options
Diffstat (limited to 'deps/v8/src/api.cc')
| -rw-r--r-- | deps/v8/src/api.cc | 3500 |
1 files changed, 1293 insertions, 2207 deletions
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc index d968bff57..b77e450cf 100644 --- a/deps/v8/src/api.cc +++ b/deps/v8/src/api.cc @@ -1,4 +1,4 @@ -// Copyright 2011 the V8 project authors. All rights reserved. +// Copyright 2010 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: @@ -38,13 +38,13 @@ #include "global-handles.h" #include "heap-profiler.h" #include "messages.h" -#include "natives.h" #include "parser.h" #include "platform.h" #include "profile-generator-inl.h" #include "runtime-profiler.h" #include "serialize.h" #include "snapshot.h" +#include "top.h" #include "v8threads.h" #include "version.h" #include "vm-state-inl.h" @@ -52,81 +52,81 @@ #include "../include/v8-profiler.h" #include "../include/v8-testing.h" -#define LOG_API(isolate, expr) LOG(isolate, ApiEntryCall(expr)) +#define LOG_API(expr) LOG(ApiEntryCall(expr)) #ifdef ENABLE_VMSTATE_TRACKING -#define ENTER_V8(isolate) \ - ASSERT((isolate)->IsInitialized()); \ - i::VMState __state__((isolate), i::OTHER) -#define LEAVE_V8(isolate) \ - i::VMState __state__((isolate), i::EXTERNAL) +#define ENTER_V8 ASSERT(i::V8::IsRunning()); i::VMState __state__(i::OTHER) +#define LEAVE_V8 i::VMState __state__(i::EXTERNAL) #else -#define ENTER_V8(isolate) ((void) 0) -#define LEAVE_V8(isolate) ((void) 0) +#define ENTER_V8 ((void) 0) +#define LEAVE_V8 ((void) 0) #endif namespace v8 { -#define ON_BAILOUT(isolate, location, code) \ - if (IsDeadCheck(isolate, location) || \ - IsExecutionTerminatingCheck(isolate)) { \ +#define ON_BAILOUT(location, code) \ + if (IsDeadCheck(location) || v8::V8::IsExecutionTerminating()) { \ code; \ UNREACHABLE(); \ } -#define EXCEPTION_PREAMBLE(isolate) \ - (isolate)->handle_scope_implementer()->IncrementCallDepth(); \ - ASSERT(!(isolate)->external_caught_exception()); \ +#define EXCEPTION_PREAMBLE() \ + thread_local.IncrementCallDepth(); \ + ASSERT(!i::Top::external_caught_exception()); \ bool has_pending_exception = false -#define EXCEPTION_BAILOUT_CHECK(isolate, value) \ +#define EXCEPTION_BAILOUT_CHECK(value) \ do { \ - i::HandleScopeImplementer* handle_scope_implementer = \ - (isolate)->handle_scope_implementer(); \ - handle_scope_implementer->DecrementCallDepth(); \ + thread_local.DecrementCallDepth(); \ if (has_pending_exception) { \ - if (handle_scope_implementer->CallDepthIsZero() && \ - (isolate)->is_out_of_memory()) { \ - if (!handle_scope_implementer->ignore_out_of_memory()) \ + if (thread_local.CallDepthIsZero() && i::Top::is_out_of_memory()) { \ + if (!thread_local.ignore_out_of_memory()) \ i::V8::FatalProcessOutOfMemory(NULL); \ } \ - bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero(); \ - (isolate)->OptionalRescheduleException(call_depth_is_zero); \ + bool call_depth_is_zero = thread_local.CallDepthIsZero(); \ + i::Top::OptionalRescheduleException(call_depth_is_zero); \ return value; \ } \ } while (false) -#define API_ENTRY_CHECK(isolate, msg) \ +#define API_ENTRY_CHECK(msg) \ do { \ if (v8::Locker::IsActive()) { \ - ApiCheck(isolate->thread_manager()->IsLockedByCurrentThread(), \ + ApiCheck(i::ThreadManager::IsLockedByCurrentThread(), \ msg, \ "Entering the V8 API without proper locking in place"); \ } \ } while (false) +// --- D a t a t h a t i s s p e c i f i c t o a t h r e a d --- + + +static i::HandleScopeImplementer thread_local; + + // --- E x c e p t i o n B e h a v i o r --- +static FatalErrorCallback exception_behavior = NULL; + static void DefaultFatalErrorHandler(const char* location, const char* message) { #ifdef ENABLE_VMSTATE_TRACKING - i::VMState __state__(i::Isolate::Current(), i::OTHER); + i::VMState __state__(i::OTHER); #endif API_Fatal(location, message); } -static FatalErrorCallback GetFatalErrorHandler() { - i::Isolate* isolate = i::Isolate::Current(); - if (isolate->exception_behavior() == NULL) { - isolate->set_exception_behavior(DefaultFatalErrorHandler); +static FatalErrorCallback& GetFatalErrorHandler() { + if (exception_behavior == NULL) { + exception_behavior = DefaultFatalErrorHandler; } - return isolate->exception_behavior(); + return exception_behavior; } @@ -175,8 +175,8 @@ void i::V8::FatalProcessOutOfMemory(const char* location, bool take_snapshot) { heap_stats.pending_global_handle_count = &pending_global_handle_count; int near_death_global_handle_count; heap_stats.near_death_global_handle_count = &near_death_global_handle_count; - int free_global_handle_count; - heap_stats.free_global_handle_count = &free_global_handle_count; + int destroyed_global_handle_count; + heap_stats.destroyed_global_handle_count = &destroyed_global_handle_count; intptr_t memory_allocator_size; heap_stats.memory_allocator_size = &memory_allocator_size; intptr_t memory_allocator_capacity; @@ -189,12 +189,11 @@ void i::V8::FatalProcessOutOfMemory(const char* location, bool take_snapshot) { heap_stats.os_error = &os_error; int end_marker; heap_stats.end_marker = &end_marker; - i::Isolate* isolate = i::Isolate::Current(); - isolate->heap()->RecordStats(&heap_stats, take_snapshot); + i::Heap::RecordStats(&heap_stats, take_snapshot); i::V8::SetFatalError(); FatalErrorCallback callback = GetFatalErrorHandler(); { - LEAVE_V8(isolate); + LEAVE_V8; callback(location, "Allocation failed - process out of memory"); } // If the callback returns, we stop execution. @@ -202,6 +201,11 @@ void i::V8::FatalProcessOutOfMemory(const char* location, bool take_snapshot) { } +void V8::SetFatalErrorHandler(FatalErrorCallback that) { + exception_behavior = that; +} + + bool Utils::ReportApiFailure(const char* location, const char* message) { FatalErrorCallback callback = GetFatalErrorHandler(); callback(location, message); @@ -248,22 +252,12 @@ static bool ReportEmptyHandle(const char* location) { * advantage over ON_BAILOUT that it actually initializes the VM if this has not * yet been done. */ -static inline bool IsDeadCheck(i::Isolate* isolate, const char* location) { - return !isolate->IsInitialized() +static inline bool IsDeadCheck(const char* location) { + return !i::V8::IsRunning() && i::V8::IsDead() ? ReportV8Dead(location) : false; } -static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) { - if (!isolate->IsInitialized()) return false; - if (isolate->has_scheduled_exception()) { - return isolate->scheduled_exception() == - isolate->heap()->termination_exception(); - } - return false; -} - - static inline bool EmptyCheck(const char* location, v8::Handle<v8::Data> obj) { return obj.IsEmpty() ? ReportEmptyHandle(location) : false; } @@ -276,185 +270,56 @@ static inline bool EmptyCheck(const char* location, const v8::Data* obj) { // --- S t a t i c s --- -static bool InitializeHelper() { - if (i::Snapshot::Initialize()) return true; - return i::V8::Initialize(NULL); -} - - -static inline bool EnsureInitializedForIsolate(i::Isolate* isolate, - const char* location) { - if (IsDeadCheck(isolate, location)) return false; - if (isolate != NULL) { - if (isolate->IsInitialized()) return true; - } - ASSERT(isolate == i::Isolate::Current()); - return ApiCheck(InitializeHelper(), location, "Error initializing V8"); -} - -// Some initializing API functions are called early and may be -// called on a thread different from static initializer thread. -// If Isolate API is used, Isolate::Enter() will initialize TLS so -// Isolate::Current() works. If it's a legacy case, then the thread -// may not have TLS initialized yet. However, in initializing APIs it -// may be too early to call EnsureInitialized() - some pre-init -// parameters still have to be configured. -static inline i::Isolate* EnterIsolateIfNeeded() { - i::Isolate* isolate = i::Isolate::UncheckedCurrent(); - if (isolate != NULL) - return isolate; - - i::Isolate::EnterDefaultIsolate(); - isolate = i::Isolate::Current(); - return isolate; -} - - -StartupDataDecompressor::StartupDataDecompressor() - : raw_data(i::NewArray<char*>(V8::GetCompressedStartupDataCount())) { - for (int i = 0; i < V8::GetCompressedStartupDataCount(); ++i) { - raw_data[i] = NULL; - } -} +static i::StringInputBuffer write_input_buffer; -StartupDataDecompressor::~StartupDataDecompressor() { - for (int i = 0; i < V8::GetCompressedStartupDataCount(); ++i) { - i::DeleteArray(raw_data[i]); +static inline bool EnsureInitialized(const char* location) { + if (i::V8::IsRunning()) { + return true; } - i::DeleteArray(raw_data); -} - - -int StartupDataDecompressor::Decompress() { - int compressed_data_count = V8::GetCompressedStartupDataCount(); - StartupData* compressed_data = - i::NewArray<StartupData>(compressed_data_count); - V8::GetCompressedStartupData(compressed_data); - for (int i = 0; i < compressed_data_count; ++i) { - char* decompressed = raw_data[i] = - i::NewArray<char>(compressed_data[i].raw_size); - if (compressed_data[i].compressed_size != 0) { - int result = DecompressData(decompressed, - &compressed_data[i].raw_size, - compressed_data[i].data, - compressed_data[i].compressed_size); - if (result != 0) return result; - } else { - ASSERT_EQ(0, compressed_data[i].raw_size); - } - compressed_data[i].data = decompressed; + if (IsDeadCheck(location)) { + return false; } - V8::SetDecompressedStartupData(compressed_data); - return 0; + return ApiCheck(v8::V8::Initialize(), location, "Error initializing V8"); } -StartupData::CompressionAlgorithm V8::GetCompressedStartupDataAlgorithm() { -#ifdef COMPRESS_STARTUP_DATA_BZ2 - return StartupData::kBZip2; -#else - return StartupData::kUncompressed; -#endif +ImplementationUtilities::HandleScopeData* + ImplementationUtilities::CurrentHandleScope() { + return &i::HandleScope::current_; } -enum CompressedStartupDataItems { - kSnapshot = 0, - kSnapshotContext, - kLibraries, - kExperimentalLibraries, - kCompressedStartupDataCount -}; - -int V8::GetCompressedStartupDataCount() { -#ifdef COMPRESS_STARTUP_DATA_BZ2 - return kCompressedStartupDataCount; -#else - return 0; -#endif +#ifdef DEBUG +void ImplementationUtilities::ZapHandleRange(i::Object** begin, + i::Object** end) { + i::HandleScope::ZapRange(begin, end); } - - -void V8::GetCompressedStartupData(StartupData* compressed_data) { -#ifdef COMPRESS_STARTUP_DATA_BZ2 - compressed_data[kSnapshot].data = - reinterpret_cast<const char*>(i::Snapshot::data()); - compressed_data[kSnapshot].compressed_size = i::Snapshot::size(); - compressed_data[kSnapshot].raw_size = i::Snapshot::raw_size(); - - compressed_data[kSnapshotContext].data = - reinterpret_cast<const char*>(i::Snapshot::context_data()); - compressed_data[kSnapshotContext].compressed_size = - i::Snapshot::context_size(); - compressed_data[kSnapshotContext].raw_size = i::Snapshot::context_raw_size(); - - i::Vector<const i::byte> libraries_source = i::Natives::GetScriptsSource(); - compressed_data[kLibraries].data = - reinterpret_cast<const char*>(libraries_source.start()); - compressed_data[kLibraries].compressed_size = libraries_source.length(); - compressed_data[kLibraries].raw_size = i::Natives::GetRawScriptsSize(); - - i::Vector<const i::byte> exp_libraries_source = - i::ExperimentalNatives::GetScriptsSource(); - compressed_data[kExperimentalLibraries].data = - reinterpret_cast<const char*>(exp_libraries_source.start()); - compressed_data[kExperimentalLibraries].compressed_size = - exp_libraries_source.length(); - compressed_data[kExperimentalLibraries].raw_size = - i::ExperimentalNatives::GetRawScriptsSize(); #endif -} -void V8::SetDecompressedStartupData(StartupData* decompressed_data) { -#ifdef COMPRESS_STARTUP_DATA_BZ2 - ASSERT_EQ(i::Snapshot::raw_size(), decompressed_data[kSnapshot].raw_size); - i::Snapshot::set_raw_data( - reinterpret_cast<const i::byte*>(decompressed_data[kSnapshot].data)); - - ASSERT_EQ(i::Snapshot::context_raw_size(), - decompressed_data[kSnapshotContext].raw_size); - i::Snapshot::set_context_raw_data( - reinterpret_cast<const i::byte*>( - decompressed_data[kSnapshotContext].data)); - - ASSERT_EQ(i::Natives::GetRawScriptsSize(), - decompressed_data[kLibraries].raw_size); - i::Vector<const char> libraries_source( - decompressed_data[kLibraries].data, - decompressed_data[kLibraries].raw_size); - i::Natives::SetRawScriptsSource(libraries_source); - - ASSERT_EQ(i::ExperimentalNatives::GetRawScriptsSize(), - decompressed_data[kExperimentalLibraries].raw_size); - i::Vector<const char> exp_libraries_source( - decompressed_data[kExperimentalLibraries].data, - decompressed_data[kExperimentalLibraries].raw_size); - i::ExperimentalNatives::SetRawScriptsSource(exp_libraries_source); -#endif +v8::Handle<v8::Primitive> ImplementationUtilities::Undefined() { + if (!EnsureInitialized("v8::Undefined()")) return v8::Handle<v8::Primitive>(); + return v8::Handle<Primitive>(ToApi<Primitive>(i::Factory::undefined_value())); } -void V8::SetFatalErrorHandler(FatalErrorCallback that) { - i::Isolate* isolate = EnterIsolateIfNeeded(); - isolate->set_exception_behavior(that); +v8::Handle<v8::Primitive> ImplementationUtilities::Null() { + if (!EnsureInitialized("v8::Null()")) return v8::Handle<v8::Primitive>(); + return v8::Handle<Primitive>(ToApi<Primitive>(i::Factory::null_value())); } -void V8::SetAllowCodeGenerationFromStringsCallback( - AllowCodeGenerationFromStringsCallback callback) { - i::Isolate* isolate = EnterIsolateIfNeeded(); - isolate->set_allow_code_gen_callback(callback); +v8::Handle<v8::Boolean> ImplementationUtilities::True() { + if (!EnsureInitialized("v8::True()")) return v8::Handle<v8::Boolean>(); + return v8::Handle<v8::Boolean>(ToApi<Boolean>(i::Factory::true_value())); } -#ifdef DEBUG -void ImplementationUtilities::ZapHandleRange(i::Object** begin, - i::Object** end) { - i::HandleScope::ZapRange(begin, end); +v8::Handle<v8::Boolean> ImplementationUtilities::False() { + if (!EnsureInitialized("v8::False()")) return v8::Handle<v8::Boolean>(); + return v8::Handle<v8::Boolean>(ToApi<Boolean>(i::Factory::false_value())); } -#endif void V8::SetFlagsFromString(const char* str, int length) { @@ -468,17 +333,14 @@ void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) { v8::Handle<Value> ThrowException(v8::Handle<v8::Value> value) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::ThrowException()")) { - return v8::Handle<Value>(); - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::ThrowException()")) return v8::Handle<Value>(); + ENTER_V8; // If we're passed an empty handle, we throw an undefined exception // to deal more gracefully with out of memory situations. if (value.IsEmpty()) { - isolate->ScheduleThrow(isolate->heap()->undefined_value()); + i::Top::ScheduleThrow(i::Heap::undefined_value()); } else { - isolate->ScheduleThrow(*Utils::OpenHandle(*value)); + i::Top::ScheduleThrow(*Utils::OpenHandle(*value)); } return v8::Undefined(); } @@ -492,8 +354,8 @@ RegisteredExtension::RegisteredExtension(Extension* extension) void RegisteredExtension::Register(RegisteredExtension* that) { - that->next_ = first_extension_; - first_extension_ = that; + that->next_ = RegisteredExtension::first_extension_; + RegisteredExtension::first_extension_ = that; } @@ -515,42 +377,26 @@ Extension::Extension(const char* name, v8::Handle<Primitive> Undefined() { - i::Isolate* isolate = i::Isolate::Current(); - if (!EnsureInitializedForIsolate(isolate, "v8::Undefined()")) { - return v8::Handle<v8::Primitive>(); - } - return v8::Handle<Primitive>(ToApi<Primitive>( - isolate->factory()->undefined_value())); + LOG_API("Undefined"); + return ImplementationUtilities::Undefined(); } v8::Handle<Primitive> Null() { - i::Isolate* isolate = i::Isolate::Current(); - if (!EnsureInitializedForIsolate(isolate, "v8::Null()")) { - return v8::Handle<v8::Primitive>(); - } - return v8::Handle<Primitive>( - ToApi<Primitive>(isolate->factory()->null_value())); + LOG_API("Null"); + return ImplementationUtilities::Null(); } v8::Handle<Boolean> True() { - i::Isolate* isolate = i::Isolate::Current(); - if (!EnsureInitializedForIsolate(isolate, "v8::True()")) { - return v8::Handle<Boolean>(); - } - return v8::Handle<Boolean>( - ToApi<Boolean>(isolate->factory()->true_value())); + LOG_API("True"); + return ImplementationUtilities::True(); } v8::Handle<Boolean> False() { - i::Isolate* isolate = i::Isolate::Current(); - if (!EnsureInitializedForIsolate(isolate, "v8::False()")) { - return v8::Handle<Boolean>(); - } - return v8::Handle<Boolean>( - ToApi<Boolean>(isolate->factory()->false_value())); + LOG_API("False"); + return ImplementationUtilities::False(); } @@ -562,96 +408,74 @@ ResourceConstraints::ResourceConstraints() bool SetResourceConstraints(ResourceConstraints* constraints) { - i::Isolate* isolate = EnterIsolateIfNeeded(); - int young_space_size = constraints->max_young_space_size(); int old_gen_size = constraints->max_old_space_size(); int max_executable_size = constraints->max_executable_size(); if (young_space_size != 0 || old_gen_size != 0 || max_executable_size != 0) { - // After initialization it's too late to change Heap constraints. - ASSERT(!isolate->IsInitialized()); - bool result = isolate->heap()->ConfigureHeap(young_space_size / 2, - old_gen_size, - max_executable_size); + bool result = i::Heap::ConfigureHeap(young_space_size / 2, + old_gen_size, + max_executable_size); if (!result) return false; } if (constraints->stack_limit() != NULL) { uintptr_t limit = reinterpret_cast<uintptr_t>(constraints->stack_limit()); - isolate->stack_guard()->SetStackLimit(limit); + i::StackGuard::SetStackLimit(limit); } return true; } i::Object** V8::GlobalizeReference(i::Object** obj) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "V8::Persistent::New")) return NULL; - LOG_API(isolate, "Persistent::New"); + if (IsDeadCheck("V8::Persistent::New")) return NULL; + LOG_API("Persistent::New"); i::Handle<i::Object> result = - isolate->global_handles()->Create(*obj); + i::GlobalHandles::Create(*obj); return result.location(); } void V8::MakeWeak(i::Object** object, void* parameters, WeakReferenceCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "MakeWeak"); - isolate->global_handles()->MakeWeak(object, parameters, - callback); + LOG_API("MakeWeak"); + i::GlobalHandles::MakeWeak(object, parameters, callback); } void V8::ClearWeak(i::Object** obj) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "ClearWeak"); - isolate->global_handles()->ClearWeakness(obj); -} - - -void V8::MarkIndependent(i::Object** object) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "MakeIndependent"); - isolate->global_handles()->MarkIndependent(object); + LOG_API("ClearWeak"); + i::GlobalHandles::ClearWeakness(obj); } bool V8::IsGlobalNearDeath(i::Object** obj) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "IsGlobalNearDeath"); - if (!isolate->IsInitialized()) return false; + LOG_API("IsGlobalNearDeath"); + if (!i::V8::IsRunning()) return false; return i::GlobalHandles::IsNearDeath(obj); } bool V8::IsGlobalWeak(i::Object** obj) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "IsGlobalWeak"); - if (!isolate->IsInitialized()) return false; + LOG_API("IsGlobalWeak"); + if (!i::V8::IsRunning()) return false; return i::GlobalHandles::IsWeak(obj); } void V8::DisposeGlobal(i::Object** obj) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "DisposeGlobal"); - if (!isolate->IsInitialized()) return; - isolate->global_handles()->Destroy(obj); + LOG_API("DisposeGlobal"); + if (!i::V8::IsRunning()) return; + i::GlobalHandles::Destroy(obj); } // --- H a n d l e s --- -HandleScope::HandleScope() { - i::Isolate* isolate = i::Isolate::Current(); - API_ENTRY_CHECK(isolate, "HandleScope::HandleScope"); - v8::ImplementationUtilities::HandleScopeData* current = - isolate->handle_scope_data(); - isolate_ = isolate; - prev_next_ = current->next; - prev_limit_ = current->limit; - is_closed_ = false; - current->level++; +HandleScope::HandleScope() + : prev_next_(i::HandleScope::current_.next), + prev_limit_(i::HandleScope::current_.limit), + is_closed_(false) { + API_ENTRY_CHECK("HandleScope::HandleScope"); + i::HandleScope::current_.level++; } @@ -663,15 +487,12 @@ HandleScope::~HandleScope() { void HandleScope::Leave() { - ASSERT(isolate_ == i::Isolate::Current()); - v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); - current->level--; - ASSERT(current->level >= 0); - current->next = prev_next_; - if (current->limit != prev_limit_) { - current->limit = prev_limit_; - i::HandleScope::DeleteExtensions(isolate_); + i::HandleScope::current_.level--; + ASSERT(i::HandleScope::current_.level >= 0); + i::HandleScope::current_.next = prev_next_; + if (i::HandleScope::current_.limit != prev_limit_) { + i::HandleScope::current_.limit = prev_limit_; + i::HandleScope::DeleteExtensions(); } #ifdef DEBUG @@ -681,83 +502,70 @@ void HandleScope::Leave() { int HandleScope::NumberOfHandles() { - EnsureInitializedForIsolate( - i::Isolate::Current(), "HandleScope::NumberOfHandles"); return i::HandleScope::NumberOfHandles(); } -i::Object** HandleScope::CreateHandle(i::Object* value) { - return i::HandleScope::CreateHandle(value, i::Isolate::Current()); -} - - -i::Object** HandleScope::CreateHandle(i::HeapObject* value) { - ASSERT(value->IsHeapObject()); - return reinterpret_cast<i::Object**>( - i::HandleScope::CreateHandle(value, value->GetIsolate())); +i::Object** v8::HandleScope::CreateHandle(i::Object* value) { + return i::HandleScope::CreateHandle(value); } void Context::Enter() { + if (IsDeadCheck("v8::Context::Enter()")) return; + ENTER_V8; i::Handle<i::Context> env = Utils::OpenHandle(this); - i::Isolate* isolate = env->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Context::Enter()")) return; - ENTER_V8(isolate); - - isolate->handle_scope_implementer()->EnterContext(env); + thread_local.EnterContext(env); - isolate->handle_scope_implementer()->SaveContext(isolate->context()); - isolate->set_context(*env); + thread_local.SaveContext(i::Top::context()); + i::Top::set_context(*env); } void Context::Exit() { - // Exit is essentially a static function and doesn't use the - // receiver, so we have to get the current isolate from the thread - // local. - i::Isolate* isolate = i::Isolate::Current(); - if (!isolate->IsInitialized()) return; - - if (!ApiCheck(isolate->handle_scope_implementer()->LeaveLastContext(), + if (!i::V8::IsRunning()) return; + if (!ApiCheck(thread_local.LeaveLastContext(), "v8::Context::Exit()", "Cannot exit non-entered context")) { return; } // Content of 'last_context' could be NULL. - i::Context* last_context = - isolate->handle_scope_implementer()->RestoreContext(); - isolate->set_context(last_context); + i::Context* last_context = thread_local.RestoreContext(); + i::Top::set_context(last_context); } void Context::SetData(v8::Handle<String> data) { - i::Handle<i::Context> env = Utils::OpenHandle(this); - i::Isolate* isolate = env->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Context::SetData()")) return; - i::Handle<i::Object> raw_data = Utils::OpenHandle(*data); - ASSERT(env->IsGlobalContext()); - if (env->IsGlobalContext()) { - env->set_data(*raw_data); + if (IsDeadCheck("v8::Context::SetData()")) return; + ENTER_V8; + { + HandleScope scope; + i::Handle<i::Context> env = Utils::OpenHandle(this); + i::Handle<i::Object> raw_data = Utils::OpenHandle(*data); + ASSERT(env->IsGlobalContext()); + if (env->IsGlobalContext()) { + env->set_data(*raw_data); + } } } v8::Local<v8::Value> Context::GetData() { - i::Handle<i::Context> env = Utils::OpenHandle(this); - i::Isolate* isolate = env->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Context::GetData()")) { - return v8::Local<Value>(); - } + if (IsDeadCheck("v8::Context::GetData()")) return v8::Local<Value>(); + ENTER_V8; i::Object* raw_result = NULL; - ASSERT(env->IsGlobalContext()); - if (env->IsGlobalContext()) { - raw_result = env->data(); - } else { - return Local<Value>(); + { + HandleScope scope; + i::Handle<i::Context> env = Utils::OpenHandle(this); + ASSERT(env->IsGlobalContext()); + if (env->IsGlobalContext()) { + raw_result = env->data(); + } else { + return Local<Value>(); + } } - i::Handle<i::Object> result(raw_result, isolate); + i::Handle<i::Object> result(raw_result); return Utils::ToLocal(result); } @@ -768,7 +576,7 @@ i::Object** v8::HandleScope::RawClose(i::Object** value) { "Local scope has already been closed")) { return 0; } - LOG_API(isolate_, "CloseHandleScope"); + LOG_API("CloseHandleScope"); // Read the result before popping the handle block. i::Object* result = NULL; @@ -797,11 +605,10 @@ i::Object** v8::HandleScope::RawClose(i::Object** value) { // NeanderObject constructor. When you add one to the site calling the // constructor you should check that you ensured the VM was not dead first. NeanderObject::NeanderObject(int size) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Nowhere"); - ENTER_V8(isolate); - value_ = isolate->factory()->NewNeanderObject(); - i::Handle<i::FixedArray> elements = isolate->factory()->NewFixedArray(size); + EnsureInitialized("v8::Nowhere"); + ENTER_V8; + value_ = i::Factory::NewNeanderObject(); + i::Handle<i::FixedArray> elements = i::Factory::NewFixedArray(size); value_->set_elements(*elements); } @@ -837,7 +644,7 @@ void NeanderArray::add(i::Handle<i::Object> value) { int length = this->length(); int size = obj_.size(); if (length == size - 1) { - i::Handle<i::FixedArray> new_elms = FACTORY->NewFixedArray(2 * size); + i::Handle<i::FixedArray> new_elms = i::Factory::NewFixedArray(2 * size); for (int i = 0; i < length; i++) new_elms->set(i + 1, get(i)); obj_.value()->set_elements(*new_elms); @@ -863,10 +670,9 @@ static void InitializeTemplate(i::Handle<i::TemplateInfo> that, int type) { void Template::Set(v8::Handle<String> name, v8::Handle<Data> value, v8::PropertyAttribute attribute) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Template::Set()")) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::Template::Set()")) return; + ENTER_V8; + HandleScope scope; i::Handle<i::Object> list(Utils::OpenHandle(this)->property_list()); if (list->IsUndefined()) { list = NeanderArray().value(); @@ -884,16 +690,14 @@ static void InitializeFunctionTemplate( i::Handle<i::FunctionTemplateInfo> info) { info->set_tag(i::Smi::FromInt(Consts::FUNCTION_TEMPLATE)); info->set_flag(0); - info->set_prototype_attributes(i::Smi::FromInt(v8::None)); } Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::PrototypeTemplate()")) { + if (IsDeadCheck("v8::FunctionTemplate::PrototypeTemplate()")) { return Local<ObjectTemplate>(); } - ENTER_V8(isolate); + ENTER_V8; i::Handle<i::Object> result(Utils::OpenHandle(this)->prototype_template()); if (result->IsUndefined()) { result = Utils::OpenHandle(*ObjectTemplate::New()); @@ -904,27 +708,28 @@ Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() { void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::Inherit()")) return; - ENTER_V8(isolate); + if (IsDeadCheck("v8::FunctionTemplate::Inherit()")) return; + ENTER_V8; Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value)); } +// To distinguish the function templates, so that we can find them in the +// function cache of the global context. +static int next_serial_number = 0; + + Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, v8::Handle<Value> data, v8::Handle<Signature> signature) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::FunctionTemplate::New()"); - LOG_API(isolate, "FunctionTemplate::New"); - ENTER_V8(isolate); + EnsureInitialized("v8::FunctionTemplate::New()"); + LOG_API("FunctionTemplate::New"); + ENTER_V8; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE); + i::Factory::NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE); i::Handle<i::FunctionTemplateInfo> obj = i::Handle<i::FunctionTemplateInfo>::cast(struct_obj); InitializeFunctionTemplate(obj); - int next_serial_number = isolate->next_serial_number(); - isolate->set_next_serial_number(next_serial_number + 1); - obj->set_serial_number(i::Smi::FromInt(next_serial_number)); + obj->set_serial_number(i::Smi::FromInt(next_serial_number++)); if (callback != 0) { if (data.IsEmpty()) data = v8::Undefined(); Utils::ToLocal(obj)->SetCallHandler(callback, data); @@ -940,17 +745,16 @@ Local<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, Local<Signature> Signature::New(Handle<FunctionTemplate> receiver, int argc, Handle<FunctionTemplate> argv[]) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Signature::New()"); - LOG_API(isolate, "Signature::New"); - ENTER_V8(isolate); + EnsureInitialized("v8::Signature::New()"); + LOG_API("Signature::New"); + ENTER_V8; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::SIGNATURE_INFO_TYPE); + i::Factory::NewStruct(i::SIGNATURE_INFO_TYPE); i::Handle<i::SignatureInfo> obj = i::Handle<i::SignatureInfo>::cast(struct_obj); if (!receiver.IsEmpty()) obj->set_receiver(*Utils::OpenHandle(*receiver)); if (argc > 0) { - i::Handle<i::FixedArray> args = isolate->factory()->NewFixedArray(argc); + i::Handle<i::FixedArray> args = i::Factory::NewFixedArray(argc); for (int i = 0; i < argc; i++) { if (!argv[i].IsEmpty()) args->set(i, *Utils::OpenHandle(*argv[i])); @@ -968,15 +772,14 @@ Local<TypeSwitch> TypeSwitch::New(Handle<FunctionTemplate> type) { Local<TypeSwitch> TypeSwitch::New(int argc, Handle<FunctionTemplate> types[]) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::TypeSwitch::New()"); - LOG_API(isolate, "TypeSwitch::New"); - ENTER_V8(isolate); - i::Handle<i::FixedArray> vector = isolate->factory()->NewFixedArray(argc); + EnsureInitialized("v8::TypeSwitch::New()"); + LOG_API("TypeSwitch::New"); + ENTER_V8; + i::Handle<i::FixedArray> vector = i::Factory::NewFixedArray(argc); for (int i = 0; i < argc; i++) vector->set(i, *Utils::OpenHandle(*types[i])); i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::TYPE_SWITCH_INFO_TYPE); + i::Factory::NewStruct(i::TYPE_SWITCH_INFO_TYPE); i::Handle<i::TypeSwitchInfo> obj = i::Handle<i::TypeSwitchInfo>::cast(struct_obj); obj->set_types(*vector); @@ -985,9 +788,7 @@ Local<TypeSwitch> TypeSwitch::New(int argc, Handle<FunctionTemplate> types[]) { int TypeSwitch::match(v8::Handle<Value> value) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "TypeSwitch::match"); - USE(isolate); + LOG_API("TypeSwitch::match"); i::Handle<i::Object> obj = Utils::OpenHandle(*value); i::Handle<i::TypeSwitchInfo> info = Utils::OpenHandle(this); i::FixedArray* types = i::FixedArray::cast(info->types()); @@ -999,20 +800,19 @@ int TypeSwitch::match(v8::Handle<Value> value) { } -#define SET_FIELD_WRAPPED(obj, setter, cdata) do { \ - i::Handle<i::Object> foreign = FromCData(cdata); \ - (obj)->setter(*foreign); \ +#define SET_FIELD_WRAPPED(obj, setter, cdata) do { \ + i::Handle<i::Object> proxy = FromCData(cdata); \ + (obj)->setter(*proxy); \ } while (false) void FunctionTemplate::SetCallHandler(InvocationCallback callback, v8::Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::FunctionTemplate::SetCallHandler()")) return; + ENTER_V8; + HandleScope scope; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); + i::Factory::NewStruct(i::CALL_HANDLER_INFO_TYPE); i::Handle<i::CallHandlerInfo> obj = i::Handle<i::CallHandlerInfo>::cast(struct_obj); SET_FIELD_WRAPPED(obj, set_callback, callback); @@ -1029,7 +829,7 @@ static i::Handle<i::AccessorInfo> MakeAccessorInfo( v8::Handle<Value> data, v8::AccessControl settings, v8::PropertyAttribute attributes) { - i::Handle<i::AccessorInfo> obj = FACTORY->NewAccessorInfo(); + i::Handle<i::AccessorInfo> obj = i::Factory::NewAccessorInfo(); ASSERT(getter != NULL); SET_FIELD_WRAPPED(obj, set_getter, getter); SET_FIELD_WRAPPED(obj, set_setter, setter); @@ -1051,13 +851,11 @@ void FunctionTemplate::AddInstancePropertyAccessor( v8::Handle<Value> data, v8::AccessControl settings, v8::PropertyAttribute attributes) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, - "v8::FunctionTemplate::AddInstancePropertyAccessor()")) { + if (IsDeadCheck("v8::FunctionTemplate::AddInstancePropertyAccessor()")) { return; } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + HandleScope scope; i::Handle<i::AccessorInfo> obj = MakeAccessorInfo(name, getter, setter, data, @@ -1073,11 +871,10 @@ void FunctionTemplate::AddInstancePropertyAccessor( Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::InstanceTemplate()") + if (IsDeadCheck("v8::FunctionTemplate::InstanceTemplate()") || EmptyCheck("v8::FunctionTemplate::InstanceTemplate()", this)) return Local<ObjectTemplate>(); - ENTER_V8(isolate); + ENTER_V8; if (Utils::OpenHandle(this)->instance_template()->IsUndefined()) { Local<ObjectTemplate> templ = ObjectTemplate::New(v8::Handle<FunctionTemplate>(this)); @@ -1090,34 +887,19 @@ Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() { void FunctionTemplate::SetClassName(Handle<String> name) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetClassName()")) return; - ENTER_V8(isolate); + if (IsDeadCheck("v8::FunctionTemplate::SetClassName()")) return; + ENTER_V8; Utils::OpenHandle(this)->set_class_name(*Utils::OpenHandle(*name)); } void FunctionTemplate::SetHiddenPrototype(bool value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetHiddenPrototype()")) { - return; - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::FunctionTemplate::SetHiddenPrototype()")) return; + ENTER_V8; Utils::OpenHandle(this)->set_hidden_prototype(value); } -void FunctionTemplate::SetPrototypeAttributes(int attributes) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetPrototypeAttributes()")) { - return; - } - ENTER_V8(isolate); - Utils::OpenHandle(this)->set_prototype_attributes( - i::Smi::FromInt(attributes)); -} - - void FunctionTemplate::SetNamedInstancePropertyHandler( NamedPropertyGetter getter, NamedPropertySetter setter, @@ -1125,15 +907,13 @@ void FunctionTemplate::SetNamedInstancePropertyHandler( NamedPropertyDeleter remover, NamedPropertyEnumerator enumerator, Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, - "v8::FunctionTemplate::SetNamedInstancePropertyHandler()")) { + if (IsDeadCheck("v8::FunctionTemplate::SetNamedInstancePropertyHandler()")) { return; } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + HandleScope scope; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); + i::Factory::NewStruct(i::INTERCEPTOR_INFO_TYPE); i::Handle<i::InterceptorInfo> obj = i::Handle<i::InterceptorInfo>::cast(struct_obj); @@ -1156,15 +936,14 @@ void FunctionTemplate::SetIndexedInstancePropertyHandler( IndexedPropertyDeleter remover, IndexedPropertyEnumerator enumerator, Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, + if (IsDeadCheck( "v8::FunctionTemplate::SetIndexedInstancePropertyHandler()")) { return; } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + HandleScope scope; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::INTERCEPTOR_INFO_TYPE); + i::Factory::NewStruct(i::INTERCEPTOR_INFO_TYPE); i::Handle<i::InterceptorInfo> obj = i::Handle<i::InterceptorInfo>::cast(struct_obj); @@ -1183,15 +962,13 @@ void FunctionTemplate::SetIndexedInstancePropertyHandler( void FunctionTemplate::SetInstanceCallAsFunctionHandler( InvocationCallback callback, Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, - "v8::FunctionTemplate::SetInstanceCallAsFunctionHandler()")) { + if (IsDeadCheck("v8::FunctionTemplate::SetInstanceCallAsFunctionHandler()")) { return; } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + HandleScope scope; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); + i::Factory::NewStruct(i::CALL_HANDLER_INFO_TYPE); i::Handle<i::CallHandlerInfo> obj = i::Handle<i::CallHandlerInfo>::cast(struct_obj); SET_FIELD_WRAPPED(obj, set_callback, callback); @@ -1211,15 +988,12 @@ Local<ObjectTemplate> ObjectTemplate::New() { Local<ObjectTemplate> ObjectTemplate::New( v8::Handle<FunctionTemplate> constructor) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::New()")) { - return Local<ObjectTemplate>(); - } - EnsureInitializedForIsolate(isolate, "v8::ObjectTemplate::New()"); - LOG_API(isolate, "ObjectTemplate::New"); - ENTER_V8(isolate); + if (IsDeadCheck("v8::ObjectTemplate::New()")) return Local<ObjectTemplate>(); + EnsureInitialized("v8::ObjectTemplate::New()"); + LOG_API("ObjectTemplate::New"); + ENTER_V8; i::Handle<i::Struct> struct_obj = - isolate->factory()->NewStruct(i::OBJECT_TEMPLATE_INFO_TYPE); + i::Factory::NewStruct(i::OBJECT_TEMPLATE_INFO_TYPE); i::Handle<i::ObjectTemplateInfo> obj = i::Handle<i::ObjectTemplateInfo>::cast(struct_obj); InitializeTemplate(obj, Consts::OBJECT_TEMPLATE); @@ -1248,10 +1022,9 @@ void ObjectTemplate::SetAccessor(v8::Handle<String> name, v8::Handle<Value> data, AccessControl settings, PropertyAttribute attribute) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessor()")) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::ObjectTemplate::SetAccessor()")) return; + ENTER_V8; + HandleScope scope; EnsureConstructor(this); i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); @@ -1271,12 +1044,9 @@ void ObjectTemplate::SetNamedPropertyHandler(NamedPropertyGetter getter, NamedPropertyDeleter remover, NamedPropertyEnumerator enumerator, Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetNamedPropertyHandler()")) { - return; - } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::ObjectTemplate::SetNamedPropertyHandler()")) return; + ENTER_V8; + HandleScope scope; EnsureConstructor(this); i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); @@ -1291,10 +1061,9 @@ void ObjectTemplate::SetNamedPropertyHandler(NamedPropertyGetter getter, void ObjectTemplate::MarkAsUndetectable() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::MarkAsUndetectable()")) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::ObjectTemplate::MarkAsUndetectable()")) return; + ENTER_V8; + HandleScope scope; EnsureConstructor(this); i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); @@ -1308,16 +1077,13 @@ void ObjectTemplate::SetAccessCheckCallbacks( IndexedSecurityCallback indexed_callback, Handle<Value> data, bool turned_on_by_default) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetAccessCheckCallbacks()")) { - return; - } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::ObjectTemplate::SetAccessCheckCallbacks()")) return; + ENTER_V8; + HandleScope scope; EnsureConstructor(this); i::Handle<i::Struct> struct_info = - isolate->factory()->NewStruct(i::ACCESS_CHECK_INFO_TYPE); + i::Factory::NewStruct(i::ACCESS_CHECK_INFO_TYPE); i::Handle<i::AccessCheckInfo> info = i::Handle<i::AccessCheckInfo>::cast(struct_info); @@ -1342,12 +1108,9 @@ void ObjectTemplate::SetIndexedPropertyHandler( IndexedPropertyDeleter remover, IndexedPropertyEnumerator enumerator, Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetIndexedPropertyHandler()")) { - return; - } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::ObjectTemplate::SetIndexedPropertyHandler()")) return; + ENTER_V8; + HandleScope scope; EnsureConstructor(this); i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); @@ -1363,13 +1126,9 @@ void ObjectTemplate::SetIndexedPropertyHandler( void ObjectTemplate::SetCallAsFunctionHandler(InvocationCallback callback, Handle<Value> data) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, - "v8::ObjectTemplate::SetCallAsFunctionHandler()")) { - return; - } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::ObjectTemplate::SetCallAsFunctionHandler()")) return; + ENTER_V8; + HandleScope scope; EnsureConstructor(this); i::FunctionTemplateInfo* constructor = i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor()); @@ -1379,8 +1138,7 @@ void ObjectTemplate::SetCallAsFunctionHandler(InvocationCallback callback, int ObjectTemplate::InternalFieldCount() { - if (IsDeadCheck(Utils::OpenHandle(this)->GetIsolate(), - "v8::ObjectTemplate::InternalFieldCount()")) { + if (IsDeadCheck("v8::ObjectTemplate::InternalFieldCount()")) { return 0; } return i::Smi::cast(Utils::OpenHandle(this)->internal_field_count())->value(); @@ -1388,16 +1146,13 @@ int ObjectTemplate::InternalFieldCount() { void ObjectTemplate::SetInternalFieldCount(int value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ObjectTemplate::SetInternalFieldCount()")) { - return; - } + if (IsDeadCheck("v8::ObjectTemplate::SetInternalFieldCount()")) return; if (!ApiCheck(i::Smi::IsValid(value), "v8::ObjectTemplate::SetInternalFieldCount()", "Invalid internal field count")) { return; } - ENTER_V8(isolate); + ENTER_V8; if (value > 0) { // The internal field count is set by the constructor function's // construct code, so we ensure that there is a constructor @@ -1445,7 +1200,7 @@ ScriptData* ScriptData::New(const char* data, int length) { } // Copy the data to align it. unsigned* deserialized_data = i::NewArray<unsigned>(deserialized_data_length); - i::OS::MemCopy(deserialized_data, data, length); + i::MemCopy(deserialized_data, data, length); return new i::ScriptDataImpl( i::Vector<unsigned>(deserialized_data, deserialized_data_length)); @@ -1459,10 +1214,9 @@ Local<Script> Script::New(v8::Handle<String> source, v8::ScriptOrigin* origin, v8::ScriptData* pre_data, v8::Handle<String> script_data) { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Script::New()", return Local<Script>()); - LOG_API(isolate, "Script::New"); - ENTER_V8(isolate); + ON_BAILOUT("v8::Script::New()", return Local<Script>()); + LOG_API("Script::New"); + ENTER_V8; i::Handle<i::String> str = Utils::OpenHandle(*source); i::Handle<i::Object> name_obj; int line_offset = 0; @@ -1478,7 +1232,7 @@ Local<Script> Script::New(v8::Handle<String> source, column_offset = static_cast<int>(origin->ResourceColumnOffset()->Value()); } } - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::ScriptDataImpl* pre_data_impl = static_cast<i::ScriptDataImpl*>(pre_data); // We assert that the pre-data is sane, even though we can actually // handle it if it turns out not to be in release mode. @@ -1497,7 +1251,7 @@ Local<Script> Script::New(v8::Handle<String> source, Utils::OpenHandle(*script_data), i::NOT_NATIVES_CODE); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Script>()); + EXCEPTION_BAILOUT_CHECK(Local<Script>()); return Local<Script>(ToApi<Script>(result)); } @@ -1513,10 +1267,9 @@ Local<Script> Script::Compile(v8::Handle<String> source, v8::ScriptOrigin* origin, v8::ScriptData* pre_data, v8::Handle<String> script_data) { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Script::Compile()", return Local<Script>()); - LOG_API(isolate, "Script::Compile"); - ENTER_V8(isolate); + ON_BAILOUT("v8::Script::Compile()", return Local<Script>()); + LOG_API("Script::Compile"); + ENTER_V8; Local<Script> generic = New(source, origin, pre_data, script_data); if (generic.IsEmpty()) return generic; @@ -1524,9 +1277,8 @@ Local<Script> Script::Compile(v8::Handle<String> source, i::Handle<i::SharedFunctionInfo> function = i::Handle<i::SharedFunctionInfo>(i::SharedFunctionInfo::cast(*obj)); i::Handle<i::JSFunction> result = - isolate->factory()->NewFunctionFromSharedFunctionInfo( - function, - isolate->global_context()); + i::Factory::NewFunctionFromSharedFunctionInfo(function, + i::Top::global_context()); return Local<Script>(ToApi<Script>(result)); } @@ -1540,32 +1292,30 @@ Local<Script> Script::Compile(v8::Handle<String> source, Local<Value> Script::Run() { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Script::Run()", return Local<Value>()); - LOG_API(isolate, "Script::Run"); - ENTER_V8(isolate); + ON_BAILOUT("v8::Script::Run()", return Local<Value>()); + LOG_API("Script::Run"); + ENTER_V8; i::Object* raw_result = NULL; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::JSFunction> fun; if (obj->IsSharedFunctionInfo()) { i::Handle<i::SharedFunctionInfo> - function_info(i::SharedFunctionInfo::cast(*obj), isolate); - fun = isolate->factory()->NewFunctionFromSharedFunctionInfo( - function_info, isolate->global_context()); + function_info(i::SharedFunctionInfo::cast(*obj)); + fun = i::Factory::NewFunctionFromSharedFunctionInfo( + function_info, i::Top::global_context()); } else { - fun = i::Handle<i::JSFunction>(i::JSFunction::cast(*obj), isolate); + fun = i::Handle<i::JSFunction>(i::JSFunction::cast(*obj)); } - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> receiver( - isolate->context()->global_proxy(), isolate); + EXCEPTION_PREAMBLE(); + i::Handle<i::Object> receiver(i::Top::context()->global_proxy()); i::Handle<i::Object> result = i::Execution::Call(fun, receiver, 0, NULL, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); + EXCEPTION_BAILOUT_CHECK(Local<Value>()); raw_result = *result; } - i::Handle<i::Object> result(raw_result, isolate); + i::Handle<i::Object> result(raw_result); return Utils::ToLocal(result); } @@ -1585,12 +1335,11 @@ static i::Handle<i::SharedFunctionInfo> OpenScript(Script* script) { Local<Value> Script::Id() { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Script::Id()", return Local<Value>()); - LOG_API(isolate, "Script::Id"); + ON_BAILOUT("v8::Script::Id()", return Local<Value>()); + LOG_API("Script::Id"); i::Object* raw_id = NULL; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::SharedFunctionInfo> function_info = OpenScript(this); i::Handle<i::Script> script(i::Script::cast(function_info->script())); i::Handle<i::Object> id(script->id()); @@ -1602,11 +1351,10 @@ Local<Value> Script::Id() { void Script::SetData(v8::Handle<String> data) { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Script::SetData()", return); - LOG_API(isolate, "Script::SetData"); + ON_BAILOUT("v8::Script::SetData()", return); + LOG_API("Script::SetData"); { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::SharedFunctionInfo> function_info = OpenScript(this); i::Handle<i::Object> raw_data = Utils::OpenHandle(*data); i::Handle<i::Script> script(i::Script::cast(function_info->script())); @@ -1619,27 +1367,25 @@ void Script::SetData(v8::Handle<String> data) { v8::TryCatch::TryCatch() - : isolate_(i::Isolate::Current()), - next_(isolate_->try_catch_handler_address()), - exception_(isolate_->heap()->the_hole_value()), + : next_(i::Top::try_catch_handler_address()), + exception_(i::Heap::the_hole_value()), message_(i::Smi::FromInt(0)), is_verbose_(false), can_continue_(true), capture_message_(true), rethrow_(false) { - isolate_->RegisterTryCatchHandler(this); + i::Top::RegisterTryCatchHandler(this); } v8::TryCatch::~TryCatch() { - ASSERT(isolate_ == i::Isolate::Current()); if (rethrow_) { v8::HandleScope scope; v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(Exception()); - isolate_->UnregisterTryCatchHandler(this); + i::Top::UnregisterTryCatchHandler(this); v8::ThrowException(exc); } else { - isolate_->UnregisterTryCatchHandler(this); + i::Top::UnregisterTryCatchHandler(this); } } @@ -1662,11 +1408,10 @@ v8::Handle<v8::Value> v8::TryCatch::ReThrow() { v8::Local<Value> v8::TryCatch::Exception() const { - ASSERT(isolate_ == i::Isolate::Current()); if (HasCaught()) { // Check for out of memory exception. i::Object* exception = reinterpret_cast<i::Object*>(exception_); - return v8::Utils::ToLocal(i::Handle<i::Object>(exception, isolate_)); + return v8::Utils::ToLocal(i::Handle<i::Object>(exception)); } else { return v8::Local<Value>(); } @@ -1674,15 +1419,15 @@ v8::Local<Value> v8::TryCatch::Exception() const { v8::Local<Value> v8::TryCatch::StackTrace() const { - ASSERT(isolate_ == i::Isolate::Current()); if (HasCaught()) { i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_); if (!raw_obj->IsJSObject()) return v8::Local<Value>(); - i::HandleScope scope(isolate_); - i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_); - i::Handle<i::String> name = isolate_->factory()->LookupAsciiSymbol("stack"); - if (!obj->HasProperty(*name)) return v8::Local<Value>(); - return v8::Utils::ToLocal(scope.CloseAndEscape(i::GetProperty(obj, name))); + v8::HandleScope scope; + i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj)); + i::Handle<i::String> name = i::Factory::LookupAsciiSymbol("stack"); + if (!obj->HasProperty(*name)) + return v8::Local<Value>(); + return scope.Close(v8::Utils::ToLocal(i::GetProperty(obj, name))); } else { return v8::Local<Value>(); } @@ -1690,10 +1435,9 @@ v8::Local<Value> v8::TryCatch::StackTrace() const { v8::Local<v8::Message> v8::TryCatch::Message() const { - ASSERT(isolate_ == i::Isolate::Current()); if (HasCaught() && message_ != i::Smi::FromInt(0)) { i::Object* message = reinterpret_cast<i::Object*>(message_); - return v8::Utils::MessageToLocal(i::Handle<i::Object>(message, isolate_)); + return v8::Utils::MessageToLocal(i::Handle<i::Object>(message)); } else { return v8::Local<v8::Message>(); } @@ -1701,8 +1445,7 @@ v8::Local<v8::Message> v8::TryCatch::Message() const { void v8::TryCatch::Reset() { - ASSERT(isolate_ == i::Isolate::Current()); - exception_ = isolate_->heap()->the_hole_value(); + exception_ = i::Heap::the_hole_value(); message_ = i::Smi::FromInt(0); } @@ -1721,9 +1464,8 @@ void v8::TryCatch::SetCaptureMessage(bool value) { Local<String> Message::Get() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Message::Get()", return Local<String>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Message::Get()", return Local<String>()); + ENTER_V8; HandleScope scope; i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::String> raw_result = i::MessageHandler::GetMessage(obj); @@ -1733,11 +1475,10 @@ Local<String> Message::Get() const { v8::Handle<Value> Message::GetScriptResourceName() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetScriptResourceName()")) { + if (IsDeadCheck("v8::Message::GetScriptResourceName()")) { return Local<String>(); } - ENTER_V8(isolate); + ENTER_V8; HandleScope scope; i::Handle<i::JSMessageObject> message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this)); @@ -1750,11 +1491,10 @@ v8::Handle<Value> Message::GetScriptResourceName() const { v8::Handle<Value> Message::GetScriptData() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetScriptResourceData()")) { + if (IsDeadCheck("v8::Message::GetScriptResourceData()")) { return Local<Value>(); } - ENTER_V8(isolate); + ENTER_V8; HandleScope scope; i::Handle<i::JSMessageObject> message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this)); @@ -1767,11 +1507,10 @@ v8::Handle<Value> Message::GetScriptData() const { v8::Handle<v8::StackTrace> Message::GetStackTrace() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetStackTrace()")) { + if (IsDeadCheck("v8::Message::GetStackTrace()")) { return Local<v8::StackTrace>(); } - ENTER_V8(isolate); + ENTER_V8; HandleScope scope; i::Handle<i::JSMessageObject> message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this)); @@ -1788,10 +1527,9 @@ static i::Handle<i::Object> CallV8HeapFunction(const char* name, int argc, i::Object** argv[], bool* has_pending_exception) { - i::Isolate* isolate = i::Isolate::Current(); - i::Handle<i::String> fmt_str = isolate->factory()->LookupAsciiSymbol(name); + i::Handle<i::String> fmt_str = i::Factory::LookupAsciiSymbol(name); i::Object* object_fun = - isolate->js_builtins_object()->GetPropertyNoExceptionThrown(*fmt_str); + i::Top::builtins()->GetPropertyNoExceptionThrown(*fmt_str); i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>(i::JSFunction::cast(object_fun)); i::Handle<i::Object> value = @@ -1805,7 +1543,7 @@ static i::Handle<i::Object> CallV8HeapFunction(const char* name, bool* has_pending_exception) { i::Object** argv[1] = { data.location() }; return CallV8HeapFunction(name, - i::Isolate::Current()->js_builtins_object(), + i::Top::builtins(), 1, argv, has_pending_exception); @@ -1813,25 +1551,23 @@ static i::Handle<i::Object> CallV8HeapFunction(const char* name, int Message::GetLineNumber() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Message::GetLineNumber()", return kNoLineNumberInfo); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Message::GetLineNumber()", return kNoLineNumberInfo); + ENTER_V8; + HandleScope scope; - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = CallV8HeapFunction("GetLineNumber", Utils::OpenHandle(this), &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, 0); + EXCEPTION_BAILOUT_CHECK(0); return static_cast<int>(result->Number()); } int Message::GetStartPosition() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetStartPosition()")) return 0; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::Message::GetStartPosition()")) return 0; + ENTER_V8; + HandleScope scope; i::Handle<i::JSMessageObject> message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this)); return message->start_position(); @@ -1839,10 +1575,9 @@ int Message::GetStartPosition() const { int Message::GetEndPosition() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetEndPosition()")) return 0; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::Message::GetEndPosition()")) return 0; + ENTER_V8; + HandleScope scope; i::Handle<i::JSMessageObject> message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this)); return message->end_position(); @@ -1850,35 +1585,31 @@ int Message::GetEndPosition() const { int Message::GetStartColumn() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetStartColumn()")) { - return kNoColumnInfo; - } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::Message::GetStartColumn()")) return kNoColumnInfo; + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> start_col_obj = CallV8HeapFunction( "GetPositionInLine", data_obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, 0); + EXCEPTION_BAILOUT_CHECK(0); return static_cast<int>(start_col_obj->Number()); } int Message::GetEndColumn() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Message::GetEndColumn()")) return kNoColumnInfo; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::Message::GetEndColumn()")) return kNoColumnInfo; + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> start_col_obj = CallV8HeapFunction( "GetPositionInLine", data_obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, 0); + EXCEPTION_BAILOUT_CHECK(0); i::Handle<i::JSMessageObject> message = i::Handle<i::JSMessageObject>::cast(data_obj); int start = message->start_position(); @@ -1888,15 +1619,14 @@ int Message::GetEndColumn() const { Local<String> Message::GetSourceLine() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Message::GetSourceLine()", return Local<String>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Message::GetSourceLine()", return Local<String>()); + ENTER_V8; HandleScope scope; - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = CallV8HeapFunction("GetSourceLine", Utils::OpenHandle(this), &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::String>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::String>()); if (result->IsString()) { return scope.Close(Utils::ToLocal(i::Handle<i::String>::cast(result))); } else { @@ -1906,21 +1636,17 @@ Local<String> Message::GetSourceLine() const { void Message::PrintCurrentStackTrace(FILE* out) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Message::PrintCurrentStackTrace()")) return; - ENTER_V8(isolate); - isolate->PrintCurrentStackTrace(out); + if (IsDeadCheck("v8::Message::PrintCurrentStackTrace()")) return; + ENTER_V8; + i::Top::PrintCurrentStackTrace(out); } // --- S t a c k T r a c e --- Local<StackFrame> StackTrace::GetFrame(uint32_t index) const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackTrace::GetFrame()")) { - return Local<StackFrame>(); - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::StackTrace::GetFrame()")) return Local<StackFrame>(); + ENTER_V8; HandleScope scope; i::Handle<i::JSArray> self = Utils::OpenHandle(this); i::Object* raw_object = self->GetElementNoExceptionThrown(index); @@ -1930,30 +1656,25 @@ Local<StackFrame> StackTrace::GetFrame(uint32_t index) const { int StackTrace::GetFrameCount() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackTrace::GetFrameCount()")) return -1; - ENTER_V8(isolate); + if (IsDeadCheck("v8::StackTrace::GetFrameCount()")) return -1; + ENTER_V8; return i::Smi::cast(Utils::OpenHandle(this)->length())->value(); } Local<Array> StackTrace::AsArray() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackTrace::AsArray()")) Local<Array>(); - ENTER_V8(isolate); + if (IsDeadCheck("v8::StackTrace::AsArray()")) Local<Array>(); + ENTER_V8; return Utils::ToLocal(Utils::OpenHandle(this)); } Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit, StackTraceOptions options) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::StackTrace::CurrentStackTrace()")) { - Local<StackTrace>(); - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::StackTrace::CurrentStackTrace()")) Local<StackTrace>(); + ENTER_V8; i::Handle<i::JSArray> stackTrace = - isolate->CaptureCurrentStackTrace(frame_limit, options); + i::Top::CaptureCurrentStackTrace(frame_limit, options); return Utils::StackTraceToLocal(stackTrace); } @@ -1961,12 +1682,11 @@ Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit, // --- S t a c k F r a m e --- int StackFrame::GetLineNumber() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::GetLineNumber()")) { + if (IsDeadCheck("v8::StackFrame::GetLineNumber()")) { return Message::kNoLineNumberInfo; } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + i::HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> line = GetProperty(self, "lineNumber"); if (!line->IsSmi()) { @@ -1977,12 +1697,11 @@ int StackFrame::GetLineNumber() const { int StackFrame::GetColumn() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::GetColumn()")) { + if (IsDeadCheck("v8::StackFrame::GetColumn()")) { return Message::kNoColumnInfo; } - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + i::HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> column = GetProperty(self, "column"); if (!column->IsSmi()) { @@ -1993,11 +1712,8 @@ int StackFrame::GetColumn() const { Local<String> StackFrame::GetScriptName() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::GetScriptName()")) { - return Local<String>(); - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::StackFrame::GetScriptName()")) return Local<String>(); + ENTER_V8; HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> name = GetProperty(self, "scriptName"); @@ -2009,11 +1725,10 @@ Local<String> StackFrame::GetScriptName() const { Local<String> StackFrame::GetScriptNameOrSourceURL() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::GetScriptNameOrSourceURL()")) { + if (IsDeadCheck("v8::StackFrame::GetScriptNameOrSourceURL()")) { return Local<String>(); } - ENTER_V8(isolate); + ENTER_V8; HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> name = GetProperty(self, "scriptNameOrSourceURL"); @@ -2025,11 +1740,8 @@ Local<String> StackFrame::GetScriptNameOrSourceURL() const { Local<String> StackFrame::GetFunctionName() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::GetFunctionName()")) { - return Local<String>(); - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::StackFrame::GetFunctionName()")) return Local<String>(); + ENTER_V8; HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> name = GetProperty(self, "functionName"); @@ -2041,10 +1753,9 @@ Local<String> StackFrame::GetFunctionName() const { bool StackFrame::IsEval() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::IsEval()")) return false; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::StackFrame::IsEval()")) return false; + ENTER_V8; + i::HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> is_eval = GetProperty(self, "isEval"); return is_eval->IsTrue(); @@ -2052,10 +1763,9 @@ bool StackFrame::IsEval() const { bool StackFrame::IsConstructor() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::StackFrame::IsConstructor()")) return false; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + if (IsDeadCheck("v8::StackFrame::IsConstructor()")) return false; + ENTER_V8; + i::HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> is_constructor = GetProperty(self, "isConstructor"); return is_constructor->IsTrue(); @@ -2065,41 +1775,37 @@ bool StackFrame::IsConstructor() const { // --- D a t a --- bool Value::IsUndefined() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsUndefined()")) { - return false; - } + if (IsDeadCheck("v8::Value::IsUndefined()")) return false; return Utils::OpenHandle(this)->IsUndefined(); } bool Value::IsNull() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsNull()")) return false; + if (IsDeadCheck("v8::Value::IsNull()")) return false; return Utils::OpenHandle(this)->IsNull(); } bool Value::IsTrue() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsTrue()")) return false; + if (IsDeadCheck("v8::Value::IsTrue()")) return false; return Utils::OpenHandle(this)->IsTrue(); } bool Value::IsFalse() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsFalse()")) return false; + if (IsDeadCheck("v8::Value::IsFalse()")) return false; return Utils::OpenHandle(this)->IsFalse(); } bool Value::IsFunction() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsFunction()")) { - return false; - } + if (IsDeadCheck("v8::Value::IsFunction()")) return false; return Utils::OpenHandle(this)->IsJSFunction(); } bool Value::FullIsString() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsString()")) return false; + if (IsDeadCheck("v8::Value::IsString()")) return false; bool result = Utils::OpenHandle(this)->IsString(); ASSERT_EQ(result, QuickIsString()); return result; @@ -2107,41 +1813,37 @@ bool Value::FullIsString() const { bool Value::IsArray() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsArray()")) return false; + if (IsDeadCheck("v8::Value::IsArray()")) return false; return Utils::OpenHandle(this)->IsJSArray(); } bool Value::IsObject() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsObject()")) return false; + if (IsDeadCheck("v8::Value::IsObject()")) return false; return Utils::OpenHandle(this)->IsJSObject(); } bool Value::IsNumber() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsNumber()")) return false; + if (IsDeadCheck("v8::Value::IsNumber()")) return false; return Utils::OpenHandle(this)->IsNumber(); } bool Value::IsBoolean() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsBoolean()")) { - return false; - } + if (IsDeadCheck("v8::Value::IsBoolean()")) return false; return Utils::OpenHandle(this)->IsBoolean(); } bool Value::IsExternal() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsExternal()")) { - return false; - } - return Utils::OpenHandle(this)->IsForeign(); + if (IsDeadCheck("v8::Value::IsExternal()")) return false; + return Utils::OpenHandle(this)->IsProxy(); } bool Value::IsInt32() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsInt32()")) return false; + if (IsDeadCheck("v8::Value::IsInt32()")) return false; i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) return true; if (obj->IsNumber()) { @@ -2153,7 +1855,7 @@ bool Value::IsInt32() const { bool Value::IsUint32() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsUint32()")) return false; + if (IsDeadCheck("v8::Value::IsUint32()")) return false; i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) return i::Smi::cast(*obj)->value() >= 0; if (obj->IsNumber()) { @@ -2165,91 +1867,78 @@ bool Value::IsUint32() const { bool Value::IsDate() const { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::IsDate()")) return false; + if (IsDeadCheck("v8::Value::IsDate()")) return false; i::Handle<i::Object> obj = Utils::OpenHandle(this); - return obj->HasSpecificClassOf(isolate->heap()->Date_symbol()); + return obj->HasSpecificClassOf(i::Heap::Date_symbol()); } bool Value::IsRegExp() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Value::IsRegExp()")) return false; + if (IsDeadCheck("v8::Value::IsRegExp()")) return false; i::Handle<i::Object> obj = Utils::OpenHandle(this); return obj->IsJSRegExp(); } Local<String> Value::ToString() const { + if (IsDeadCheck("v8::Value::ToString()")) return Local<String>(); + LOG_API("ToString"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> str; if (obj->IsString()) { str = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToString()")) { - return Local<String>(); - } - LOG_API(isolate, "ToString"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); str = i::Execution::ToString(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<String>()); + EXCEPTION_BAILOUT_CHECK(Local<String>()); } return Local<String>(ToApi<String>(str)); } Local<String> Value::ToDetailString() const { + if (IsDeadCheck("v8::Value::ToDetailString()")) return Local<String>(); + LOG_API("ToDetailString"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> str; if (obj->IsString()) { str = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToDetailString()")) { - return Local<String>(); - } - LOG_API(isolate, "ToDetailString"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); str = i::Execution::ToDetailString(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<String>()); + EXCEPTION_BAILOUT_CHECK(Local<String>()); } return Local<String>(ToApi<String>(str)); } Local<v8::Object> Value::ToObject() const { + if (IsDeadCheck("v8::Value::ToObject()")) return Local<v8::Object>(); + LOG_API("ToObject"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> val; if (obj->IsJSObject()) { val = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToObject()")) { - return Local<v8::Object>(); - } - LOG_API(isolate, "ToObject"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); val = i::Execution::ToObject(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::Object>()); } return Local<v8::Object>(ToApi<Object>(val)); } Local<Boolean> Value::ToBoolean() const { + if (IsDeadCheck("v8::Value::ToBoolean()")) return Local<Boolean>(); + LOG_API("ToBoolean"); i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsBoolean()) { return Local<Boolean>(ToApi<Boolean>(obj)); } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToBoolean()")) { - return Local<Boolean>(); - } - LOG_API(isolate, "ToBoolean"); - ENTER_V8(isolate); + ENTER_V8; i::Handle<i::Object> val = i::Execution::ToBoolean(obj); return Local<Boolean>(ToApi<Boolean>(val)); } @@ -2257,54 +1946,50 @@ Local<Boolean> Value::ToBoolean() const { Local<Number> Value::ToNumber() const { + if (IsDeadCheck("v8::Value::ToNumber()")) return Local<Number>(); + LOG_API("ToNumber"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> num; if (obj->IsNumber()) { num = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToNumber()")) { - return Local<Number>(); - } - LOG_API(isolate, "ToNumber"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); num = i::Execution::ToNumber(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Number>()); + EXCEPTION_BAILOUT_CHECK(Local<Number>()); } return Local<Number>(ToApi<Number>(num)); } Local<Integer> Value::ToInteger() const { + if (IsDeadCheck("v8::Value::ToInteger()")) return Local<Integer>(); + LOG_API("ToInteger"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> num; if (obj->IsSmi()) { num = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToInteger()")) return Local<Integer>(); - LOG_API(isolate, "ToInteger"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); num = i::Execution::ToInteger(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Integer>()); + EXCEPTION_BAILOUT_CHECK(Local<Integer>()); } return Local<Integer>(ToApi<Integer>(num)); } void External::CheckCast(v8::Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::External::Cast()")) return; + if (IsDeadCheck("v8::External::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); - ApiCheck(obj->IsForeign(), + ApiCheck(obj->IsProxy(), "v8::External::Cast()", "Could not convert to external"); } void v8::Object::CheckCast(Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::Object::Cast()")) return; + if (IsDeadCheck("v8::Object::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsJSObject(), "v8::Object::Cast()", @@ -2313,7 +1998,7 @@ void v8::Object::CheckCast(Value* that) { void v8::Function::CheckCast(Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::Function::Cast()")) return; + if (IsDeadCheck("v8::Function::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsJSFunction(), "v8::Function::Cast()", @@ -2322,7 +2007,7 @@ void v8::Function::CheckCast(Value* that) { void v8::String::CheckCast(v8::Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::String::Cast()")) return; + if (IsDeadCheck("v8::String::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsString(), "v8::String::Cast()", @@ -2331,7 +2016,7 @@ void v8::String::CheckCast(v8::Value* that) { void v8::Number::CheckCast(v8::Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::Number::Cast()")) return; + if (IsDeadCheck("v8::Number::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsNumber(), "v8::Number::Cast()", @@ -2340,7 +2025,7 @@ void v8::Number::CheckCast(v8::Value* that) { void v8::Integer::CheckCast(v8::Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::Integer::Cast()")) return; + if (IsDeadCheck("v8::Integer::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsNumber(), "v8::Integer::Cast()", @@ -2349,7 +2034,7 @@ void v8::Integer::CheckCast(v8::Value* that) { void v8::Array::CheckCast(Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::Array::Cast()")) return; + if (IsDeadCheck("v8::Array::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsJSArray(), "v8::Array::Cast()", @@ -2358,17 +2043,16 @@ void v8::Array::CheckCast(Value* that) { void v8::Date::CheckCast(v8::Value* that) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Date::Cast()")) return; + if (IsDeadCheck("v8::Date::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); - ApiCheck(obj->HasSpecificClassOf(isolate->heap()->Date_symbol()), + ApiCheck(obj->HasSpecificClassOf(i::Heap::Date_symbol()), "v8::Date::Cast()", "Could not convert to date"); } void v8::RegExp::CheckCast(v8::Value* that) { - if (IsDeadCheck(i::Isolate::Current(), "v8::RegExp::Cast()")) return; + if (IsDeadCheck("v8::RegExp::Cast()")) return; i::Handle<i::Object> obj = Utils::OpenHandle(that); ApiCheck(obj->IsJSRegExp(), "v8::RegExp::Cast()", @@ -2377,14 +2061,13 @@ void v8::RegExp::CheckCast(v8::Value* that) { bool Value::BooleanValue() const { + if (IsDeadCheck("v8::Value::BooleanValue()")) return false; + LOG_API("BooleanValue"); i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsBoolean()) { return obj->IsTrue(); } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::BooleanValue()")) return false; - LOG_API(isolate, "BooleanValue"); - ENTER_V8(isolate); + ENTER_V8; i::Handle<i::Object> value = i::Execution::ToBoolean(obj); return value->IsTrue(); } @@ -2392,38 +2075,34 @@ bool Value::BooleanValue() const { double Value::NumberValue() const { + if (IsDeadCheck("v8::Value::NumberValue()")) return i::OS::nan_value(); + LOG_API("NumberValue"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> num; if (obj->IsNumber()) { num = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::NumberValue()")) { - return i::OS::nan_value(); - } - LOG_API(isolate, "NumberValue"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); num = i::Execution::ToNumber(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, i::OS::nan_value()); + EXCEPTION_BAILOUT_CHECK(i::OS::nan_value()); } return num->Number(); } int64_t Value::IntegerValue() const { + if (IsDeadCheck("v8::Value::IntegerValue()")) return 0; + LOG_API("IntegerValue"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> num; if (obj->IsNumber()) { num = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::IntegerValue()")) return 0; - LOG_API(isolate, "IntegerValue"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); num = i::Execution::ToInteger(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, 0); + EXCEPTION_BAILOUT_CHECK(0); } if (num->IsSmi()) { return i::Smi::cast(*num)->value(); @@ -2434,55 +2113,52 @@ int64_t Value::IntegerValue() const { Local<Int32> Value::ToInt32() const { + if (IsDeadCheck("v8::Value::ToInt32()")) return Local<Int32>(); + LOG_API("ToInt32"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> num; if (obj->IsSmi()) { num = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToInt32()")) return Local<Int32>(); - LOG_API(isolate, "ToInt32"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); num = i::Execution::ToInt32(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Int32>()); + EXCEPTION_BAILOUT_CHECK(Local<Int32>()); } return Local<Int32>(ToApi<Int32>(num)); } Local<Uint32> Value::ToUint32() const { + if (IsDeadCheck("v8::Value::ToUint32()")) return Local<Uint32>(); + LOG_API("ToUInt32"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> num; if (obj->IsSmi()) { num = obj; } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToUint32()")) return Local<Uint32>(); - LOG_API(isolate, "ToUInt32"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); num = i::Execution::ToUint32(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Uint32>()); + EXCEPTION_BAILOUT_CHECK(Local<Uint32>()); } return Local<Uint32>(ToApi<Uint32>(num)); } Local<Uint32> Value::ToArrayIndex() const { + if (IsDeadCheck("v8::Value::ToArrayIndex()")) return Local<Uint32>(); + LOG_API("ToArrayIndex"); i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) { if (i::Smi::cast(*obj)->value() >= 0) return Utils::Uint32ToLocal(obj); return Local<Uint32>(); } - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::ToArrayIndex()")) return Local<Uint32>(); - LOG_API(isolate, "ToArrayIndex"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::Object> string_obj = i::Execution::ToString(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Uint32>()); + EXCEPTION_BAILOUT_CHECK(Local<Uint32>()); i::Handle<i::String> str = i::Handle<i::String>::cast(string_obj); uint32_t index; if (str->AsArrayIndex(&index)) { @@ -2490,7 +2166,7 @@ Local<Uint32> Value::ToArrayIndex() const { if (index <= static_cast<uint32_t>(i::Smi::kMaxValue)) { value = i::Handle<i::Object>(i::Smi::FromInt(index)); } else { - value = isolate->factory()->NewNumber(index); + value = i::Factory::NewNumber(index); } return Utils::Uint32ToLocal(value); } @@ -2499,18 +2175,18 @@ Local<Uint32> Value::ToArrayIndex() const { int32_t Value::Int32Value() const { + if (IsDeadCheck("v8::Value::Int32Value()")) return 0; + LOG_API("Int32Value"); i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) { return i::Smi::cast(*obj)->value(); } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::Int32Value()")) return 0; - LOG_API(isolate, "Int32Value (slow)"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + LOG_API("Int32Value (slow)"); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::Object> num = i::Execution::ToInt32(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, 0); + EXCEPTION_BAILOUT_CHECK(0); if (num->IsSmi()) { return i::Smi::cast(*num)->value(); } else { @@ -2521,14 +2197,13 @@ int32_t Value::Int32Value() const { bool Value::Equals(Handle<Value> that) const { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::Equals()") + if (IsDeadCheck("v8::Value::Equals()") || EmptyCheck("v8::Value::Equals()", this) || EmptyCheck("v8::Value::Equals()", that)) { return false; } - LOG_API(isolate, "Equals"); - ENTER_V8(isolate); + LOG_API("Equals"); + ENTER_V8; i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> other = Utils::OpenHandle(*that); // If both obj and other are JSObjects, we'd better compare by identity @@ -2538,22 +2213,21 @@ bool Value::Equals(Handle<Value> that) const { return *obj == *other; } i::Object** args[1] = { other.location() }; - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = CallV8HeapFunction("EQUALS", obj, 1, args, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return *result == i::Smi::FromInt(i::EQUAL); } bool Value::StrictEquals(Handle<Value> that) const { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::StrictEquals()") + if (IsDeadCheck("v8::Value::StrictEquals()") || EmptyCheck("v8::Value::StrictEquals()", this) || EmptyCheck("v8::Value::StrictEquals()", that)) { return false; } - LOG_API(isolate, "StrictEquals"); + LOG_API("StrictEquals"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::Object> other = Utils::OpenHandle(*that); // Must check HeapNumber first, since NaN !== NaN. @@ -2579,18 +2253,17 @@ bool Value::StrictEquals(Handle<Value> that) const { uint32_t Value::Uint32Value() const { + if (IsDeadCheck("v8::Value::Uint32Value()")) return 0; + LOG_API("Uint32Value"); i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) { return i::Smi::cast(*obj)->value(); } else { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Value::Uint32Value()")) return 0; - LOG_API(isolate, "Uint32Value"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::Object> num = i::Execution::ToUint32(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, 0); + EXCEPTION_BAILOUT_CHECK(0); if (num->IsSmi()) { return i::Smi::cast(*num)->value(); } else { @@ -2602,14 +2275,13 @@ uint32_t Value::Uint32Value() const { bool v8::Object::Set(v8::Handle<Value> key, v8::Handle<Value> value, v8::PropertyAttribute attribs) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Set()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::Set()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::Object> self = Utils::OpenHandle(this); i::Handle<i::Object> key_obj = Utils::OpenHandle(*key); i::Handle<i::Object> value_obj = Utils::OpenHandle(*value); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::SetProperty( self, key_obj, @@ -2617,26 +2289,24 @@ bool v8::Object::Set(v8::Handle<Value> key, v8::Handle<Value> value, static_cast<PropertyAttributes>(attribs), i::kNonStrictMode); has_pending_exception = obj.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return true; } bool v8::Object::Set(uint32_t index, v8::Handle<Value> value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Set()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::Set()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> value_obj = Utils::OpenHandle(*value); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::SetElement( self, index, - value_obj, - i::kNonStrictMode); + value_obj); has_pending_exception = obj.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return true; } @@ -2644,30 +2314,28 @@ bool v8::Object::Set(uint32_t index, v8::Handle<Value> value) { bool v8::Object::ForceSet(v8::Handle<Value> key, v8::Handle<Value> value, v8::PropertyAttribute attribs) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::ForceSet()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::ForceSet()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> key_obj = Utils::OpenHandle(*key); i::Handle<i::Object> value_obj = Utils::OpenHandle(*value); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::ForceSetProperty( self, key_obj, value_obj, static_cast<PropertyAttributes>(attribs)); has_pending_exception = obj.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return true; } bool v8::Object::ForceDelete(v8::Handle<Value> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::ForceDelete()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::ForceDelete()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> key_obj = Utils::OpenHandle(*key); @@ -2675,46 +2343,42 @@ bool v8::Object::ForceDelete(v8::Handle<Value> key) { // as optimized code does not always handle access checks. i::Deoptimizer::DeoptimizeGlobalObject(*self); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::ForceDeleteProperty(self, key_obj); has_pending_exception = obj.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return obj->IsTrue(); } Local<Value> v8::Object::Get(v8::Handle<Value> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Get()", return Local<v8::Value>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::Get()", return Local<v8::Value>()); + ENTER_V8; i::Handle<i::Object> self = Utils::OpenHandle(this); i::Handle<i::Object> key_obj = Utils::OpenHandle(*key); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = i::GetProperty(self, key_obj); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); + EXCEPTION_BAILOUT_CHECK(Local<Value>()); return Utils::ToLocal(result); } Local<Value> v8::Object::Get(uint32_t index) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Get()", return Local<v8::Value>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::Get()", return Local<v8::Value>()); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = i::GetElement(self, index); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); + EXCEPTION_BAILOUT_CHECK(Local<Value>()); return Utils::ToLocal(result); } Local<Value> v8::Object::GetPrototype() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetPrototype()", - return Local<v8::Value>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::GetPrototype()", return Local<v8::Value>()); + ENTER_V8; i::Handle<i::Object> self = Utils::OpenHandle(this); i::Handle<i::Object> result = i::GetPrototype(self); return Utils::ToLocal(result); @@ -2722,29 +2386,23 @@ Local<Value> v8::Object::GetPrototype() { bool v8::Object::SetPrototype(Handle<Value> value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::SetPrototype()", return false); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::SetPrototype()", return false); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> value_obj = Utils::OpenHandle(*value); - // We do not allow exceptions thrown while setting the prototype - // to propagate outside. - TryCatch try_catch; - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = i::SetPrototype(self, value_obj); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return true; } Local<Object> v8::Object::FindInstanceInPrototypeChain( v8::Handle<FunctionTemplate> tmpl) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, - "v8::Object::FindInstanceInPrototypeChain()", + ON_BAILOUT("v8::Object::FindInstanceInPrototypeChain()", return Local<v8::Object>()); - ENTER_V8(isolate); + ENTER_V8; i::JSObject* object = *Utils::OpenHandle(this); i::FunctionTemplateInfo* tmpl_info = *Utils::OpenHandle(*tmpl); while (!object->IsInstanceOf(tmpl_info)) { @@ -2757,48 +2415,24 @@ Local<Object> v8::Object::FindInstanceInPrototypeChain( Local<Array> v8::Object::GetPropertyNames() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetPropertyNames()", - return Local<v8::Array>()); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::GetPropertyNames()", return Local<v8::Array>()); + ENTER_V8; + v8::HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::FixedArray> value = i::GetKeysInFixedArrayFor(self, i::INCLUDE_PROTOS); // Because we use caching to speed up enumeration it is important // to never change the result of the basic enumeration function so // we clone the result. - i::Handle<i::FixedArray> elms = isolate->factory()->CopyFixedArray(value); - i::Handle<i::JSArray> result = - isolate->factory()->NewJSArrayWithElements(elms); - return Utils::ToLocal(scope.CloseAndEscape(result)); -} - - -Local<Array> v8::Object::GetOwnPropertyNames() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetOwnPropertyNames()", - return Local<v8::Array>()); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - i::Handle<i::JSObject> self = Utils::OpenHandle(this); - i::Handle<i::FixedArray> value = - i::GetKeysInFixedArrayFor(self, i::LOCAL_ONLY); - // Because we use caching to speed up enumeration it is important - // to never change the result of the basic enumeration function so - // we clone the result. - i::Handle<i::FixedArray> elms = isolate->factory()->CopyFixedArray(value); - i::Handle<i::JSArray> result = - isolate->factory()->NewJSArrayWithElements(elms); - return Utils::ToLocal(scope.CloseAndEscape(result)); + i::Handle<i::FixedArray> elms = i::Factory::CopyFixedArray(value); + i::Handle<i::JSArray> result = i::Factory::NewJSArrayWithElements(elms); + return scope.Close(Utils::ToLocal(result)); } Local<String> v8::Object::ObjectProtoToString() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::ObjectProtoToString()", - return Local<v8::String>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::ObjectProtoToString()", return Local<v8::String>()); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> name(self->class_name()); @@ -2849,10 +2483,8 @@ Local<String> v8::Object::ObjectProtoToString() { Local<String> v8::Object::GetConstructorName() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetConstructorName()", - return Local<v8::String>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::GetConstructorName()", return Local<v8::String>()); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::String> name(self->constructor_name()); return Utils::ToLocal(name); @@ -2860,10 +2492,9 @@ Local<String> v8::Object::GetConstructorName() { bool v8::Object::Delete(v8::Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Delete()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::Delete()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::String> key_obj = Utils::OpenHandle(*key); return i::DeleteProperty(self, key_obj)->IsTrue(); @@ -2871,9 +2502,8 @@ bool v8::Object::Delete(v8::Handle<String> key) { bool v8::Object::Has(v8::Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Has()", return false); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::Has()", return false); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::String> key_obj = Utils::OpenHandle(*key); return self->HasProperty(*key_obj); @@ -2881,10 +2511,8 @@ bool v8::Object::Has(v8::Handle<String> key) { bool v8::Object::Delete(uint32_t index) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::DeleteProperty()", - return false); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::DeleteProperty()", return false); + ENTER_V8; HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); return i::DeleteElement(self, index)->IsTrue(); @@ -2892,8 +2520,7 @@ bool v8::Object::Delete(uint32_t index) { bool v8::Object::Has(uint32_t index) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::HasProperty()", return false); + ON_BAILOUT("v8::Object::HasProperty()", return false); i::Handle<i::JSObject> self = Utils::OpenHandle(this); return self->HasElement(index); } @@ -2905,10 +2532,9 @@ bool Object::SetAccessor(Handle<String> name, v8::Handle<Value> data, AccessControl settings, PropertyAttribute attributes) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::SetAccessor()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::SetAccessor()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::AccessorInfo> info = MakeAccessorInfo(name, getter, setter, data, settings, attributes); @@ -2917,104 +2543,80 @@ bool Object::SetAccessor(Handle<String> name, } -bool v8::Object::HasOwnProperty(Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::HasOwnProperty()", - return false); - return Utils::OpenHandle(this)->HasLocalProperty( - *Utils::OpenHandle(*key)); -} - - bool v8::Object::HasRealNamedProperty(Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::HasRealNamedProperty()", - return false); + ON_BAILOUT("v8::Object::HasRealNamedProperty()", return false); return Utils::OpenHandle(this)->HasRealNamedProperty( *Utils::OpenHandle(*key)); } bool v8::Object::HasRealIndexedProperty(uint32_t index) { - ON_BAILOUT(Utils::OpenHandle(this)->GetIsolate(), - "v8::Object::HasRealIndexedProperty()", - return false); + ON_BAILOUT("v8::Object::HasRealIndexedProperty()", return false); return Utils::OpenHandle(this)->HasRealElementProperty(index); } bool v8::Object::HasRealNamedCallbackProperty(Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, - "v8::Object::HasRealNamedCallbackProperty()", - return false); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::HasRealNamedCallbackProperty()", return false); + ENTER_V8; return Utils::OpenHandle(this)->HasRealNamedCallbackProperty( *Utils::OpenHandle(*key)); } bool v8::Object::HasNamedLookupInterceptor() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::HasNamedLookupInterceptor()", - return false); + ON_BAILOUT("v8::Object::HasNamedLookupInterceptor()", return false); return Utils::OpenHandle(this)->HasNamedInterceptor(); } bool v8::Object::HasIndexedLookupInterceptor() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::HasIndexedLookupInterceptor()", - return false); + ON_BAILOUT("v8::Object::HasIndexedLookupInterceptor()", return false); return Utils::OpenHandle(this)->HasIndexedInterceptor(); } -static Local<Value> GetPropertyByLookup(i::Isolate* isolate, - i::Handle<i::JSObject> receiver, - i::Handle<i::String> name, - i::LookupResult* lookup) { - if (!lookup->IsProperty()) { - // No real property was found. - return Local<Value>(); - } - - // If the property being looked up is a callback, it can throw - // an exception. - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> result = i::GetProperty(receiver, name, lookup); - has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); - - return Utils::ToLocal(result); -} - - Local<Value> v8::Object::GetRealNamedPropertyInPrototypeChain( Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, - "v8::Object::GetRealNamedPropertyInPrototypeChain()", + ON_BAILOUT("v8::Object::GetRealNamedPropertyInPrototypeChain()", return Local<Value>()); - ENTER_V8(isolate); + ENTER_V8; i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this); i::Handle<i::String> key_obj = Utils::OpenHandle(*key); i::LookupResult lookup; self_obj->LookupRealNamedPropertyInPrototypes(*key_obj, &lookup); - return GetPropertyByLookup(isolate, self_obj, key_obj, &lookup); + if (lookup.IsProperty()) { + PropertyAttributes attributes; + i::Object* property = + self_obj->GetProperty(*self_obj, + &lookup, + *key_obj, + &attributes)->ToObjectUnchecked(); + i::Handle<i::Object> result(property); + return Utils::ToLocal(result); + } + return Local<Value>(); // No real property was found in prototype chain. } Local<Value> v8::Object::GetRealNamedProperty(Handle<String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetRealNamedProperty()", - return Local<Value>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::GetRealNamedProperty()", return Local<Value>()); + ENTER_V8; i::Handle<i::JSObject> self_obj = Utils::OpenHandle(this); i::Handle<i::String> key_obj = Utils::OpenHandle(*key); i::LookupResult lookup; self_obj->LookupRealNamedProperty(*key_obj, &lookup); - return GetPropertyByLookup(isolate, self_obj, key_obj, &lookup); + if (lookup.IsProperty()) { + PropertyAttributes attributes; + i::Object* property = + self_obj->GetProperty(*self_obj, + &lookup, + *key_obj, + &attributes)->ToObjectUnchecked(); + i::Handle<i::Object> result(property); + return Utils::ToLocal(result); + } + return Local<Value>(); // No real property was found in prototype chain. } @@ -3022,10 +2624,9 @@ Local<Value> v8::Object::GetRealNamedProperty(Handle<String> key) { // Because the object gets a new map, existing inline cache caching // the old map of this object will fail. void v8::Object::TurnOnAccessCheck() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::TurnOnAccessCheck()", return); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::TurnOnAccessCheck()", return); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> obj = Utils::OpenHandle(this); // When turning on access checks for a global object deoptimize all functions @@ -3033,7 +2634,7 @@ void v8::Object::TurnOnAccessCheck() { i::Deoptimizer::DeoptimizeGlobalObject(*obj); i::Handle<i::Map> new_map = - isolate->factory()->CopyMapDropTransitions(i::Handle<i::Map>(obj->map())); + i::Factory::CopyMapDropTransitions(i::Handle<i::Map>(obj->map())); new_map->set_is_access_check_needed(true); obj->set_map(*new_map); } @@ -3045,50 +2646,21 @@ bool v8::Object::IsDirty() { Local<v8::Object> v8::Object::Clone() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::Clone()", return Local<Object>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::Clone()", return Local<Object>()); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::JSObject> result = i::Copy(self); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Object>()); + EXCEPTION_BAILOUT_CHECK(Local<Object>()); return Utils::ToLocal(result); } -static i::Context* GetCreationContext(i::JSObject* object) { - i::Object* constructor = object->map()->constructor(); - i::JSFunction* function; - if (!constructor->IsJSFunction()) { - // API functions have null as a constructor, - // but any JSFunction knows its context immediately. - ASSERT(object->IsJSFunction() && - i::JSFunction::cast(object)->shared()->IsApiFunction()); - function = i::JSFunction::cast(object); - } else { - function = i::JSFunction::cast(constructor); - } - return function->context()->global_context(); -} - - -Local<v8::Context> v8::Object::CreationContext() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, - "v8::Object::CreationContext()", return Local<v8::Context>()); - ENTER_V8(isolate); - i::Handle<i::JSObject> self = Utils::OpenHandle(this); - i::Context* context = GetCreationContext(*self); - return Utils::ToLocal(i::Handle<i::Context>(context)); -} - - int v8::Object::GetIdentityHash() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetIdentityHash()", return 0); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::GetIdentityHash()", return 0); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> hidden_props_obj(i::GetHiddenProperties(self, true)); if (!hidden_props_obj->IsJSObject()) { @@ -3099,7 +2671,7 @@ int v8::Object::GetIdentityHash() { } i::Handle<i::JSObject> hidden_props = i::Handle<i::JSObject>::cast(hidden_props_obj); - i::Handle<i::String> hash_symbol = isolate->factory()->identity_hash_symbol(); + i::Handle<i::String> hash_symbol = i::Factory::identity_hash_symbol(); if (hidden_props->HasLocalProperty(*hash_symbol)) { i::Handle<i::Object> hash = i::GetProperty(hidden_props, hash_symbol); CHECK(!hash.is_null()); @@ -3112,7 +2684,7 @@ int v8::Object::GetIdentityHash() { do { // Generate a random 32-bit hash value but limit range to fit // within a smi. - hash_value = i::V8::Random(self->GetIsolate()) & i::Smi::kMaxValue; + hash_value = i::V8::Random() & i::Smi::kMaxValue; attempts++; } while (hash_value == 0 && attempts < 30); hash_value = hash_value != 0 ? hash_value : 1; // never return 0 @@ -3128,15 +2700,14 @@ int v8::Object::GetIdentityHash() { bool v8::Object::SetHiddenValue(v8::Handle<v8::String> key, v8::Handle<v8::Value> value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::SetHiddenValue()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::Object::SetHiddenValue()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> hidden_props(i::GetHiddenProperties(self, true)); i::Handle<i::Object> key_obj = Utils::OpenHandle(*key); i::Handle<i::Object> value_obj = Utils::OpenHandle(*value); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::SetProperty( hidden_props, key_obj, @@ -3144,26 +2715,24 @@ bool v8::Object::SetHiddenValue(v8::Handle<v8::String> key, static_cast<PropertyAttributes>(None), i::kNonStrictMode); has_pending_exception = obj.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, false); + EXCEPTION_BAILOUT_CHECK(false); return true; } v8::Local<v8::Value> v8::Object::GetHiddenValue(v8::Handle<v8::String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::GetHiddenValue()", - return Local<v8::Value>()); - ENTER_V8(isolate); + ON_BAILOUT("v8::Object::GetHiddenValue()", return Local<v8::Value>()); + ENTER_V8; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> hidden_props(i::GetHiddenProperties(self, false)); if (hidden_props->IsUndefined()) { return v8::Local<v8::Value>(); } i::Handle<i::String> key_obj = Utils::OpenHandle(*key); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> result = i::GetProperty(hidden_props, key_obj); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, v8::Local<v8::Value>()); + EXCEPTION_BAILOUT_CHECK(v8::Local<v8::Value>()); if (result->IsUndefined()) { return v8::Local<v8::Value>(); } @@ -3172,10 +2741,9 @@ v8::Local<v8::Value> v8::Object::GetHiddenValue(v8::Handle<v8::String> key) { bool v8::Object::DeleteHiddenValue(v8::Handle<v8::String> key) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::DeleteHiddenValue()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::DeleteHiddenValue()", return false); + ENTER_V8; + HandleScope scope; i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::Object> hidden_props(i::GetHiddenProperties(self, false)); if (hidden_props->IsUndefined()) { @@ -3187,44 +2755,11 @@ bool v8::Object::DeleteHiddenValue(v8::Handle<v8::String> key) { } -namespace { - -void PrepareExternalArrayElements(i::Handle<i::JSObject> object, - void* data, - ExternalArrayType array_type, - int length) { - i::Isolate* isolate = object->GetIsolate(); - i::Handle<i::ExternalArray> array = - isolate->factory()->NewExternalArray(length, array_type, data); - - // If the object already has external elements, create a new, unique - // map if the element type is now changing, because assumptions about - // generated code based on the receiver's map will be invalid. - i::Handle<i::HeapObject> elements(object->elements()); - bool cant_reuse_map = - elements->map()->IsUndefined() || - !elements->map()->has_external_array_elements() || - elements->map() != isolate->heap()->MapForExternalArrayType(array_type); - if (cant_reuse_map) { - i::Handle<i::Map> external_array_map = - isolate->factory()->GetExternalArrayElementsMap( - i::Handle<i::Map>(object->map()), - array_type, - object->HasFastProperties()); - object->set_map(*external_array_map); - } - object->set_elements(*array); -} - -} // namespace - - void v8::Object::SetIndexedPropertiesToPixelData(uint8_t* data, int length) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::SetElementsToPixelData()", return); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - if (!ApiCheck(length <= i::ExternalPixelArray::kMaxLength, + ON_BAILOUT("v8::SetElementsToPixelData()", return); + ENTER_V8; + HandleScope scope; + if (!ApiCheck(length <= i::PixelArray::kMaxLength, "v8::Object::SetIndexedPropertiesToPixelData()", "length exceeds max acceptable value")) { return; @@ -3235,25 +2770,26 @@ void v8::Object::SetIndexedPropertiesToPixelData(uint8_t* data, int length) { "JSArray is not supported")) { return; } - PrepareExternalArrayElements(self, data, kExternalPixelArray, length); + i::Handle<i::PixelArray> pixels = i::Factory::NewPixelArray(length, data); + i::Handle<i::Map> pixel_array_map = + i::Factory::GetPixelArrayElementsMap(i::Handle<i::Map>(self->map())); + self->set_map(*pixel_array_map); + self->set_elements(*pixels); } bool v8::Object::HasIndexedPropertiesInPixelData() { + ON_BAILOUT("v8::HasIndexedPropertiesInPixelData()", return false); i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), "v8::HasIndexedPropertiesInPixelData()", - return false); - return self->HasExternalPixelElements(); + return self->HasPixelElements(); } uint8_t* v8::Object::GetIndexedPropertiesPixelData() { + ON_BAILOUT("v8::GetIndexedPropertiesPixelData()", return NULL); i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), "v8::GetIndexedPropertiesPixelData()", - return NULL); - if (self->HasExternalPixelElements()) { - return i::ExternalPixelArray::cast(self->elements())-> - external_pixel_pointer(); + if (self->HasPixelElements()) { + return i::PixelArray::cast(self->elements())->external_pointer(); } else { return NULL; } @@ -3261,24 +2797,23 @@ uint8_t* v8::Object::GetIndexedPropertiesPixelData() { int v8::Object::GetIndexedPropertiesPixelDataLength() { + ON_BAILOUT("v8::GetIndexedPropertiesPixelDataLength()", return -1); i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), "v8::GetIndexedPropertiesPixelDataLength()", - return -1); - if (self->HasExternalPixelElements()) { - return i::ExternalPixelArray::cast(self->elements())->length(); + if (self->HasPixelElements()) { + return i::PixelArray::cast(self->elements())->length(); } else { return -1; } } + void v8::Object::SetIndexedPropertiesToExternalArrayData( void* data, ExternalArrayType array_type, int length) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::SetIndexedPropertiesToExternalArrayData()", return); - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ON_BAILOUT("v8::SetIndexedPropertiesToExternalArrayData()", return); + ENTER_V8; + HandleScope scope; if (!ApiCheck(length <= i::ExternalArray::kMaxLength, "v8::Object::SetIndexedPropertiesToExternalArrayData()", "length exceeds max acceptable value")) { @@ -3290,24 +2825,25 @@ void v8::Object::SetIndexedPropertiesToExternalArrayData( "JSArray is not supported")) { return; } - PrepareExternalArrayElements(self, data, array_type, length); + i::Handle<i::ExternalArray> array = + i::Factory::NewExternalArray(length, array_type, data); + i::Handle<i::Map> slow_map = + i::Factory::GetSlowElementsMap(i::Handle<i::Map>(self->map())); + self->set_map(*slow_map); + self->set_elements(*array); } bool v8::Object::HasIndexedPropertiesInExternalArrayData() { + ON_BAILOUT("v8::HasIndexedPropertiesInExternalArrayData()", return false); i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), - "v8::HasIndexedPropertiesInExternalArrayData()", - return false); return self->HasExternalArrayElements(); } void* v8::Object::GetIndexedPropertiesExternalArrayData() { + ON_BAILOUT("v8::GetIndexedPropertiesExternalArrayData()", return NULL); i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), - "v8::GetIndexedPropertiesExternalArrayData()", - return NULL); if (self->HasExternalArrayElements()) { return i::ExternalArray::cast(self->elements())->external_pointer(); } else { @@ -3317,10 +2853,9 @@ void* v8::Object::GetIndexedPropertiesExternalArrayData() { ExternalArrayType v8::Object::GetIndexedPropertiesExternalArrayDataType() { - i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), - "v8::GetIndexedPropertiesExternalArrayDataType()", + ON_BAILOUT("v8::GetIndexedPropertiesExternalArrayDataType()", return static_cast<ExternalArrayType>(-1)); + i::Handle<i::JSObject> self = Utils::OpenHandle(this); switch (self->elements()->map()->instance_type()) { case i::EXTERNAL_BYTE_ARRAY_TYPE: return kExternalByteArray; @@ -3336,10 +2871,6 @@ ExternalArrayType v8::Object::GetIndexedPropertiesExternalArrayDataType() { return kExternalUnsignedIntArray; case i::EXTERNAL_FLOAT_ARRAY_TYPE: return kExternalFloatArray; - case i::EXTERNAL_DOUBLE_ARRAY_TYPE: - return kExternalDoubleArray; - case i::EXTERNAL_PIXEL_ARRAY_TYPE: - return kExternalPixelArray; default: return static_cast<ExternalArrayType>(-1); } @@ -3347,10 +2878,8 @@ ExternalArrayType v8::Object::GetIndexedPropertiesExternalArrayDataType() { int v8::Object::GetIndexedPropertiesExternalArrayDataLength() { + ON_BAILOUT("v8::GetIndexedPropertiesExternalArrayDataLength()", return 0); i::Handle<i::JSObject> self = Utils::OpenHandle(this); - ON_BAILOUT(self->GetIsolate(), - "v8::GetIndexedPropertiesExternalArrayDataLength()", - return 0); if (self->HasExternalArrayElements()) { return i::ExternalArray::cast(self->elements())->length(); } else { @@ -3359,85 +2888,6 @@ int v8::Object::GetIndexedPropertiesExternalArrayDataLength() { } -bool v8::Object::IsCallable() { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::IsCallable()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - i::Handle<i::JSObject> obj = Utils::OpenHandle(this); - if (obj->IsJSFunction()) return true; - return i::Execution::GetFunctionDelegate(obj)->IsJSFunction(); -} - - -Local<v8::Value> Object::CallAsFunction(v8::Handle<v8::Object> recv, int argc, - v8::Handle<v8::Value> argv[]) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::CallAsFunction()", - return Local<v8::Value>()); - LOG_API(isolate, "Object::CallAsFunction"); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - i::Handle<i::JSObject> obj = Utils::OpenHandle(this); - i::Handle<i::Object> recv_obj = Utils::OpenHandle(*recv); - STATIC_ASSERT(sizeof(v8::Handle<v8::Value>) == sizeof(i::Object**)); - i::Object*** args = reinterpret_cast<i::Object***>(argv); - i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>(); - if (obj->IsJSFunction()) { - fun = i::Handle<i::JSFunction>::cast(obj); - } else { - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> delegate = - i::Execution::TryGetFunctionDelegate(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); - fun = i::Handle<i::JSFunction>::cast(delegate); - recv_obj = obj; - } - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> returned = - i::Execution::Call(fun, recv_obj, argc, args, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); - return Utils::ToLocal(scope.CloseAndEscape(returned)); -} - - -Local<v8::Value> Object::CallAsConstructor(int argc, - v8::Handle<v8::Value> argv[]) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Object::CallAsConstructor()", - return Local<v8::Object>()); - LOG_API(isolate, "Object::CallAsConstructor"); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - i::Handle<i::JSObject> obj = Utils::OpenHandle(this); - STATIC_ASSERT(sizeof(v8::Handle<v8::Value>) == sizeof(i::Object**)); - i::Object*** args = reinterpret_cast<i::Object***>(argv); - if (obj->IsJSFunction()) { - i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(obj); - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> returned = - i::Execution::New(fun, argc, args, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>()); - return Utils::ToLocal(scope.CloseAndEscape( - i::Handle<i::JSObject>::cast(returned))); - } - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> delegate = - i::Execution::TryGetConstructorDelegate(obj, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>()); - if (!delegate->IsUndefined()) { - i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(delegate); - EXCEPTION_PREAMBLE(isolate); - i::Handle<i::Object> returned = - i::Execution::Call(fun, obj, argc, args, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>()); - ASSERT(!delegate->IsUndefined()); - return Utils::ToLocal(scope.CloseAndEscape(returned)); - } - return Local<v8::Object>(); -} - - Local<v8::Object> Function::NewInstance() const { return NewInstance(0, NULL); } @@ -3445,40 +2895,37 @@ Local<v8::Object> Function::NewInstance() const { Local<v8::Object> Function::NewInstance(int argc, v8::Handle<v8::Value> argv[]) const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Function::NewInstance()", - return Local<v8::Object>()); - LOG_API(isolate, "Function::NewInstance"); - ENTER_V8(isolate); + ON_BAILOUT("v8::Function::NewInstance()", return Local<v8::Object>()); + LOG_API("Function::NewInstance"); + ENTER_V8; HandleScope scope; i::Handle<i::JSFunction> function = Utils::OpenHandle(this); STATIC_ASSERT(sizeof(v8::Handle<v8::Value>) == sizeof(i::Object**)); i::Object*** args = reinterpret_cast<i::Object***>(argv); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> returned = i::Execution::New(function, argc, args, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::Object>()); return scope.Close(Utils::ToLocal(i::Handle<i::JSObject>::cast(returned))); } Local<v8::Value> Function::Call(v8::Handle<v8::Object> recv, int argc, v8::Handle<v8::Value> argv[]) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Function::Call()", return Local<v8::Value>()); - LOG_API(isolate, "Function::Call"); - ENTER_V8(isolate); + ON_BAILOUT("v8::Function::Call()", return Local<v8::Value>()); + LOG_API("Function::Call"); + ENTER_V8; i::Object* raw_result = NULL; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::JSFunction> fun = Utils::OpenHandle(this); i::Handle<i::Object> recv_obj = Utils::OpenHandle(*recv); STATIC_ASSERT(sizeof(v8::Handle<v8::Value>) == sizeof(i::Object**)); i::Object*** args = reinterpret_cast<i::Object***>(argv); - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); i::Handle<i::Object> returned = i::Execution::Call(fun, recv_obj, argc, args, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Object>()); + EXCEPTION_BAILOUT_CHECK(Local<Object>()); raw_result = *returned; } i::Handle<i::Object> result(raw_result); @@ -3487,9 +2934,7 @@ Local<v8::Value> Function::Call(v8::Handle<v8::Object> recv, int argc, void Function::SetName(v8::Handle<v8::String> name) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ENTER_V8(isolate); - USE(isolate); + ENTER_V8; i::Handle<i::JSFunction> func = Utils::OpenHandle(this); func->shared()->set_name(*Utils::OpenHandle(*name)); } @@ -3528,17 +2973,81 @@ int Function::GetScriptLineNumber() const { } +namespace { + +// Tracks string usage to help make better decisions when +// externalizing strings. +// +// Implementation note: internally this class only tracks fresh +// strings and keeps a single use counter for them. +class StringTracker { + public: + // Records that the given string's characters were copied to some + // external buffer. If this happens often we should honor + // externalization requests for the string. + static void RecordWrite(i::Handle<i::String> string) { + i::Address address = reinterpret_cast<i::Address>(*string); + i::Address top = i::Heap::NewSpaceTop(); + if (IsFreshString(address, top)) { + IncrementUseCount(top); + } + } + + // Estimates freshness and use frequency of the given string based + // on how close it is to the new space top and the recorded usage + // history. + static inline bool IsFreshUnusedString(i::Handle<i::String> string) { + i::Address address = reinterpret_cast<i::Address>(*string); + i::Address top = i::Heap::NewSpaceTop(); + return IsFreshString(address, top) && IsUseCountLow(top); + } + + private: + static inline bool IsFreshString(i::Address string, i::Address top) { + return top - kFreshnessLimit <= string && string <= top; + } + + static inline bool IsUseCountLow(i::Address top) { + if (last_top_ != top) return true; + return use_count_ < kUseLimit; + } + + static inline void IncrementUseCount(i::Address top) { + if (last_top_ != top) { + use_count_ = 0; + last_top_ = top; + } + ++use_count_; + } + + // How close to the new space top a fresh string has to be. + static const int kFreshnessLimit = 1024; + + // The number of uses required to consider a string useful. + static const int kUseLimit = 32; + + // Single use counter shared by all fresh strings. + static int use_count_; + + // Last new space top when the use count above was valid. + static i::Address last_top_; +}; + +int StringTracker::use_count_ = 0; +i::Address StringTracker::last_top_ = NULL; + +} // namespace + + int String::Length() const { - i::Handle<i::String> str = Utils::OpenHandle(this); - if (IsDeadCheck(str->GetIsolate(), "v8::String::Length()")) return 0; - return str->length(); + if (IsDeadCheck("v8::String::Length()")) return 0; + return Utils::OpenHandle(this)->length(); } int String::Utf8Length() const { - i::Handle<i::String> str = Utils::OpenHandle(this); - if (IsDeadCheck(str->GetIsolate(), "v8::String::Utf8Length()")) return 0; - return str->Utf8Length(); + if (IsDeadCheck("v8::String::Utf8Length()")) return 0; + return Utils::OpenHandle(this)->Utf8Length(); } @@ -3546,13 +3055,11 @@ int String::WriteUtf8(char* buffer, int capacity, int* nchars_ref, WriteHints hints) const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::String::WriteUtf8()")) return 0; - LOG_API(isolate, "String::WriteUtf8"); - ENTER_V8(isolate); - i::StringInputBuffer& write_input_buffer = *isolate->write_input_buffer(); + if (IsDeadCheck("v8::String::WriteUtf8()")) return 0; + LOG_API("String::WriteUtf8"); + ENTER_V8; i::Handle<i::String> str = Utils::OpenHandle(this); - isolate->string_tracker()->RecordWrite(str); + StringTracker::RecordWrite(str); if (hints & HINT_MANY_WRITES_EXPECTED) { // Flatten the string for efficiency. This applies whether we are // using StringInputBuffer or Get(i) to access the characters. @@ -3603,14 +3110,12 @@ int String::WriteAscii(char* buffer, int start, int length, WriteHints hints) const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::String::WriteAscii()")) return 0; - LOG_API(isolate, "String::WriteAscii"); - ENTER_V8(isolate); - i::StringInputBuffer& write_input_buffer = *isolate->write_input_buffer(); + if (IsDeadCheck("v8::String::WriteAscii()")) return 0; + LOG_API("String::WriteAscii"); + ENTER_V8; ASSERT(start >= 0 && length >= -1); i::Handle<i::String> str = Utils::OpenHandle(this); - isolate->string_tracker()->RecordWrite(str); + StringTracker::RecordWrite(str); if (hints & HINT_MANY_WRITES_EXPECTED) { // Flatten the string for efficiency. This applies whether we are // using StringInputBuffer or Get(i) to access the characters. @@ -3637,13 +3142,12 @@ int String::Write(uint16_t* buffer, int start, int length, WriteHints hints) const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::String::Write()")) return 0; - LOG_API(isolate, "String::Write"); - ENTER_V8(isolate); + if (IsDeadCheck("v8::String::Write()")) return 0; + LOG_API("String::Write"); + ENTER_V8; ASSERT(start >= 0 && length >= -1); i::Handle<i::String> str = Utils::OpenHandle(this); - isolate->string_tracker()->RecordWrite(str); + StringTracker::RecordWrite(str); if (hints & HINT_MANY_WRITES_EXPECTED) { // Flatten the string for efficiency. This applies whether we are // using StringInputBuffer or Get(i) to access the characters. @@ -3662,20 +3166,15 @@ int String::Write(uint16_t* buffer, bool v8::String::IsExternal() const { + EnsureInitialized("v8::String::IsExternal()"); i::Handle<i::String> str = Utils::OpenHandle(this); - if (IsDeadCheck(str->GetIsolate(), "v8::String::IsExternal()")) { - return false; - } - EnsureInitializedForIsolate(str->GetIsolate(), "v8::String::IsExternal()"); return i::StringShape(*str).IsExternalTwoByte(); } bool v8::String::IsExternalAscii() const { + EnsureInitialized("v8::String::IsExternalAscii()"); i::Handle<i::String> str = Utils::OpenHandle(this); - if (IsDeadCheck(str->GetIsolate(), "v8::String::IsExternalAscii()")) { - return false; - } return i::StringShape(*str).IsExternalAscii(); } @@ -3696,11 +3195,8 @@ void v8::String::VerifyExternalStringResource( v8::String::ExternalAsciiStringResource* v8::String::GetExternalAsciiStringResource() const { + EnsureInitialized("v8::String::GetExternalAsciiStringResource()"); i::Handle<i::String> str = Utils::OpenHandle(this); - if (IsDeadCheck(str->GetIsolate(), - "v8::String::GetExternalAsciiStringResource()")) { - return NULL; - } if (i::StringShape(*str).IsExternalAscii()) { void* resource = i::Handle<i::ExternalAsciiString>::cast(str)->resource(); return reinterpret_cast<ExternalAsciiStringResource*>(resource); @@ -3711,21 +3207,21 @@ v8::String::ExternalAsciiStringResource* double Number::Value() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Number::Value()")) return 0; + if (IsDeadCheck("v8::Number::Value()")) return 0; i::Handle<i::Object> obj = Utils::OpenHandle(this); return obj->Number(); } bool Boolean::Value() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Boolean::Value()")) return false; + if (IsDeadCheck("v8::Boolean::Value()")) return false; i::Handle<i::Object> obj = Utils::OpenHandle(this); return obj->IsTrue(); } int64_t Integer::Value() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Integer::Value()")) return 0; + if (IsDeadCheck("v8::Integer::Value()")) return 0; i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) { return i::Smi::cast(*obj)->value(); @@ -3736,7 +3232,7 @@ int64_t Integer::Value() const { int32_t Int32::Value() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Int32::Value()")) return 0; + if (IsDeadCheck("v8::Int32::Value()")) return 0; i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) { return i::Smi::cast(*obj)->value(); @@ -3747,7 +3243,7 @@ int32_t Int32::Value() const { uint32_t Uint32::Value() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::Uint32::Value()")) return 0; + if (IsDeadCheck("v8::Uint32::Value()")) return 0; i::Handle<i::Object> obj = Utils::OpenHandle(this); if (obj->IsSmi()) { return i::Smi::cast(*obj)->value(); @@ -3758,19 +3254,15 @@ uint32_t Uint32::Value() const { int v8::Object::InternalFieldCount() { + if (IsDeadCheck("v8::Object::InternalFieldCount()")) return 0; i::Handle<i::JSObject> obj = Utils::OpenHandle(this); - if (IsDeadCheck(obj->GetIsolate(), "v8::Object::InternalFieldCount()")) { - return 0; - } return obj->GetInternalFieldCount(); } Local<Value> v8::Object::CheckedGetInternalField(int index) { + if (IsDeadCheck("v8::Object::GetInternalField()")) return Local<Value>(); i::Handle<i::JSObject> obj = Utils::OpenHandle(this); - if (IsDeadCheck(obj->GetIsolate(), "v8::Object::GetInternalField()")) { - return Local<Value>(); - } if (!ApiCheck(index < obj->GetInternalFieldCount(), "v8::Object::GetInternalField()", "Reading internal field out of bounds")) { @@ -3787,17 +3279,14 @@ Local<Value> v8::Object::CheckedGetInternalField(int index) { void v8::Object::SetInternalField(int index, v8::Handle<Value> value) { + if (IsDeadCheck("v8::Object::SetInternalField()")) return; i::Handle<i::JSObject> obj = Utils::OpenHandle(this); - i::Isolate* isolate = obj->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Object::SetInternalField()")) { - return; - } if (!ApiCheck(index < obj->GetInternalFieldCount(), "v8::Object::SetInternalField()", "Writing internal field out of bounds")) { return; } - ENTER_V8(isolate); + ENTER_V8; i::Handle<i::Object> val = Utils::OpenHandle(*value); obj->SetInternalField(index, *val); } @@ -3821,17 +3310,15 @@ static i::Smi* EncodeAsSmi(void* ptr) { void v8::Object::SetPointerInInternalField(int index, void* value) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ENTER_V8(isolate); + ENTER_V8; if (CanBeEncodedAsSmi(value)) { Utils::OpenHandle(this)->SetInternalField(index, EncodeAsSmi(value)); } else { HandleScope scope; - i::Handle<i::Foreign> foreign = - isolate->factory()->NewForeign( - reinterpret_cast<i::Address>(value), i::TENURED); - if (!foreign.is_null()) - Utils::OpenHandle(this)->SetInternalField(index, *foreign); + i::Handle<i::Proxy> proxy = + i::Factory::NewProxy(reinterpret_cast<i::Address>(value), i::TENURED); + if (!proxy.is_null()) + Utils::OpenHandle(this)->SetInternalField(index, *proxy); } ASSERT_EQ(value, GetPointerFromInternalField(index)); } @@ -3839,23 +3326,15 @@ void v8::Object::SetPointerInInternalField(int index, void* value) { // --- E n v i r o n m e n t --- - bool v8::V8::Initialize() { - i::Isolate* isolate = i::Isolate::UncheckedCurrent(); - if (isolate != NULL && isolate->IsInitialized()) { - return true; - } - return InitializeHelper(); + if (i::V8::IsRunning()) return true; + HandleScope scope; + if (i::Snapshot::Initialize()) return true; + return i::V8::Initialize(NULL); } bool v8::V8::Dispose() { - i::Isolate* isolate = i::Isolate::Current(); - if (!ApiCheck(isolate != NULL && isolate->IsDefaultIsolate(), - "v8::V8::Dispose()", - "Use v8::Isolate::Dispose() for a non-default isolate.")) { - return false; - } i::V8::TearDown(); return true; } @@ -3868,39 +3347,38 @@ HeapStatistics::HeapStatistics(): total_heap_size_(0), void v8::V8::GetHeapStatistics(HeapStatistics* heap_statistics) { - i::Heap* heap = i::Isolate::Current()->heap(); - heap_statistics->set_total_heap_size(heap->CommittedMemory()); + heap_statistics->set_total_heap_size(i::Heap::CommittedMemory()); heap_statistics->set_total_heap_size_executable( - heap->CommittedMemoryExecutable()); - heap_statistics->set_used_heap_size(heap->SizeOfObjects()); - heap_statistics->set_heap_size_limit(heap->MaxReserved()); + i::Heap::CommittedMemoryExecutable()); + heap_statistics->set_used_heap_size(i::Heap::SizeOfObjects()); + heap_statistics->set_heap_size_limit(i::Heap::MaxReserved()); } bool v8::V8::IdleNotification() { // Returning true tells the caller that it need not // continue to call IdleNotification. - if (!i::Isolate::Current()->IsInitialized()) return true; + if (!i::V8::IsRunning()) return true; return i::V8::IdleNotification(); } void v8::V8::LowMemoryNotification() { - i::Isolate* isolate = i::Isolate::Current(); - if (!isolate->IsInitialized()) return; - isolate->heap()->CollectAllGarbage(true); + if (!i::V8::IsRunning()) return; + i::Heap::CollectAllGarbage(true); } int v8::V8::ContextDisposedNotification() { - i::Isolate* isolate = i::Isolate::Current(); - if (!isolate->IsInitialized()) return 0; - return isolate->heap()->NotifyContextDisposed(); + if (!i::V8::IsRunning()) return 0; + return i::Heap::NotifyContextDisposed(); } const char* v8::V8::GetVersion() { - return i::Version::GetVersion(); + static v8::internal::EmbeddedVector<char, 128> buffer; + v8::internal::Version::GetString(buffer); + return buffer.start(); } @@ -3920,15 +3398,14 @@ Persistent<Context> v8::Context::New( v8::ExtensionConfiguration* extensions, v8::Handle<ObjectTemplate> global_template, v8::Handle<Value> global_object) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Context::New()"); - LOG_API(isolate, "Context::New"); - ON_BAILOUT(isolate, "v8::Context::New()", return Persistent<Context>()); + EnsureInitialized("v8::Context::New()"); + LOG_API("Context::New"); + ON_BAILOUT("v8::Context::New()", return Persistent<Context>()); // Enter V8 via an ENTER_V8 scope. i::Handle<i::Context> env; { - ENTER_V8(isolate); + ENTER_V8; v8::Handle<ObjectTemplate> proxy_template = global_template; i::Handle<i::FunctionTemplateInfo> proxy_constructor; i::Handle<i::FunctionTemplateInfo> global_constructor; @@ -3957,14 +3434,12 @@ Persistent<Context> v8::Context::New( proxy_constructor->set_needs_access_check( global_constructor->needs_access_check()); global_constructor->set_needs_access_check(false); - global_constructor->set_access_check_info( - isolate->heap()->undefined_value()); + global_constructor->set_access_check_info(i::Heap::undefined_value()); } } // Create the environment. - env = isolate->bootstrapper()->CreateEnvironment( - isolate, + env = i::Bootstrapper::CreateEnvironment( Utils::OpenHandle(*global_object), proxy_template, extensions); @@ -3978,7 +3453,7 @@ Persistent<Context> v8::Context::New( global_constructor->set_needs_access_check( proxy_constructor->needs_access_check()); } - isolate->runtime_profiler()->Reset(); + i::RuntimeProfiler::Reset(); } // Leave V8. @@ -3989,11 +3464,8 @@ Persistent<Context> v8::Context::New( void v8::Context::SetSecurityToken(Handle<Value> token) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::SetSecurityToken()")) { - return; - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::Context::SetSecurityToken()")) return; + ENTER_V8; i::Handle<i::Context> env = Utils::OpenHandle(this); i::Handle<i::Object> token_handle = Utils::OpenHandle(*token); env->set_security_token(*token_handle); @@ -4001,22 +3473,15 @@ void v8::Context::SetSecurityToken(Handle<Value> token) { void v8::Context::UseDefaultSecurityToken() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, - "v8::Context::UseDefaultSecurityToken()")) { - return; - } - ENTER_V8(isolate); + if (IsDeadCheck("v8::Context::UseDefaultSecurityToken()")) return; + ENTER_V8; i::Handle<i::Context> env = Utils::OpenHandle(this); env->set_security_token(env->global()); } Handle<Value> v8::Context::GetSecurityToken() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::GetSecurityToken()")) { - return Handle<Value>(); - } + if (IsDeadCheck("v8::Context::GetSecurityToken()")) return Handle<Value>(); i::Handle<i::Context> env = Utils::OpenHandle(this); i::Object* security_token = env->security_token(); i::Handle<i::Object> token_handle(security_token); @@ -4031,17 +3496,13 @@ bool Context::HasOutOfMemoryException() { bool Context::InContext() { - return i::Isolate::Current()->context() != NULL; + return i::Top::context() != NULL; } v8::Local<v8::Context> Context::GetEntered() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::GetEntered()")) { - return Local<Context>(); - } - i::Handle<i::Object> last = - isolate->handle_scope_implementer()->LastEnteredContext(); + if (IsDeadCheck("v8::Context::GetEntered()")) return Local<Context>(); + i::Handle<i::Object> last = thread_local.LastEnteredContext(); if (last.is_null()) return Local<Context>(); i::Handle<i::Context> context = i::Handle<i::Context>::cast(last); return Utils::ToLocal(context); @@ -4049,11 +3510,8 @@ v8::Local<v8::Context> Context::GetEntered() { v8::Local<v8::Context> Context::GetCurrent() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::GetCurrent()")) { - return Local<Context>(); - } - i::Handle<i::Object> current = isolate->global_context(); + if (IsDeadCheck("v8::Context::GetCurrent()")) return Local<Context>(); + i::Handle<i::Object> current = i::Top::global_context(); if (current.is_null()) return Local<Context>(); i::Handle<i::Context> context = i::Handle<i::Context>::cast(current); return Utils::ToLocal(context); @@ -4061,12 +3519,8 @@ v8::Local<v8::Context> Context::GetCurrent() { v8::Local<v8::Context> Context::GetCalling() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::GetCalling()")) { - return Local<Context>(); - } - i::Handle<i::Object> calling = - isolate->GetCallingGlobalContext(); + if (IsDeadCheck("v8::Context::GetCalling()")) return Local<Context>(); + i::Handle<i::Object> calling = i::Top::GetCallingGlobalContext(); if (calling.is_null()) return Local<Context>(); i::Handle<i::Context> context = i::Handle<i::Context>::cast(calling); return Utils::ToLocal(context); @@ -4074,9 +3528,7 @@ v8::Local<v8::Context> Context::GetCalling() { v8::Local<v8::Object> Context::Global() { - if (IsDeadCheck(i::Isolate::Current(), "v8::Context::Global()")) { - return Local<v8::Object>(); - } + if (IsDeadCheck("v8::Context::Global()")) return Local<v8::Object>(); i::Object** ctx = reinterpret_cast<i::Object**>(this); i::Handle<i::Context> context = i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx)); @@ -4086,101 +3538,73 @@ v8::Local<v8::Object> Context::Global() { void Context::DetachGlobal() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::DetachGlobal()")) return; - ENTER_V8(isolate); + if (IsDeadCheck("v8::Context::DetachGlobal()")) return; + ENTER_V8; i::Object** ctx = reinterpret_cast<i::Object**>(this); i::Handle<i::Context> context = i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx)); - isolate->bootstrapper()->DetachGlobal(context); + i::Bootstrapper::DetachGlobal(context); } void Context::ReattachGlobal(Handle<Object> global_object) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::ReattachGlobal()")) return; - ENTER_V8(isolate); + if (IsDeadCheck("v8::Context::ReattachGlobal()")) return; + ENTER_V8; i::Object** ctx = reinterpret_cast<i::Object**>(this); i::Handle<i::Context> context = i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx)); - isolate->bootstrapper()->ReattachGlobal( - context, - Utils::OpenHandle(*global_object)); -} - - -void Context::AllowCodeGenerationFromStrings(bool allow) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Context::AllowCodeGenerationFromStrings()")) { - return; - } - ENTER_V8(isolate); - i::Object** ctx = reinterpret_cast<i::Object**>(this); - i::Handle<i::Context> context = - i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx)); - context->set_allow_code_gen_from_strings( - allow ? isolate->heap()->true_value() : isolate->heap()->false_value()); -} - - -void V8::SetWrapperClassId(i::Object** global_handle, uint16_t class_id) { - i::GlobalHandles::SetWrapperClassId(global_handle, class_id); + i::Bootstrapper::ReattachGlobal(context, Utils::OpenHandle(*global_object)); } Local<v8::Object> ObjectTemplate::NewInstance() { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::ObjectTemplate::NewInstance()", - return Local<v8::Object>()); - LOG_API(isolate, "ObjectTemplate::NewInstance"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ON_BAILOUT("v8::ObjectTemplate::NewInstance()", return Local<v8::Object>()); + LOG_API("ObjectTemplate::NewInstance"); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::Execution::InstantiateObject(Utils::OpenHandle(this), &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::Object>()); return Utils::ToLocal(i::Handle<i::JSObject>::cast(obj)); } Local<v8::Function> FunctionTemplate::GetFunction() { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::FunctionTemplate::GetFunction()", + ON_BAILOUT("v8::FunctionTemplate::GetFunction()", return Local<v8::Function>()); - LOG_API(isolate, "FunctionTemplate::GetFunction"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + LOG_API("FunctionTemplate::GetFunction"); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::Execution::InstantiateFunction(Utils::OpenHandle(this), &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Function>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::Function>()); return Utils::ToLocal(i::Handle<i::JSFunction>::cast(obj)); } bool FunctionTemplate::HasInstance(v8::Handle<v8::Value> value) { - ON_BAILOUT(i::Isolate::Current(), "v8::FunctionTemplate::HasInstanceOf()", - return false); + ON_BAILOUT("v8::FunctionTemplate::HasInstanceOf()", return false); i::Object* obj = *Utils::OpenHandle(*value); return obj->IsInstanceOf(*Utils::OpenHandle(this)); } static Local<External> ExternalNewImpl(void* data) { - return Utils::ToLocal(FACTORY->NewForeign(static_cast<i::Address>(data))); + return Utils::ToLocal(i::Factory::NewProxy(static_cast<i::Address>(data))); } static void* ExternalValueImpl(i::Handle<i::Object> obj) { - return reinterpret_cast<void*>(i::Foreign::cast(*obj)->address()); + return reinterpret_cast<void*>(i::Proxy::cast(*obj)->proxy()); } Local<Value> v8::External::Wrap(void* data) { - i::Isolate* isolate = i::Isolate::Current(); STATIC_ASSERT(sizeof(data) == sizeof(i::Address)); - LOG_API(isolate, "External::Wrap"); - EnsureInitializedForIsolate(isolate, "v8::External::Wrap()"); - ENTER_V8(isolate); + LOG_API("External::Wrap"); + EnsureInitialized("v8::External::Wrap()"); + ENTER_V8; v8::Local<v8::Value> result = CanBeEncodedAsSmi(data) ? Utils::ToLocal(i::Handle<i::Object>(EncodeAsSmi(data))) @@ -4196,8 +3620,8 @@ void* v8::Object::SlowGetPointerFromInternalField(int index) { i::Object* value = obj->GetInternalField(index); if (value->IsSmi()) { return i::Internals::GetExternalPointerFromSmi(value); - } else if (value->IsForeign()) { - return reinterpret_cast<void*>(i::Foreign::cast(value)->address()); + } else if (value->IsProxy()) { + return reinterpret_cast<void*>(i::Proxy::cast(value)->proxy()); } else { return NULL; } @@ -4205,12 +3629,12 @@ void* v8::Object::SlowGetPointerFromInternalField(int index) { void* v8::External::FullUnwrap(v8::Handle<v8::Value> wrapper) { - if (IsDeadCheck(i::Isolate::Current(), "v8::External::Unwrap()")) return 0; + if (IsDeadCheck("v8::External::Unwrap()")) return 0; i::Handle<i::Object> obj = Utils::OpenHandle(*wrapper); void* result; if (obj->IsSmi()) { result = i::Internals::GetExternalPointerFromSmi(*obj); - } else if (obj->IsForeign()) { + } else if (obj->IsProxy()) { result = ExternalValueImpl(obj); } else { result = NULL; @@ -4222,65 +3646,58 @@ void* v8::External::FullUnwrap(v8::Handle<v8::Value> wrapper) { Local<External> v8::External::New(void* data) { STATIC_ASSERT(sizeof(data) == sizeof(i::Address)); - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "External::New"); - EnsureInitializedForIsolate(isolate, "v8::External::New()"); - ENTER_V8(isolate); + LOG_API("External::New"); + EnsureInitialized("v8::External::New()"); + ENTER_V8; return ExternalNewImpl(data); } void* External::Value() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::External::Value()")) return 0; + if (IsDeadCheck("v8::External::Value()")) return 0; i::Handle<i::Object> obj = Utils::OpenHandle(this); return ExternalValueImpl(obj); } Local<String> v8::String::Empty() { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::Empty()"); - LOG_API(isolate, "String::Empty()"); - return Utils::ToLocal(isolate->factory()->empty_symbol()); + EnsureInitialized("v8::String::Empty()"); + LOG_API("String::Empty()"); + return Utils::ToLocal(i::Factory::empty_symbol()); } Local<String> v8::String::New(const char* data, int length) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::New()"); - LOG_API(isolate, "String::New(char)"); + EnsureInitialized("v8::String::New()"); + LOG_API("String::New(char)"); if (length == 0) return Empty(); - ENTER_V8(isolate); + ENTER_V8; if (length == -1) length = i::StrLength(data); i::Handle<i::String> result = - isolate->factory()->NewStringFromUtf8( - i::Vector<const char>(data, length)); + i::Factory::NewStringFromUtf8(i::Vector<const char>(data, length)); return Utils::ToLocal(result); } Local<String> v8::String::Concat(Handle<String> left, Handle<String> right) { + EnsureInitialized("v8::String::New()"); + LOG_API("String::New(char)"); + ENTER_V8; i::Handle<i::String> left_string = Utils::OpenHandle(*left); - i::Isolate* isolate = left_string->GetIsolate(); - EnsureInitializedForIsolate(isolate, "v8::String::New()"); - LOG_API(isolate, "String::New(char)"); - ENTER_V8(isolate); i::Handle<i::String> right_string = Utils::OpenHandle(*right); - i::Handle<i::String> result = isolate->factory()->NewConsString(left_string, - right_string); + i::Handle<i::String> result = i::Factory::NewConsString(left_string, + right_string); return Utils::ToLocal(result); } Local<String> v8::String::NewUndetectable(const char* data, int length) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::NewUndetectable()"); - LOG_API(isolate, "String::NewUndetectable(char)"); - ENTER_V8(isolate); + EnsureInitialized("v8::String::NewUndetectable()"); + LOG_API("String::NewUndetectable(char)"); + ENTER_V8; if (length == -1) length = i::StrLength(data); i::Handle<i::String> result = - isolate->factory()->NewStringFromUtf8( - i::Vector<const char>(data, length)); + i::Factory::NewStringFromUtf8(i::Vector<const char>(data, length)); result->MarkAsUndetectable(); return Utils::ToLocal(result); } @@ -4294,78 +3711,65 @@ static int TwoByteStringLength(const uint16_t* data) { Local<String> v8::String::New(const uint16_t* data, int length) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::New()"); - LOG_API(isolate, "String::New(uint16_)"); + EnsureInitialized("v8::String::New()"); + LOG_API("String::New(uint16_)"); if (length == 0) return Empty(); - ENTER_V8(isolate); + ENTER_V8; if (length == -1) length = TwoByteStringLength(data); i::Handle<i::String> result = - isolate->factory()->NewStringFromTwoByte( - i::Vector<const uint16_t>(data, length)); + i::Factory::NewStringFromTwoByte(i::Vector<const uint16_t>(data, length)); return Utils::ToLocal(result); } Local<String> v8::String::NewUndetectable(const uint16_t* data, int length) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::NewUndetectable()"); - LOG_API(isolate, "String::NewUndetectable(uint16_)"); - ENTER_V8(isolate); + EnsureInitialized("v8::String::NewUndetectable()"); + LOG_API("String::NewUndetectable(uint16_)"); + ENTER_V8; if (length == -1) length = TwoByteStringLength(data); i::Handle<i::String> result = - isolate->factory()->NewStringFromTwoByte( - i::Vector<const uint16_t>(data, length)); + i::Factory::NewStringFromTwoByte(i::Vector<const uint16_t>(data, length)); result->MarkAsUndetectable(); return Utils::ToLocal(result); } -i::Handle<i::String> NewExternalStringHandle(i::Isolate* isolate, +i::Handle<i::String> NewExternalStringHandle( v8::String::ExternalStringResource* resource) { i::Handle<i::String> result = - isolate->factory()->NewExternalStringFromTwoByte(resource); + i::Factory::NewExternalStringFromTwoByte(resource); return result; } -i::Handle<i::String> NewExternalAsciiStringHandle(i::Isolate* isolate, +i::Handle<i::String> NewExternalAsciiStringHandle( v8::String::ExternalAsciiStringResource* resource) { i::Handle<i::String> result = - isolate->factory()->NewExternalStringFromAscii(resource); + i::Factory::NewExternalStringFromAscii(resource); return result; } Local<String> v8::String::NewExternal( v8::String::ExternalStringResource* resource) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::NewExternal()"); - LOG_API(isolate, "String::NewExternal"); - ENTER_V8(isolate); - i::Handle<i::String> result = NewExternalStringHandle(isolate, resource); - isolate->heap()->external_string_table()->AddString(*result); + EnsureInitialized("v8::String::NewExternal()"); + LOG_API("String::NewExternal"); + ENTER_V8; + i::Handle<i::String> result = NewExternalStringHandle(resource); + i::ExternalStringTable::AddString(*result); return Utils::ToLocal(result); } bool v8::String::MakeExternal(v8::String::ExternalStringResource* resource) { + if (IsDeadCheck("v8::String::MakeExternal()")) return false; + if (this->IsExternal()) return false; // Already an external string. + ENTER_V8; i::Handle<i::String> obj = Utils::OpenHandle(this); - i::Isolate* isolate = obj->GetIsolate(); - if (IsDeadCheck(isolate, "v8::String::MakeExternal()")) return false; - if (i::StringShape(*obj).IsExternalTwoByte()) { - return false; // Already an external string. - } - ENTER_V8(isolate); - if (isolate->string_tracker()->IsFreshUnusedString(obj)) { - return false; - } - if (isolate->heap()->IsInGCPostProcessing()) { - return false; - } + if (StringTracker::IsFreshUnusedString(obj)) return false; bool result = obj->MakeExternal(resource); if (result && !obj->IsSymbol()) { - isolate->heap()->external_string_table()->AddString(*obj); + i::ExternalStringTable::AddString(*obj); } return result; } @@ -4373,46 +3777,34 @@ bool v8::String::MakeExternal(v8::String::ExternalStringResource* resource) { Local<String> v8::String::NewExternal( v8::String::ExternalAsciiStringResource* resource) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::NewExternal()"); - LOG_API(isolate, "String::NewExternal"); - ENTER_V8(isolate); - i::Handle<i::String> result = NewExternalAsciiStringHandle(isolate, resource); - isolate->heap()->external_string_table()->AddString(*result); + EnsureInitialized("v8::String::NewExternal()"); + LOG_API("String::NewExternal"); + ENTER_V8; + i::Handle<i::String> result = NewExternalAsciiStringHandle(resource); + i::ExternalStringTable::AddString(*result); return Utils::ToLocal(result); } bool v8::String::MakeExternal( v8::String::ExternalAsciiStringResource* resource) { + if (IsDeadCheck("v8::String::MakeExternal()")) return false; + if (this->IsExternal()) return false; // Already an external string. + ENTER_V8; i::Handle<i::String> obj = Utils::OpenHandle(this); - i::Isolate* isolate = obj->GetIsolate(); - if (IsDeadCheck(isolate, "v8::String::MakeExternal()")) return false; - if (i::StringShape(*obj).IsExternalTwoByte()) { - return false; // Already an external string. - } - ENTER_V8(isolate); - if (isolate->string_tracker()->IsFreshUnusedString(obj)) { - return false; - } - if (isolate->heap()->IsInGCPostProcessing()) { - return false; - } + if (StringTracker::IsFreshUnusedString(obj)) return false; bool result = obj->MakeExternal(resource); if (result && !obj->IsSymbol()) { - isolate->heap()->external_string_table()->AddString(*obj); + i::ExternalStringTable::AddString(*obj); } return result; } bool v8::String::CanMakeExternal() { + if (IsDeadCheck("v8::String::CanMakeExternal()")) return false; i::Handle<i::String> obj = Utils::OpenHandle(this); - i::Isolate* isolate = obj->GetIsolate(); - if (IsDeadCheck(isolate, "v8::String::CanMakeExternal()")) return false; - if (isolate->string_tracker()->IsFreshUnusedString(obj)) { - return false; - } + if (StringTracker::IsFreshUnusedString(obj)) return false; int size = obj->Size(); // Byte size of the original string. if (size < i::ExternalString::kSize) return false; @@ -4422,37 +3814,34 @@ bool v8::String::CanMakeExternal() { Local<v8::Object> v8::Object::New() { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Object::New()"); - LOG_API(isolate, "Object::New"); - ENTER_V8(isolate); + EnsureInitialized("v8::Object::New()"); + LOG_API("Object::New"); + ENTER_V8; i::Handle<i::JSObject> obj = - isolate->factory()->NewJSObject(isolate->object_function()); + i::Factory::NewJSObject(i::Top::object_function()); return Utils::ToLocal(obj); } Local<v8::Value> v8::Date::New(double time) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Date::New()"); - LOG_API(isolate, "Date::New"); + EnsureInitialized("v8::Date::New()"); + LOG_API("Date::New"); if (isnan(time)) { // Introduce only canonical NaN value into the VM, to avoid signaling NaNs. time = i::OS::nan_value(); } - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::Object> obj = i::Execution::NewDate(time, &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Value>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::Value>()); return Utils::ToLocal(obj); } double v8::Date::NumberValue() const { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::Date::NumberValue()")) return 0; - LOG_API(isolate, "Date::NumberValue"); + if (IsDeadCheck("v8::Date::NumberValue()")) return 0; + LOG_API("Date::NumberValue"); i::Handle<i::Object> obj = Utils::OpenHandle(this); i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj); return jsvalue->value()->Number(); @@ -4460,18 +3849,16 @@ double v8::Date::NumberValue() const { void v8::Date::DateTimeConfigurationChangeNotification() { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Date::DateTimeConfigurationChangeNotification()", - return); - LOG_API(isolate, "Date::DateTimeConfigurationChangeNotification"); - ENTER_V8(isolate); + ON_BAILOUT("v8::Date::DateTimeConfigurationChangeNotification()", return); + LOG_API("Date::DateTimeConfigurationChangeNotification"); + ENTER_V8; + + HandleScope scope; - i::HandleScope scope(isolate); // Get the function ResetDateCache (defined in date-delay.js). i::Handle<i::String> func_name_str = - isolate->factory()->LookupAsciiSymbol("ResetDateCache"); - i::MaybeObject* result = - isolate->js_builtins_object()->GetProperty(*func_name_str); + i::Factory::LookupAsciiSymbol("ResetDateCache"); + i::MaybeObject* result = i::Top::builtins()->GetProperty(*func_name_str); i::Object* object_func; if (!result->ToObject(&object_func)) { return; @@ -4483,11 +3870,9 @@ void v8::Date::DateTimeConfigurationChangeNotification() { // Call ResetDateCache(0 but expect no exceptions: bool caught_exception = false; - i::Execution::TryCall(func, - isolate->js_builtins_object(), - 0, - NULL, - &caught_exception); + i::Handle<i::Object> result = + i::Execution::TryCall(func, i::Top::builtins(), 0, NULL, + &caught_exception); } } @@ -4499,32 +3884,28 @@ static i::Handle<i::String> RegExpFlagsToString(RegExp::Flags flags) { if ((flags & RegExp::kMultiline) != 0) flags_buf[num_flags++] = 'm'; if ((flags & RegExp::kIgnoreCase) != 0) flags_buf[num_flags++] = 'i'; ASSERT(num_flags <= static_cast<int>(ARRAY_SIZE(flags_buf))); - return FACTORY->LookupSymbol( + return i::Factory::LookupSymbol( i::Vector<const char>(flags_buf, num_flags)); } Local<v8::RegExp> v8::RegExp::New(Handle<String> pattern, Flags flags) { - i::Isolate* isolate = Utils::OpenHandle(*pattern)->GetIsolate(); - EnsureInitializedForIsolate(isolate, "v8::RegExp::New()"); - LOG_API(isolate, "RegExp::New"); - ENTER_V8(isolate); - EXCEPTION_PREAMBLE(isolate); + EnsureInitialized("v8::RegExp::New()"); + LOG_API("RegExp::New"); + ENTER_V8; + EXCEPTION_PREAMBLE(); i::Handle<i::JSRegExp> obj = i::Execution::NewJSRegExp( Utils::OpenHandle(*pattern), RegExpFlagsToString(flags), &has_pending_exception); - EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::RegExp>()); + EXCEPTION_BAILOUT_CHECK(Local<v8::RegExp>()); return Utils::ToLocal(i::Handle<i::JSRegExp>::cast(obj)); } Local<v8::String> v8::RegExp::GetSource() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::RegExp::GetSource()")) { - return Local<v8::String>(); - } + if (IsDeadCheck("v8::RegExp::GetSource()")) return Local<v8::String>(); i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this); return Utils::ToLocal(i::Handle<i::String>(obj->Pattern())); } @@ -4541,31 +3922,23 @@ REGEXP_FLAG_ASSERT_EQ(kMultiline, MULTILINE); #undef REGEXP_FLAG_ASSERT_EQ v8::RegExp::Flags v8::RegExp::GetFlags() const { - if (IsDeadCheck(i::Isolate::Current(), "v8::RegExp::GetFlags()")) { - return v8::RegExp::kNone; - } + if (IsDeadCheck("v8::RegExp::GetFlags()")) return v8::RegExp::kNone; i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this); return static_cast<RegExp::Flags>(obj->GetFlags().value()); } Local<v8::Array> v8::Array::New(int length) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Array::New()"); - LOG_API(isolate, "Array::New"); - ENTER_V8(isolate); - int real_length = length > 0 ? length : 0; - i::Handle<i::JSArray> obj = isolate->factory()->NewJSArray(real_length); - i::Handle<i::Object> length_obj = - isolate->factory()->NewNumberFromInt(real_length); - obj->set_length(*length_obj); + EnsureInitialized("v8::Array::New()"); + LOG_API("Array::New"); + ENTER_V8; + i::Handle<i::JSArray> obj = i::Factory::NewJSArray(length); return Utils::ToLocal(obj); } uint32_t v8::Array::Length() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::Array::Length()")) return 0; + if (IsDeadCheck("v8::Array::Length()")) return 0; i::Handle<i::JSArray> obj = Utils::OpenHandle(this); i::Object* length = obj->length(); if (length->IsSmi()) { @@ -4577,8 +3950,7 @@ uint32_t v8::Array::Length() const { Local<Object> Array::CloneElementAt(uint32_t index) { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - ON_BAILOUT(isolate, "v8::Array::CloneElementAt()", return Local<Object>()); + ON_BAILOUT("v8::Array::CloneElementAt()", return Local<Object>()); i::Handle<i::JSObject> self = Utils::OpenHandle(this); if (!self->HasFastElements()) { return Local<Object>(); @@ -4589,49 +3961,45 @@ Local<Object> Array::CloneElementAt(uint32_t index) { return Local<Object>(); } i::Handle<i::JSObject> paragon_handle(i::JSObject::cast(paragon)); - EXCEPTION_PREAMBLE(isolate); - ENTER_V8(isolate); + EXCEPTION_PREAMBLE(); + ENTER_V8; i::Handle<i::JSObject> result = i::Copy(paragon_handle); has_pending_exception = result.is_null(); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Object>()); + EXCEPTION_BAILOUT_CHECK(Local<Object>()); return Utils::ToLocal(result); } Local<String> v8::String::NewSymbol(const char* data, int length) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::String::NewSymbol()"); - LOG_API(isolate, "String::NewSymbol(char)"); - ENTER_V8(isolate); + EnsureInitialized("v8::String::NewSymbol()"); + LOG_API("String::NewSymbol(char)"); + ENTER_V8; if (length == -1) length = i::StrLength(data); i::Handle<i::String> result = - isolate->factory()->LookupSymbol(i::Vector<const char>(data, length)); + i::Factory::LookupSymbol(i::Vector<const char>(data, length)); return Utils::ToLocal(result); } Local<Number> v8::Number::New(double value) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Number::New()"); + EnsureInitialized("v8::Number::New()"); if (isnan(value)) { // Introduce only canonical NaN value into the VM, to avoid signaling NaNs. value = i::OS::nan_value(); } - ENTER_V8(isolate); - i::Handle<i::Object> result = isolate->factory()->NewNumber(value); + ENTER_V8; + i::Handle<i::Object> result = i::Factory::NewNumber(value); return Utils::NumberToLocal(result); } Local<Integer> v8::Integer::New(int32_t value) { - i::Isolate* isolate = i::Isolate::UncheckedCurrent(); - EnsureInitializedForIsolate(isolate, "v8::Integer::New()"); + EnsureInitialized("v8::Integer::New()"); if (i::Smi::IsValid(value)) { - return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value), - isolate)); + return Utils::IntegerToLocal(i::Handle<i::Object>(i::Smi::FromInt(value))); } - ENTER_V8(isolate); - i::Handle<i::Object> result = isolate->factory()->NewNumber(value); + ENTER_V8; + i::Handle<i::Object> result = i::Factory::NewNumber(value); return Utils::IntegerToLocal(result); } @@ -4641,30 +4009,27 @@ Local<Integer> Integer::NewFromUnsigned(uint32_t value) { if (fits_into_int32_t) { return Integer::New(static_cast<int32_t>(value)); } - i::Isolate* isolate = i::Isolate::Current(); - ENTER_V8(isolate); - i::Handle<i::Object> result = isolate->factory()->NewNumber(value); + ENTER_V8; + i::Handle<i::Object> result = i::Factory::NewNumber(value); return Utils::IntegerToLocal(result); } void V8::IgnoreOutOfMemoryException() { - EnterIsolateIfNeeded()->handle_scope_implementer()->set_ignore_out_of_memory( - true); + thread_local.set_ignore_out_of_memory(true); } bool V8::AddMessageListener(MessageCallback that, Handle<Value> data) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::V8::AddMessageListener()"); - ON_BAILOUT(isolate, "v8::V8::AddMessageListener()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - NeanderArray listeners(isolate->factory()->message_listeners()); + EnsureInitialized("v8::V8::AddMessageListener()"); + ON_BAILOUT("v8::V8::AddMessageListener()", return false); + ENTER_V8; + HandleScope scope; + NeanderArray listeners(i::Factory::message_listeners()); NeanderObject obj(2); - obj.set(0, *isolate->factory()->NewForeign(FUNCTION_ADDR(that))); + obj.set(0, *i::Factory::NewProxy(FUNCTION_ADDR(that))); obj.set(1, data.IsEmpty() ? - isolate->heap()->undefined_value() : + i::Heap::undefined_value() : *Utils::OpenHandle(*data)); listeners.add(obj.value()); return true; @@ -4672,19 +4037,18 @@ bool V8::AddMessageListener(MessageCallback that, Handle<Value> data) { void V8::RemoveMessageListeners(MessageCallback that) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::V8::RemoveMessageListener()"); - ON_BAILOUT(isolate, "v8::V8::RemoveMessageListeners()", return); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - NeanderArray listeners(isolate->factory()->message_listeners()); + EnsureInitialized("v8::V8::RemoveMessageListener()"); + ON_BAILOUT("v8::V8::RemoveMessageListeners()", return); + ENTER_V8; + HandleScope scope; + NeanderArray listeners(i::Factory::message_listeners()); for (int i = 0; i < listeners.length(); i++) { if (listeners.get(i)->IsUndefined()) continue; // skip deleted ones NeanderObject listener(i::JSObject::cast(listeners.get(i))); - i::Handle<i::Foreign> callback_obj(i::Foreign::cast(listener.get(0))); - if (callback_obj->address() == FUNCTION_ADDR(that)) { - listeners.set(i, isolate->heap()->undefined_value()); + i::Handle<i::Proxy> callback_obj(i::Proxy::cast(listener.get(0))); + if (callback_obj->proxy() == FUNCTION_ADDR(that)) { + listeners.set(i, i::Heap::undefined_value()); } } } @@ -4694,7 +4058,7 @@ void V8::SetCaptureStackTraceForUncaughtExceptions( bool capture, int frame_limit, StackTrace::StackTraceOptions options) { - i::Isolate::Current()->SetCaptureStackTraceForUncaughtExceptions( + i::Top::SetCaptureStackTraceForUncaughtExceptions( capture, frame_limit, options); @@ -4702,267 +4066,223 @@ void V8::SetCaptureStackTraceForUncaughtExceptions( void V8::SetCounterFunction(CounterLookupCallback callback) { - i::Isolate* isolate = EnterIsolateIfNeeded(); - if (IsDeadCheck(isolate, "v8::V8::SetCounterFunction()")) return; - isolate->stats_table()->SetCounterFunction(callback); + if (IsDeadCheck("v8::V8::SetCounterFunction()")) return; + i::StatsTable::SetCounterFunction(callback); } void V8::SetCreateHistogramFunction(CreateHistogramCallback callback) { - i::Isolate* isolate = EnterIsolateIfNeeded(); - if (IsDeadCheck(isolate, "v8::V8::SetCreateHistogramFunction()")) return; - isolate->stats_table()->SetCreateHistogramFunction(callback); + if (IsDeadCheck("v8::V8::SetCreateHistogramFunction()")) return; + i::StatsTable::SetCreateHistogramFunction(callback); } void V8::SetAddHistogramSampleFunction(AddHistogramSampleCallback callback) { - i::Isolate* isolate = EnterIsolateIfNeeded(); - if (IsDeadCheck(isolate, "v8::V8::SetAddHistogramSampleFunction()")) return; - isolate->stats_table()-> - SetAddHistogramSampleFunction(callback); + if (IsDeadCheck("v8::V8::SetAddHistogramSampleFunction()")) return; + i::StatsTable::SetAddHistogramSampleFunction(callback); } void V8::EnableSlidingStateWindow() { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::EnableSlidingStateWindow()")) return; - isolate->logger()->EnableSlidingStateWindow(); + if (IsDeadCheck("v8::V8::EnableSlidingStateWindow()")) return; + i::Logger::EnableSlidingStateWindow(); } void V8::SetFailedAccessCheckCallbackFunction( FailedAccessCheckCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::SetFailedAccessCheckCallbackFunction()")) { - return; - } - isolate->SetFailedAccessCheckCallback(callback); -} - -void V8::AddObjectGroup(Persistent<Value>* objects, - size_t length, - RetainedObjectInfo* info) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddObjectGroup()")) return; - STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**)); - isolate->global_handles()->AddObjectGroup( - reinterpret_cast<i::Object***>(objects), length, info); + if (IsDeadCheck("v8::V8::SetFailedAccessCheckCallbackFunction()")) return; + i::Top::SetFailedAccessCheckCallback(callback); } -void V8::AddImplicitReferences(Persistent<Object> parent, - Persistent<Value>* children, - size_t length) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddImplicitReferences()")) return; +void V8::AddObjectGroup(Persistent<Value>* objects, size_t length) { + if (IsDeadCheck("v8::V8::AddObjectGroup()")) return; STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**)); - isolate->global_handles()->AddImplicitReferences( - i::Handle<i::HeapObject>::cast(Utils::OpenHandle(*parent)).location(), - reinterpret_cast<i::Object***>(children), length); + i::GlobalHandles::AddGroup(reinterpret_cast<i::Object***>(objects), length); } int V8::AdjustAmountOfExternalAllocatedMemory(int change_in_bytes) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AdjustAmountOfExternalAllocatedMemory()")) { - return 0; - } - return isolate->heap()->AdjustAmountOfExternalAllocatedMemory( - change_in_bytes); + if (IsDeadCheck("v8::V8::AdjustAmountOfExternalAllocatedMemory()")) return 0; + return i::Heap::AdjustAmountOfExternalAllocatedMemory(change_in_bytes); } void V8::SetGlobalGCPrologueCallback(GCCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::SetGlobalGCPrologueCallback()")) return; - isolate->heap()->SetGlobalGCPrologueCallback(callback); + if (IsDeadCheck("v8::V8::SetGlobalGCPrologueCallback()")) return; + i::Heap::SetGlobalGCPrologueCallback(callback); } void V8::SetGlobalGCEpilogueCallback(GCCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::SetGlobalGCEpilogueCallback()")) return; - isolate->heap()->SetGlobalGCEpilogueCallback(callback); + if (IsDeadCheck("v8::V8::SetGlobalGCEpilogueCallback()")) return; + i::Heap::SetGlobalGCEpilogueCallback(callback); } void V8::AddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddGCPrologueCallback()")) return; - isolate->heap()->AddGCPrologueCallback(callback, gc_type); + if (IsDeadCheck("v8::V8::AddGCPrologueCallback()")) return; + i::Heap::AddGCPrologueCallback(callback, gc_type); } void V8::RemoveGCPrologueCallback(GCPrologueCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::RemoveGCPrologueCallback()")) return; - isolate->heap()->RemoveGCPrologueCallback(callback); + if (IsDeadCheck("v8::V8::RemoveGCPrologueCallback()")) return; + i::Heap::RemoveGCPrologueCallback(callback); } void V8::AddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddGCEpilogueCallback()")) return; - isolate->heap()->AddGCEpilogueCallback(callback, gc_type); + if (IsDeadCheck("v8::V8::AddGCEpilogueCallback()")) return; + i::Heap::AddGCEpilogueCallback(callback, gc_type); } void V8::RemoveGCEpilogueCallback(GCEpilogueCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::RemoveGCEpilogueCallback()")) return; - isolate->heap()->RemoveGCEpilogueCallback(callback); + if (IsDeadCheck("v8::V8::RemoveGCEpilogueCallback()")) return; + i::Heap::RemoveGCEpilogueCallback(callback); } void V8::AddMemoryAllocationCallback(MemoryAllocationCallback callback, ObjectSpace space, AllocationAction action) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddMemoryAllocationCallback()")) return; - isolate->memory_allocator()->AddMemoryAllocationCallback( - callback, space, action); + if (IsDeadCheck("v8::V8::AddMemoryAllocationCallback()")) return; + i::MemoryAllocator::AddMemoryAllocationCallback(callback, + space, + action); } void V8::RemoveMemoryAllocationCallback(MemoryAllocationCallback callback) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::RemoveMemoryAllocationCallback()")) return; - isolate->memory_allocator()->RemoveMemoryAllocationCallback( - callback); + if (IsDeadCheck("v8::V8::RemoveMemoryAllocationCallback()")) return; + i::MemoryAllocator::RemoveMemoryAllocationCallback(callback); } void V8::PauseProfiler() { #ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - isolate->logger()->PauseProfiler(); + PauseProfilerEx(PROFILER_MODULE_CPU); #endif } void V8::ResumeProfiler() { #ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - isolate->logger()->ResumeProfiler(); + ResumeProfilerEx(PROFILER_MODULE_CPU); #endif } bool V8::IsProfilerPaused() { #ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - return isolate->logger()->IsProfilerPaused(); + return i::Logger::GetActiveProfilerModules() & PROFILER_MODULE_CPU; #else return true; #endif } +void V8::ResumeProfilerEx(int flags, int tag) { +#ifdef ENABLE_LOGGING_AND_PROFILING + if (flags & PROFILER_MODULE_HEAP_SNAPSHOT) { + // Snapshot mode: resume modules, perform GC, then pause only + // those modules which haven't been started prior to making a + // snapshot. + + // Make a GC prior to taking a snapshot. + i::Heap::CollectAllGarbage(false); + // Reset snapshot flag and CPU module flags. + flags &= ~(PROFILER_MODULE_HEAP_SNAPSHOT | PROFILER_MODULE_CPU); + const int current_flags = i::Logger::GetActiveProfilerModules(); + i::Logger::ResumeProfiler(flags, tag); + i::Heap::CollectAllGarbage(false); + i::Logger::PauseProfiler(~current_flags & flags, tag); + } else { + i::Logger::ResumeProfiler(flags, tag); + } +#endif +} + + +void V8::PauseProfilerEx(int flags, int tag) { +#ifdef ENABLE_LOGGING_AND_PROFILING + i::Logger::PauseProfiler(flags, tag); +#endif +} + + +int V8::GetActiveProfilerModules() { +#ifdef ENABLE_LOGGING_AND_PROFILING + return i::Logger::GetActiveProfilerModules(); +#else + return PROFILER_MODULE_NONE; +#endif +} + + int V8::GetLogLines(int from_pos, char* dest_buf, int max_size) { #ifdef ENABLE_LOGGING_AND_PROFILING ASSERT(max_size >= kMinimumSizeForLogLinesBuffer); - return LOGGER->GetLogLines(from_pos, dest_buf, max_size); + return i::Logger::GetLogLines(from_pos, dest_buf, max_size); #endif return 0; } int V8::GetCurrentThreadId() { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "V8::GetCurrentThreadId()"); - return isolate->thread_id().ToInteger(); + API_ENTRY_CHECK("V8::GetCurrentThreadId()"); + EnsureInitialized("V8::GetCurrentThreadId()"); + return i::Top::thread_id(); } void V8::TerminateExecution(int thread_id) { - i::Isolate* isolate = i::Isolate::Current(); - if (!isolate->IsInitialized()) return; - API_ENTRY_CHECK(isolate, "V8::TerminateExecution()"); + if (!i::V8::IsRunning()) return; + API_ENTRY_CHECK("V8::GetCurrentThreadId()"); // If the thread_id identifies the current thread just terminate // execution right away. Otherwise, ask the thread manager to // terminate the thread with the given id if any. - i::ThreadId internal_tid = i::ThreadId::FromInteger(thread_id); - if (isolate->thread_id().Equals(internal_tid)) { - isolate->stack_guard()->TerminateExecution(); + if (thread_id == i::Top::thread_id()) { + i::StackGuard::TerminateExecution(); } else { - isolate->thread_manager()->TerminateExecution(internal_tid); + i::ThreadManager::TerminateExecution(thread_id); } } -void V8::TerminateExecution(Isolate* isolate) { - // If no isolate is supplied, use the default isolate. - if (isolate != NULL) { - reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->TerminateExecution(); - } else { - i::Isolate::GetDefaultIsolateStackGuard()->TerminateExecution(); - } -} - - -bool V8::IsExecutionTerminating(Isolate* isolate) { - i::Isolate* i_isolate = isolate != NULL ? - reinterpret_cast<i::Isolate*>(isolate) : i::Isolate::Current(); - return IsExecutionTerminatingCheck(i_isolate); +void V8::TerminateExecution() { + if (!i::V8::IsRunning()) return; + i::StackGuard::TerminateExecution(); } -Isolate* Isolate::GetCurrent() { - i::Isolate* isolate = i::Isolate::UncheckedCurrent(); - return reinterpret_cast<Isolate*>(isolate); -} - - -Isolate* Isolate::New() { - i::Isolate* isolate = new i::Isolate(); - return reinterpret_cast<Isolate*>(isolate); +bool V8::IsExecutionTerminating() { + if (!i::V8::IsRunning()) return false; + if (i::Top::has_scheduled_exception()) { + return i::Top::scheduled_exception() == i::Heap::termination_exception(); + } + return false; } -void Isolate::Dispose() { - i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this); - if (!ApiCheck(!isolate->IsInUse(), - "v8::Isolate::Dispose()", - "Disposing the isolate that is entered by a thread.")) { +String::Utf8Value::Utf8Value(v8::Handle<v8::Value> obj) { + EnsureInitialized("v8::String::Utf8Value::Utf8Value()"); + if (obj.IsEmpty()) { + str_ = NULL; + length_ = 0; return; } - isolate->TearDown(); -} - - -void Isolate::Enter() { - i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this); - isolate->Enter(); -} - - -void Isolate::Exit() { - i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this); - isolate->Exit(); -} - - -void Isolate::SetData(void* data) { - i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this); - isolate->SetData(data); -} - -void* Isolate::GetData() { - i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this); - return isolate->GetData(); -} - - -String::Utf8Value::Utf8Value(v8::Handle<v8::Value> obj) - : str_(NULL), length_(0) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::String::Utf8Value::Utf8Value()")) return; - if (obj.IsEmpty()) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); + ENTER_V8; + HandleScope scope; TryCatch try_catch; Handle<String> str = obj->ToString(); - if (str.IsEmpty()) return; - length_ = str->Utf8Length(); - str_ = i::NewArray<char>(length_ + 1); - str->WriteUtf8(str_); + if (str.IsEmpty()) { + str_ = NULL; + length_ = 0; + } else { + length_ = str->Utf8Length(); + str_ = i::NewArray<char>(length_ + 1); + str->WriteUtf8(str_); + } } @@ -4971,19 +4291,25 @@ String::Utf8Value::~Utf8Value() { } -String::AsciiValue::AsciiValue(v8::Handle<v8::Value> obj) - : str_(NULL), length_(0) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::String::AsciiValue::AsciiValue()")) return; - if (obj.IsEmpty()) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); +String::AsciiValue::AsciiValue(v8::Handle<v8::Value> obj) { + EnsureInitialized("v8::String::AsciiValue::AsciiValue()"); + if (obj.IsEmpty()) { + str_ = NULL; + length_ = 0; + return; + } + ENTER_V8; + HandleScope scope; TryCatch try_catch; Handle<String> str = obj->ToString(); - if (str.IsEmpty()) return; - length_ = str->Length(); - str_ = i::NewArray<char>(length_ + 1); - str->WriteAscii(str_); + if (str.IsEmpty()) { + str_ = NULL; + length_ = 0; + } else { + length_ = str->Length(); + str_ = i::NewArray<char>(length_ + 1); + str->WriteAscii(str_); + } } @@ -4992,19 +4318,25 @@ String::AsciiValue::~AsciiValue() { } -String::Value::Value(v8::Handle<v8::Value> obj) - : str_(NULL), length_(0) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::String::Value::Value()")) return; - if (obj.IsEmpty()) return; - ENTER_V8(isolate); - i::HandleScope scope(isolate); +String::Value::Value(v8::Handle<v8::Value> obj) { + EnsureInitialized("v8::String::Value::Value()"); + if (obj.IsEmpty()) { + str_ = NULL; + length_ = 0; + return; + } + ENTER_V8; + HandleScope scope; TryCatch try_catch; Handle<String> str = obj->ToString(); - if (str.IsEmpty()) return; - length_ = str->Length(); - str_ = i::NewArray<uint16_t>(length_ + 1); - str->Write(str_); + if (str.IsEmpty()) { + str_ = NULL; + length_ = 0; + } else { + length_ = str->Length(); + str_ = i::NewArray<uint16_t>(length_ + 1); + str->Write(str_); + } } @@ -5013,15 +4345,14 @@ String::Value::~Value() { } Local<Value> Exception::RangeError(v8::Handle<v8::String> raw_message) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "RangeError"); - ON_BAILOUT(isolate, "v8::Exception::RangeError()", return Local<Value>()); - ENTER_V8(isolate); + LOG_API("RangeError"); + ON_BAILOUT("v8::Exception::RangeError()", return Local<Value>()); + ENTER_V8; i::Object* error; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::String> message = Utils::OpenHandle(*raw_message); - i::Handle<i::Object> result = isolate->factory()->NewRangeError(message); + i::Handle<i::Object> result = i::Factory::NewRangeError(message); error = *result; } i::Handle<i::Object> result(error); @@ -5029,16 +4360,14 @@ Local<Value> Exception::RangeError(v8::Handle<v8::String> raw_message) { } Local<Value> Exception::ReferenceError(v8::Handle<v8::String> raw_message) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "ReferenceError"); - ON_BAILOUT(isolate, "v8::Exception::ReferenceError()", return Local<Value>()); - ENTER_V8(isolate); + LOG_API("ReferenceError"); + ON_BAILOUT("v8::Exception::ReferenceError()", return Local<Value>()); + ENTER_V8; i::Object* error; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::String> message = Utils::OpenHandle(*raw_message); - i::Handle<i::Object> result = - isolate->factory()->NewReferenceError(message); + i::Handle<i::Object> result = i::Factory::NewReferenceError(message); error = *result; } i::Handle<i::Object> result(error); @@ -5046,15 +4375,14 @@ Local<Value> Exception::ReferenceError(v8::Handle<v8::String> raw_message) { } Local<Value> Exception::SyntaxError(v8::Handle<v8::String> raw_message) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "SyntaxError"); - ON_BAILOUT(isolate, "v8::Exception::SyntaxError()", return Local<Value>()); - ENTER_V8(isolate); + LOG_API("SyntaxError"); + ON_BAILOUT("v8::Exception::SyntaxError()", return Local<Value>()); + ENTER_V8; i::Object* error; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::String> message = Utils::OpenHandle(*raw_message); - i::Handle<i::Object> result = isolate->factory()->NewSyntaxError(message); + i::Handle<i::Object> result = i::Factory::NewSyntaxError(message); error = *result; } i::Handle<i::Object> result(error); @@ -5062,15 +4390,14 @@ Local<Value> Exception::SyntaxError(v8::Handle<v8::String> raw_message) { } Local<Value> Exception::TypeError(v8::Handle<v8::String> raw_message) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "TypeError"); - ON_BAILOUT(isolate, "v8::Exception::TypeError()", return Local<Value>()); - ENTER_V8(isolate); + LOG_API("TypeError"); + ON_BAILOUT("v8::Exception::TypeError()", return Local<Value>()); + ENTER_V8; i::Object* error; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::String> message = Utils::OpenHandle(*raw_message); - i::Handle<i::Object> result = isolate->factory()->NewTypeError(message); + i::Handle<i::Object> result = i::Factory::NewTypeError(message); error = *result; } i::Handle<i::Object> result(error); @@ -5078,15 +4405,14 @@ Local<Value> Exception::TypeError(v8::Handle<v8::String> raw_message) { } Local<Value> Exception::Error(v8::Handle<v8::String> raw_message) { - i::Isolate* isolate = i::Isolate::Current(); - LOG_API(isolate, "Error"); - ON_BAILOUT(isolate, "v8::Exception::Error()", return Local<Value>()); - ENTER_V8(isolate); + LOG_API("Error"); + ON_BAILOUT("v8::Exception::Error()", return Local<Value>()); + ENTER_V8; i::Object* error; { - i::HandleScope scope(isolate); + HandleScope scope; i::Handle<i::String> message = Utils::OpenHandle(*raw_message); - i::Handle<i::Object> result = isolate->factory()->NewError(message); + i::Handle<i::Object> result = i::Factory::NewError(message); error = *result; } i::Handle<i::Object> result(error); @@ -5098,216 +4424,180 @@ Local<Value> Exception::Error(v8::Handle<v8::String> raw_message) { #ifdef ENABLE_DEBUGGER_SUPPORT +static v8::Debug::EventCallback event_callback = NULL; + static void EventCallbackWrapper(const v8::Debug::EventDetails& event_details) { - i::Isolate* isolate = i::Isolate::Current(); - if (isolate->debug_event_callback() != NULL) { - isolate->debug_event_callback()(event_details.GetEvent(), - event_details.GetExecutionState(), - event_details.GetEventData(), - event_details.GetCallbackData()); + if (event_callback) { + event_callback(event_details.GetEvent(), + event_details.GetExecutionState(), + event_details.GetEventData(), + event_details.GetCallbackData()); } } bool Debug::SetDebugEventListener(EventCallback that, Handle<Value> data) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Debug::SetDebugEventListener()"); - ON_BAILOUT(isolate, "v8::Debug::SetDebugEventListener()", return false); - ENTER_V8(isolate); + EnsureInitialized("v8::Debug::SetDebugEventListener()"); + ON_BAILOUT("v8::Debug::SetDebugEventListener()", return false); + ENTER_V8; - isolate->set_debug_event_callback(that); + event_callback = that; - i::HandleScope scope(isolate); - i::Handle<i::Object> foreign = isolate->factory()->undefined_value(); + HandleScope scope; + i::Handle<i::Object> proxy = i::Factory::undefined_value(); if (that != NULL) { - foreign = - isolate->factory()->NewForeign(FUNCTION_ADDR(EventCallbackWrapper)); + proxy = i::Factory::NewProxy(FUNCTION_ADDR(EventCallbackWrapper)); } - isolate->debugger()->SetEventListener(foreign, Utils::OpenHandle(*data)); + i::Debugger::SetEventListener(proxy, Utils::OpenHandle(*data)); return true; } bool Debug::SetDebugEventListener2(EventCallback2 that, Handle<Value> data) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Debug::SetDebugEventListener2()"); - ON_BAILOUT(isolate, "v8::Debug::SetDebugEventListener2()", return false); - ENTER_V8(isolate); - i::HandleScope scope(isolate); - i::Handle<i::Object> foreign = isolate->factory()->undefined_value(); + EnsureInitialized("v8::Debug::SetDebugEventListener2()"); + ON_BAILOUT("v8::Debug::SetDebugEventListener2()", return false); + ENTER_V8; + HandleScope scope; + i::Handle<i::Object> proxy = i::Factory::undefined_value(); if (that != NULL) { - foreign = isolate->factory()->NewForeign(FUNCTION_ADDR(that)); + proxy = i::Factory::NewProxy(FUNCTION_ADDR(that)); } - isolate->debugger()->SetEventListener(foreign, Utils::OpenHandle(*data)); + i::Debugger::SetEventListener(proxy, Utils::OpenHandle(*data)); return true; } bool Debug::SetDebugEventListener(v8::Handle<v8::Object> that, Handle<Value> data) { - i::Isolate* isolate = i::Isolate::Current(); - ON_BAILOUT(isolate, "v8::Debug::SetDebugEventListener()", return false); - ENTER_V8(isolate); - isolate->debugger()->SetEventListener(Utils::OpenHandle(*that), - Utils::OpenHandle(*data)); + ON_BAILOUT("v8::Debug::SetDebugEventListener()", return false); + ENTER_V8; + i::Debugger::SetEventListener(Utils::OpenHandle(*that), + Utils::OpenHandle(*data)); return true; } -void Debug::DebugBreak(Isolate* isolate) { - // If no isolate is supplied, use the default isolate. - if (isolate != NULL) { - reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->DebugBreak(); - } else { - i::Isolate::GetDefaultIsolateStackGuard()->DebugBreak(); - } +void Debug::DebugBreak() { + if (!i::V8::IsRunning()) return; + i::StackGuard::DebugBreak(); } -void Debug::CancelDebugBreak(Isolate* isolate) { - // If no isolate is supplied, use the default isolate. - if (isolate != NULL) { - i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate); - internal_isolate->stack_guard()->Continue(i::DEBUGBREAK); - } else { - i::Isolate::GetDefaultIsolateStackGuard()->Continue(i::DEBUGBREAK); - } +void Debug::CancelDebugBreak() { + i::StackGuard::Continue(i::DEBUGBREAK); } -void Debug::DebugBreakForCommand(ClientData* data, Isolate* isolate) { - // If no isolate is supplied, use the default isolate. - if (isolate != NULL) { - i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate); - internal_isolate->debugger()->EnqueueDebugCommand(data); - } else { - i::Isolate::GetDefaultIsolateDebugger()->EnqueueDebugCommand(data); - } +void Debug::DebugBreakForCommand(ClientData* data) { + if (!i::V8::IsRunning()) return; + i::Debugger::EnqueueDebugCommand(data); } +static v8::Debug::MessageHandler message_handler = NULL; + static void MessageHandlerWrapper(const v8::Debug::Message& message) { - i::Isolate* isolate = i::Isolate::Current(); - if (isolate->message_handler()) { + if (message_handler) { v8::String::Value json(message.GetJSON()); - (isolate->message_handler())(*json, json.length(), message.GetClientData()); + message_handler(*json, json.length(), message.GetClientData()); } } void Debug::SetMessageHandler(v8::Debug::MessageHandler handler, bool message_handler_thread) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Debug::SetMessageHandler"); - ENTER_V8(isolate); - + EnsureInitialized("v8::Debug::SetMessageHandler"); + ENTER_V8; // Message handler thread not supported any more. Parameter temporally left in - // the API for client compatibility reasons. + // the API for client compatability reasons. CHECK(!message_handler_thread); // TODO(sgjesse) support the old message handler API through a simple wrapper. - isolate->set_message_handler(handler); - if (handler != NULL) { - isolate->debugger()->SetMessageHandler(MessageHandlerWrapper); + message_handler = handler; + if (message_handler != NULL) { + i::Debugger::SetMessageHandler(MessageHandlerWrapper); } else { - isolate->debugger()->SetMessageHandler(NULL); + i::Debugger::SetMessageHandler(NULL); } } void Debug::SetMessageHandler2(v8::Debug::MessageHandler2 handler) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Debug::SetMessageHandler"); - ENTER_V8(isolate); - isolate->debugger()->SetMessageHandler(handler); + EnsureInitialized("v8::Debug::SetMessageHandler"); + ENTER_V8; + i::Debugger::SetMessageHandler(handler); } void Debug::SendCommand(const uint16_t* command, int length, - ClientData* client_data, - Isolate* isolate) { - // If no isolate is supplied, use the default isolate. - if (isolate != NULL) { - i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate); - internal_isolate->debugger()->ProcessCommand( - i::Vector<const uint16_t>(command, length), client_data); - } else { - i::Isolate::GetDefaultIsolateDebugger()->ProcessCommand( - i::Vector<const uint16_t>(command, length), client_data); - } + ClientData* client_data) { + if (!i::V8::IsRunning()) return; + i::Debugger::ProcessCommand(i::Vector<const uint16_t>(command, length), + client_data); } void Debug::SetHostDispatchHandler(HostDispatchHandler handler, int period) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Debug::SetHostDispatchHandler"); - ENTER_V8(isolate); - isolate->debugger()->SetHostDispatchHandler(handler, period); + EnsureInitialized("v8::Debug::SetHostDispatchHandler"); + ENTER_V8; + i::Debugger::SetHostDispatchHandler(handler, period); } void Debug::SetDebugMessageDispatchHandler( DebugMessageDispatchHandler handler, bool provide_locker) { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, - "v8::Debug::SetDebugMessageDispatchHandler"); - ENTER_V8(isolate); - isolate->debugger()->SetDebugMessageDispatchHandler( - handler, provide_locker); + EnsureInitialized("v8::Debug::SetDebugMessageDispatchHandler"); + ENTER_V8; + i::Debugger::SetDebugMessageDispatchHandler(handler, provide_locker); } Local<Value> Debug::Call(v8::Handle<v8::Function> fun, v8::Handle<v8::Value> data) { - i::Isolate* isolate = i::Isolate::Current(); - if (!isolate->IsInitialized()) return Local<Value>(); - ON_BAILOUT(isolate, "v8::Debug::Call()", return Local<Value>()); - ENTER_V8(isolate); + if (!i::V8::IsRunning()) return Local<Value>(); + ON_BAILOUT("v8::Debug::Call()", return Local<Value>()); + ENTER_V8; i::Handle<i::Object> result; - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); if (data.IsEmpty()) { - result = isolate->debugger()->Call(Utils::OpenHandle(*fun), - isolate->factory()->undefined_value(), - &has_pending_exception); + result = i::Debugger::Call(Utils::OpenHandle(*fun), + i::Factory::undefined_value(), + &has_pending_exception); } else { - result = isolate->debugger()->Call(Utils::OpenHandle(*fun), - Utils::OpenHandle(*data), - &has_pending_exception); + result = i::Debugger::Call(Utils::OpenHandle(*fun), + Utils::OpenHandle(*data), + &has_pending_exception); } - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); + EXCEPTION_BAILOUT_CHECK(Local<Value>()); return Utils::ToLocal(result); } Local<Value> Debug::GetMirror(v8::Handle<v8::Value> obj) { - i::Isolate* isolate = i::Isolate::Current(); - if (!isolate->IsInitialized()) return Local<Value>(); - ON_BAILOUT(isolate, "v8::Debug::GetMirror()", return Local<Value>()); - ENTER_V8(isolate); + if (!i::V8::IsRunning()) return Local<Value>(); + ON_BAILOUT("v8::Debug::GetMirror()", return Local<Value>()); + ENTER_V8; v8::HandleScope scope; - i::Debug* isolate_debug = isolate->debug(); - isolate_debug->Load(); - i::Handle<i::JSObject> debug(isolate_debug->debug_context()->global()); - i::Handle<i::String> name = - isolate->factory()->LookupAsciiSymbol("MakeMirror"); + i::Debug::Load(); + i::Handle<i::JSObject> debug(i::Debug::debug_context()->global()); + i::Handle<i::String> name = i::Factory::LookupAsciiSymbol("MakeMirror"); i::Handle<i::Object> fun_obj = i::GetProperty(debug, name); i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(fun_obj); v8::Handle<v8::Function> v8_fun = Utils::ToLocal(fun); const int kArgc = 1; v8::Handle<v8::Value> argv[kArgc] = { obj }; - EXCEPTION_PREAMBLE(isolate); + EXCEPTION_PREAMBLE(); v8::Handle<v8::Value> result = v8_fun->Call(Utils::ToLocal(debug), kArgc, argv); - EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>()); + EXCEPTION_BAILOUT_CHECK(Local<Value>()); return scope.Close(result); } bool Debug::EnableAgent(const char* name, int port, bool wait_for_connection) { - return i::Isolate::Current()->debugger()->StartAgent(name, port, - wait_for_connection); + return i::Debugger::StartAgent(name, port, wait_for_connection); } void Debug::ProcessDebugMessages() { @@ -5315,568 +4605,389 @@ void Debug::ProcessDebugMessages() { } Local<Context> Debug::GetDebugContext() { - i::Isolate* isolate = i::Isolate::Current(); - EnsureInitializedForIsolate(isolate, "v8::Debug::GetDebugContext()"); - ENTER_V8(isolate); - return Utils::ToLocal(i::Isolate::Current()->debugger()->GetDebugContext()); + EnsureInitialized("v8::Debug::GetDebugContext()"); + ENTER_V8; + return Utils::ToLocal(i::Debugger::GetDebugContext()); } #endif // ENABLE_DEBUGGER_SUPPORT -Handle<String> CpuProfileNode::GetFunctionName() const { #ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetFunctionName"); + +Handle<String> CpuProfileNode::GetFunctionName() const { + IsDeadCheck("v8::CpuProfileNode::GetFunctionName"); const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this); const i::CodeEntry* entry = node->entry(); if (!entry->has_name_prefix()) { return Handle<String>(ToApi<String>( - isolate->factory()->LookupAsciiSymbol(entry->name()))); + i::Factory::LookupAsciiSymbol(entry->name()))); } else { - return Handle<String>(ToApi<String>(isolate->factory()->NewConsString( - isolate->factory()->LookupAsciiSymbol(entry->name_prefix()), - isolate->factory()->LookupAsciiSymbol(entry->name())))); + return Handle<String>(ToApi<String>(i::Factory::NewConsString( + i::Factory::LookupAsciiSymbol(entry->name_prefix()), + i::Factory::LookupAsciiSymbol(entry->name())))); } -#else - return v8::String::Empty(); -#endif } Handle<String> CpuProfileNode::GetScriptResourceName() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetScriptResourceName"); + IsDeadCheck("v8::CpuProfileNode::GetScriptResourceName"); const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this); - return Handle<String>(ToApi<String>(isolate->factory()->LookupAsciiSymbol( + return Handle<String>(ToApi<String>(i::Factory::LookupAsciiSymbol( node->entry()->resource_name()))); -#else - return v8::String::Empty(); -#endif } int CpuProfileNode::GetLineNumber() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetLineNumber"); + IsDeadCheck("v8::CpuProfileNode::GetLineNumber"); return reinterpret_cast<const i::ProfileNode*>(this)->entry()->line_number(); -#else - return 0; -#endif } double CpuProfileNode::GetTotalTime() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetTotalTime"); + IsDeadCheck("v8::CpuProfileNode::GetTotalTime"); return reinterpret_cast<const i::ProfileNode*>(this)->GetTotalMillis(); -#else - return 0.0; -#endif } double CpuProfileNode::GetSelfTime() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetSelfTime"); + IsDeadCheck("v8::CpuProfileNode::GetSelfTime"); return reinterpret_cast<const i::ProfileNode*>(this)->GetSelfMillis(); -#else - return 0.0; -#endif } double CpuProfileNode::GetTotalSamplesCount() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetTotalSamplesCount"); + IsDeadCheck("v8::CpuProfileNode::GetTotalSamplesCount"); return reinterpret_cast<const i::ProfileNode*>(this)->total_ticks(); -#else - return 0.0; -#endif } double CpuProfileNode::GetSelfSamplesCount() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetSelfSamplesCount"); + IsDeadCheck("v8::CpuProfileNode::GetSelfSamplesCount"); return reinterpret_cast<const i::ProfileNode*>(this)->self_ticks(); -#else - return 0.0; -#endif } unsigned CpuProfileNode::GetCallUid() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetCallUid"); + IsDeadCheck("v8::CpuProfileNode::GetCallUid"); return reinterpret_cast<const i::ProfileNode*>(this)->entry()->GetCallUid(); -#else - return 0; -#endif } int CpuProfileNode::GetChildrenCount() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetChildrenCount"); + IsDeadCheck("v8::CpuProfileNode::GetChildrenCount"); return reinterpret_cast<const i::ProfileNode*>(this)->children()->length(); -#else - return 0; -#endif } const CpuProfileNode* CpuProfileNode::GetChild(int index) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfileNode::GetChild"); + IsDeadCheck("v8::CpuProfileNode::GetChild"); const i::ProfileNode* child = reinterpret_cast<const i::ProfileNode*>(this)->children()->at(index); return reinterpret_cast<const CpuProfileNode*>(child); -#else - return NULL; -#endif -} - - -void CpuProfile::Delete() { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfile::Delete"); - i::CpuProfiler::DeleteProfile(reinterpret_cast<i::CpuProfile*>(this)); - if (i::CpuProfiler::GetProfilesCount() == 0 && - !i::CpuProfiler::HasDetachedProfiles()) { - // If this was the last profile, clean up all accessory data as well. - i::CpuProfiler::DeleteAllProfiles(); - } -#endif } unsigned CpuProfile::GetUid() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfile::GetUid"); + IsDeadCheck("v8::CpuProfile::GetUid"); return reinterpret_cast<const i::CpuProfile*>(this)->uid(); -#else - return 0; -#endif } Handle<String> CpuProfile::GetTitle() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfile::GetTitle"); + IsDeadCheck("v8::CpuProfile::GetTitle"); const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this); - return Handle<String>(ToApi<String>(isolate->factory()->LookupAsciiSymbol( + return Handle<String>(ToApi<String>(i::Factory::LookupAsciiSymbol( profile->title()))); -#else - return v8::String::Empty(); -#endif } const CpuProfileNode* CpuProfile::GetBottomUpRoot() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfile::GetBottomUpRoot"); + IsDeadCheck("v8::CpuProfile::GetBottomUpRoot"); const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this); return reinterpret_cast<const CpuProfileNode*>(profile->bottom_up()->root()); -#else - return NULL; -#endif } const CpuProfileNode* CpuProfile::GetTopDownRoot() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfile::GetTopDownRoot"); + IsDeadCheck("v8::CpuProfile::GetTopDownRoot"); const i::CpuProfile* profile = reinterpret_cast<const i::CpuProfile*>(this); return reinterpret_cast<const CpuProfileNode*>(profile->top_down()->root()); -#else - return NULL; -#endif } int CpuProfiler::GetProfilesCount() { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfiler::GetProfilesCount"); + IsDeadCheck("v8::CpuProfiler::GetProfilesCount"); return i::CpuProfiler::GetProfilesCount(); -#else - return 0; -#endif } const CpuProfile* CpuProfiler::GetProfile(int index, Handle<Value> security_token) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfiler::GetProfile"); + IsDeadCheck("v8::CpuProfiler::GetProfile"); return reinterpret_cast<const CpuProfile*>( i::CpuProfiler::GetProfile( security_token.IsEmpty() ? NULL : *Utils::OpenHandle(*security_token), index)); -#else - return NULL; -#endif } const CpuProfile* CpuProfiler::FindProfile(unsigned uid, Handle<Value> security_token) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfiler::FindProfile"); + IsDeadCheck("v8::CpuProfiler::FindProfile"); return reinterpret_cast<const CpuProfile*>( i::CpuProfiler::FindProfile( security_token.IsEmpty() ? NULL : *Utils::OpenHandle(*security_token), uid)); -#else - return NULL; -#endif } void CpuProfiler::StartProfiling(Handle<String> title) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfiler::StartProfiling"); + IsDeadCheck("v8::CpuProfiler::StartProfiling"); i::CpuProfiler::StartProfiling(*Utils::OpenHandle(*title)); -#endif } const CpuProfile* CpuProfiler::StopProfiling(Handle<String> title, Handle<Value> security_token) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfiler::StopProfiling"); + IsDeadCheck("v8::CpuProfiler::StopProfiling"); return reinterpret_cast<const CpuProfile*>( i::CpuProfiler::StopProfiling( security_token.IsEmpty() ? NULL : *Utils::OpenHandle(*security_token), *Utils::OpenHandle(*title))); -#else - return NULL; -#endif -} - - -void CpuProfiler::DeleteAllProfiles() { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::CpuProfiler::DeleteAllProfiles"); - i::CpuProfiler::DeleteAllProfiles(); -#endif } -#ifdef ENABLE_LOGGING_AND_PROFILING static i::HeapGraphEdge* ToInternal(const HeapGraphEdge* edge) { return const_cast<i::HeapGraphEdge*>( reinterpret_cast<const i::HeapGraphEdge*>(edge)); } -#endif - HeapGraphEdge::Type HeapGraphEdge::GetType() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphEdge::GetType"); + IsDeadCheck("v8::HeapGraphEdge::GetType"); return static_cast<HeapGraphEdge::Type>(ToInternal(this)->type()); -#else - return static_cast<HeapGraphEdge::Type>(0); -#endif } Handle<Value> HeapGraphEdge::GetName() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphEdge::GetName"); + IsDeadCheck("v8::HeapGraphEdge::GetName"); i::HeapGraphEdge* edge = ToInternal(this); switch (edge->type()) { case i::HeapGraphEdge::kContextVariable: case i::HeapGraphEdge::kInternal: case i::HeapGraphEdge::kProperty: case i::HeapGraphEdge::kShortcut: - return Handle<String>(ToApi<String>(isolate->factory()->LookupAsciiSymbol( + return Handle<String>(ToApi<String>(i::Factory::LookupAsciiSymbol( edge->name()))); case i::HeapGraphEdge::kElement: case i::HeapGraphEdge::kHidden: - return Handle<Number>(ToApi<Number>(isolate->factory()->NewNumberFromInt( + return Handle<Number>(ToApi<Number>(i::Factory::NewNumberFromInt( edge->index()))); default: UNREACHABLE(); } -#endif - return v8::Undefined(); + return ImplementationUtilities::Undefined(); } const HeapGraphNode* HeapGraphEdge::GetFromNode() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphEdge::GetFromNode"); + IsDeadCheck("v8::HeapGraphEdge::GetFromNode"); const i::HeapEntry* from = ToInternal(this)->From(); return reinterpret_cast<const HeapGraphNode*>(from); -#else - return NULL; -#endif } const HeapGraphNode* HeapGraphEdge::GetToNode() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphEdge::GetToNode"); + IsDeadCheck("v8::HeapGraphEdge::GetToNode"); const i::HeapEntry* to = ToInternal(this)->to(); return reinterpret_cast<const HeapGraphNode*>(to); -#else - return NULL; -#endif } -#ifdef ENABLE_LOGGING_AND_PROFILING +static i::HeapGraphPath* ToInternal(const HeapGraphPath* path) { + return const_cast<i::HeapGraphPath*>( + reinterpret_cast<const i::HeapGraphPath*>(path)); +} + + +int HeapGraphPath::GetEdgesCount() const { + return ToInternal(this)->path()->length(); +} + + +const HeapGraphEdge* HeapGraphPath::GetEdge(int index) const { + return reinterpret_cast<const HeapGraphEdge*>( + ToInternal(this)->path()->at(index)); +} + + +const HeapGraphNode* HeapGraphPath::GetFromNode() const { + return GetEdgesCount() > 0 ? GetEdge(0)->GetFromNode() : NULL; +} + + +const HeapGraphNode* HeapGraphPath::GetToNode() const { + const int count = GetEdgesCount(); + return count > 0 ? GetEdge(count - 1)->GetToNode() : NULL; +} + + static i::HeapEntry* ToInternal(const HeapGraphNode* entry) { return const_cast<i::HeapEntry*>( reinterpret_cast<const i::HeapEntry*>(entry)); } -#endif HeapGraphNode::Type HeapGraphNode::GetType() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphNode::GetType"); + IsDeadCheck("v8::HeapGraphNode::GetType"); return static_cast<HeapGraphNode::Type>(ToInternal(this)->type()); -#else - return static_cast<HeapGraphNode::Type>(0); -#endif } Handle<String> HeapGraphNode::GetName() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphNode::GetName"); - return Handle<String>(ToApi<String>(isolate->factory()->LookupAsciiSymbol( + IsDeadCheck("v8::HeapGraphNode::GetName"); + return Handle<String>(ToApi<String>(i::Factory::LookupAsciiSymbol( ToInternal(this)->name()))); -#else - return v8::String::Empty(); -#endif } uint64_t HeapGraphNode::GetId() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphNode::GetId"); + IsDeadCheck("v8::HeapGraphNode::GetId"); + ASSERT(ToInternal(this)->snapshot()->type() != i::HeapSnapshot::kAggregated); return ToInternal(this)->id(); -#else - return 0; -#endif +} + + +int HeapGraphNode::GetInstancesCount() const { + IsDeadCheck("v8::HeapGraphNode::GetInstancesCount"); + ASSERT(ToInternal(this)->snapshot()->type() == i::HeapSnapshot::kAggregated); + return static_cast<int>(ToInternal(this)->id()); } int HeapGraphNode::GetSelfSize() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapGraphNode::GetSelfSize"); + IsDeadCheck("v8::HeapGraphNode::GetSelfSize"); return ToInternal(this)->self_size(); -#else - return 0; -#endif } int HeapGraphNode::GetRetainedSize(bool exact) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetRetainedSize"); + IsDeadCheck("v8::HeapSnapshot::GetRetainedSize"); return ToInternal(this)->RetainedSize(exact); -#else - return 0; -#endif } int HeapGraphNode::GetChildrenCount() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetChildrenCount"); + IsDeadCheck("v8::HeapSnapshot::GetChildrenCount"); return ToInternal(this)->children().length(); -#else - return 0; -#endif } const HeapGraphEdge* HeapGraphNode::GetChild(int index) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetChild"); + IsDeadCheck("v8::HeapSnapshot::GetChild"); return reinterpret_cast<const HeapGraphEdge*>( &ToInternal(this)->children()[index]); -#else - return NULL; -#endif } int HeapGraphNode::GetRetainersCount() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetRetainersCount"); + IsDeadCheck("v8::HeapSnapshot::GetRetainersCount"); return ToInternal(this)->retainers().length(); -#else - return 0; -#endif } const HeapGraphEdge* HeapGraphNode::GetRetainer(int index) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetRetainer"); + IsDeadCheck("v8::HeapSnapshot::GetRetainer"); return reinterpret_cast<const HeapGraphEdge*>( ToInternal(this)->retainers()[index]); -#else - return NULL; -#endif +} + + +int HeapGraphNode::GetRetainingPathsCount() const { + IsDeadCheck("v8::HeapSnapshot::GetRetainingPathsCount"); + return ToInternal(this)->GetRetainingPaths()->length(); +} + + +const HeapGraphPath* HeapGraphNode::GetRetainingPath(int index) const { + IsDeadCheck("v8::HeapSnapshot::GetRetainingPath"); + return reinterpret_cast<const HeapGraphPath*>( + ToInternal(this)->GetRetainingPaths()->at(index)); } const HeapGraphNode* HeapGraphNode::GetDominatorNode() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetDominatorNode"); + IsDeadCheck("v8::HeapSnapshot::GetDominatorNode"); return reinterpret_cast<const HeapGraphNode*>(ToInternal(this)->dominator()); -#else - return NULL; -#endif } -#ifdef ENABLE_LOGGING_AND_PROFILING -static i::HeapSnapshot* ToInternal(const HeapSnapshot* snapshot) { - return const_cast<i::HeapSnapshot*>( - reinterpret_cast<const i::HeapSnapshot*>(snapshot)); +const HeapGraphNode* HeapSnapshotsDiff::GetAdditionsRoot() const { + IsDeadCheck("v8::HeapSnapshotsDiff::GetAdditionsRoot"); + i::HeapSnapshotsDiff* diff = + const_cast<i::HeapSnapshotsDiff*>( + reinterpret_cast<const i::HeapSnapshotsDiff*>(this)); + return reinterpret_cast<const HeapGraphNode*>(diff->additions_root()); } -#endif -void HeapSnapshot::Delete() { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::Delete"); - if (i::HeapProfiler::GetSnapshotsCount() > 1) { - ToInternal(this)->Delete(); - } else { - // If this is the last snapshot, clean up all accessory data as well. - i::HeapProfiler::DeleteAllSnapshots(); - } -#endif +const HeapGraphNode* HeapSnapshotsDiff::GetDeletionsRoot() const { + IsDeadCheck("v8::HeapSnapshotsDiff::GetDeletionsRoot"); + i::HeapSnapshotsDiff* diff = + const_cast<i::HeapSnapshotsDiff*>( + reinterpret_cast<const i::HeapSnapshotsDiff*>(this)); + return reinterpret_cast<const HeapGraphNode*>(diff->deletions_root()); +} + + +static i::HeapSnapshot* ToInternal(const HeapSnapshot* snapshot) { + return const_cast<i::HeapSnapshot*>( + reinterpret_cast<const i::HeapSnapshot*>(snapshot)); } HeapSnapshot::Type HeapSnapshot::GetType() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetType"); + IsDeadCheck("v8::HeapSnapshot::GetType"); return static_cast<HeapSnapshot::Type>(ToInternal(this)->type()); -#else - return static_cast<HeapSnapshot::Type>(0); -#endif } unsigned HeapSnapshot::GetUid() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetUid"); + IsDeadCheck("v8::HeapSnapshot::GetUid"); return ToInternal(this)->uid(); -#else - return 0; -#endif } Handle<String> HeapSnapshot::GetTitle() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetTitle"); - return Handle<String>(ToApi<String>(isolate->factory()->LookupAsciiSymbol( + IsDeadCheck("v8::HeapSnapshot::GetTitle"); + return Handle<String>(ToApi<String>(i::Factory::LookupAsciiSymbol( ToInternal(this)->title()))); -#else - return v8::String::Empty(); -#endif } const HeapGraphNode* HeapSnapshot::GetRoot() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetHead"); + IsDeadCheck("v8::HeapSnapshot::GetHead"); return reinterpret_cast<const HeapGraphNode*>(ToInternal(this)->root()); -#else - return 0; -#endif } const HeapGraphNode* HeapSnapshot::GetNodeById(uint64_t id) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetNodeById"); + IsDeadCheck("v8::HeapSnapshot::GetNodeById"); return reinterpret_cast<const HeapGraphNode*>( ToInternal(this)->GetEntryById(id)); -#else - return NULL; -#endif } -int HeapSnapshot::GetNodesCount() const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetNodesCount"); - return ToInternal(this)->entries()->length(); -#else - return 0; -#endif -} - - -const HeapGraphNode* HeapSnapshot::GetNode(int index) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::GetNode"); - return reinterpret_cast<const HeapGraphNode*>( - ToInternal(this)->entries()->at(index)); -#else - return 0; -#endif +const HeapSnapshotsDiff* HeapSnapshot::CompareWith( + const HeapSnapshot* snapshot) const { + IsDeadCheck("v8::HeapSnapshot::CompareWith"); + return reinterpret_cast<const HeapSnapshotsDiff*>( + ToInternal(this)->CompareWith(ToInternal(snapshot))); } void HeapSnapshot::Serialize(OutputStream* stream, HeapSnapshot::SerializationFormat format) const { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapSnapshot::Serialize"); + IsDeadCheck("v8::HeapSnapshot::Serialize"); ApiCheck(format == kJSON, "v8::HeapSnapshot::Serialize", "Unknown serialization format"); @@ -5888,85 +4999,50 @@ void HeapSnapshot::Serialize(OutputStream* stream, "Invalid stream chunk size"); i::HeapSnapshotJSONSerializer serializer(ToInternal(this)); serializer.Serialize(stream); -#endif } int HeapProfiler::GetSnapshotsCount() { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapProfiler::GetSnapshotsCount"); + IsDeadCheck("v8::HeapProfiler::GetSnapshotsCount"); return i::HeapProfiler::GetSnapshotsCount(); -#else - return 0; -#endif } const HeapSnapshot* HeapProfiler::GetSnapshot(int index) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapProfiler::GetSnapshot"); + IsDeadCheck("v8::HeapProfiler::GetSnapshot"); return reinterpret_cast<const HeapSnapshot*>( i::HeapProfiler::GetSnapshot(index)); -#else - return NULL; -#endif } const HeapSnapshot* HeapProfiler::FindSnapshot(unsigned uid) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapProfiler::FindSnapshot"); + IsDeadCheck("v8::HeapProfiler::FindSnapshot"); return reinterpret_cast<const HeapSnapshot*>( i::HeapProfiler::FindSnapshot(uid)); -#else - return NULL; -#endif } const HeapSnapshot* HeapProfiler::TakeSnapshot(Handle<String> title, HeapSnapshot::Type type, ActivityControl* control) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapProfiler::TakeSnapshot"); + IsDeadCheck("v8::HeapProfiler::TakeSnapshot"); i::HeapSnapshot::Type internal_type = i::HeapSnapshot::kFull; switch (type) { case HeapSnapshot::kFull: internal_type = i::HeapSnapshot::kFull; break; + case HeapSnapshot::kAggregated: + internal_type = i::HeapSnapshot::kAggregated; + break; default: UNREACHABLE(); } return reinterpret_cast<const HeapSnapshot*>( i::HeapProfiler::TakeSnapshot( *Utils::OpenHandle(*title), internal_type, control)); -#else - return NULL; -#endif -} - - -void HeapProfiler::DeleteAllSnapshots() { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate* isolate = i::Isolate::Current(); - IsDeadCheck(isolate, "v8::HeapProfiler::DeleteAllSnapshots"); - i::HeapProfiler::DeleteAllSnapshots(); -#endif -} - - -void HeapProfiler::DefineWrapperClass(uint16_t class_id, - WrapperInfoCallback callback) { -#ifdef ENABLE_LOGGING_AND_PROFILING - i::Isolate::Current()->heap_profiler()->DefineWrapperClass(class_id, - callback); -#endif } +#endif // ENABLE_LOGGING_AND_PROFILING v8::Testing::StressType internal::Testing::stress_type_ = @@ -6030,22 +5106,27 @@ void Testing::PrepareStressRun(int run) { } -void Testing::DeoptimizeAll() { - internal::Deoptimizer::DeoptimizeAll(); -} +namespace internal { -namespace internal { +HandleScopeImplementer* HandleScopeImplementer::instance() { + return &thread_local; +} void HandleScopeImplementer::FreeThreadResources() { - Free(); + thread_local.Free(); } char* HandleScopeImplementer::ArchiveThread(char* storage) { + return thread_local.ArchiveThreadHelper(storage); +} + + +char* HandleScopeImplementer::ArchiveThreadHelper(char* storage) { v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); + v8::ImplementationUtilities::CurrentHandleScope(); handle_scope_data_ = *current; memcpy(storage, this, sizeof(*this)); @@ -6057,13 +5138,18 @@ char* HandleScopeImplementer::ArchiveThread(char* storage) { int HandleScopeImplementer::ArchiveSpacePerThread() { - return sizeof(HandleScopeImplementer); + return sizeof(thread_local); } char* HandleScopeImplementer::RestoreThread(char* storage) { + return thread_local.RestoreThreadHelper(storage); +} + + +char* HandleScopeImplementer::RestoreThreadHelper(char* storage) { memcpy(this, storage, sizeof(*this)); - *isolate_->handle_scope_data() = handle_scope_data_; + *v8::ImplementationUtilities::CurrentHandleScope() = handle_scope_data_; return storage + ArchiveSpacePerThread(); } @@ -6089,16 +5175,16 @@ void HandleScopeImplementer::IterateThis(ObjectVisitor* v) { void HandleScopeImplementer::Iterate(ObjectVisitor* v) { v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); - handle_scope_data_ = *current; - IterateThis(v); + v8::ImplementationUtilities::CurrentHandleScope(); + thread_local.handle_scope_data_ = *current; + thread_local.IterateThis(v); } char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) { - HandleScopeImplementer* scope_implementer = + HandleScopeImplementer* thread_local = reinterpret_cast<HandleScopeImplementer*>(storage); - scope_implementer->IterateThis(v); + thread_local->IterateThis(v); return storage + ArchiveSpacePerThread(); } |