ab3b3bec86
The idea here is to perform the handler lookup in the deoptimizer, and then take the information from the handler table to build the catch handler frame in the deoptimizer. Specifically, we use the pc offset, context location and stack height (in full-code) to tweak the output frame. Sadly, this still requires nasty voodoo for the liveness analyzer so that it keeps variables alive if they are used in the catch handler. Review URL: https://codereview.chromium.org/1416543006 Cr-Commit-Position: refs/heads/master@{#33936}
2875 lines
96 KiB
C++
2875 lines
96 KiB
C++
// Copyright 2012 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "src/isolate.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <fstream> // NOLINT(readability/streams)
|
|
#include <sstream>
|
|
|
|
#include "src/ast/ast.h"
|
|
#include "src/ast/scopeinfo.h"
|
|
#include "src/base/platform/platform.h"
|
|
#include "src/base/sys-info.h"
|
|
#include "src/base/utils/random-number-generator.h"
|
|
#include "src/basic-block-profiler.h"
|
|
#include "src/bootstrapper.h"
|
|
#include "src/codegen.h"
|
|
#include "src/compilation-cache.h"
|
|
#include "src/compilation-statistics.h"
|
|
#include "src/crankshaft/hydrogen.h"
|
|
#include "src/debug/debug.h"
|
|
#include "src/deoptimizer.h"
|
|
#include "src/frames-inl.h"
|
|
#include "src/ic/stub-cache.h"
|
|
#include "src/interpreter/interpreter.h"
|
|
#include "src/isolate-inl.h"
|
|
#include "src/log.h"
|
|
#include "src/messages.h"
|
|
#include "src/profiler/cpu-profiler.h"
|
|
#include "src/profiler/sampler.h"
|
|
#include "src/prototype.h"
|
|
#include "src/regexp/regexp-stack.h"
|
|
#include "src/runtime-profiler.h"
|
|
#include "src/simulator.h"
|
|
#include "src/snapshot/serialize.h"
|
|
#include "src/v8.h"
|
|
#include "src/version.h"
|
|
#include "src/vm-state-inl.h"
|
|
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
base::Atomic32 ThreadId::highest_thread_id_ = 0;
|
|
|
|
int ThreadId::AllocateThreadId() {
|
|
int new_id = base::NoBarrier_AtomicIncrement(&highest_thread_id_, 1);
|
|
return new_id;
|
|
}
|
|
|
|
|
|
int ThreadId::GetCurrentThreadId() {
|
|
int thread_id = base::Thread::GetThreadLocalInt(Isolate::thread_id_key_);
|
|
if (thread_id == 0) {
|
|
thread_id = AllocateThreadId();
|
|
base::Thread::SetThreadLocalInt(Isolate::thread_id_key_, thread_id);
|
|
}
|
|
return thread_id;
|
|
}
|
|
|
|
|
|
ThreadLocalTop::ThreadLocalTop() {
|
|
InitializeInternal();
|
|
}
|
|
|
|
|
|
void ThreadLocalTop::InitializeInternal() {
|
|
c_entry_fp_ = 0;
|
|
c_function_ = 0;
|
|
handler_ = 0;
|
|
#ifdef USE_SIMULATOR
|
|
simulator_ = NULL;
|
|
#endif
|
|
js_entry_sp_ = NULL;
|
|
external_callback_scope_ = NULL;
|
|
current_vm_state_ = EXTERNAL;
|
|
try_catch_handler_ = NULL;
|
|
context_ = NULL;
|
|
thread_id_ = ThreadId::Invalid();
|
|
external_caught_exception_ = false;
|
|
failed_access_check_callback_ = NULL;
|
|
save_context_ = NULL;
|
|
promise_on_stack_ = NULL;
|
|
|
|
// These members are re-initialized later after deserialization
|
|
// is complete.
|
|
pending_exception_ = NULL;
|
|
rethrowing_message_ = false;
|
|
pending_message_obj_ = NULL;
|
|
scheduled_exception_ = NULL;
|
|
}
|
|
|
|
|
|
void ThreadLocalTop::Initialize() {
|
|
InitializeInternal();
|
|
#ifdef USE_SIMULATOR
|
|
simulator_ = Simulator::current(isolate_);
|
|
#endif
|
|
thread_id_ = ThreadId::Current();
|
|
}
|
|
|
|
|
|
void ThreadLocalTop::Free() {
|
|
// Match unmatched PopPromise calls.
|
|
while (promise_on_stack_) isolate_->PopPromise();
|
|
}
|
|
|
|
|
|
base::Thread::LocalStorageKey Isolate::isolate_key_;
|
|
base::Thread::LocalStorageKey Isolate::thread_id_key_;
|
|
base::Thread::LocalStorageKey Isolate::per_isolate_thread_data_key_;
|
|
base::LazyMutex Isolate::thread_data_table_mutex_ = LAZY_MUTEX_INITIALIZER;
|
|
Isolate::ThreadDataTable* Isolate::thread_data_table_ = NULL;
|
|
base::Atomic32 Isolate::isolate_counter_ = 0;
|
|
#if DEBUG
|
|
base::Atomic32 Isolate::isolate_key_created_ = 0;
|
|
#endif
|
|
|
|
Isolate::PerIsolateThreadData*
|
|
Isolate::FindOrAllocatePerThreadDataForThisThread() {
|
|
ThreadId thread_id = ThreadId::Current();
|
|
PerIsolateThreadData* per_thread = NULL;
|
|
{
|
|
base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
|
|
per_thread = thread_data_table_->Lookup(this, thread_id);
|
|
if (per_thread == NULL) {
|
|
per_thread = new PerIsolateThreadData(this, thread_id);
|
|
thread_data_table_->Insert(per_thread);
|
|
}
|
|
DCHECK(thread_data_table_->Lookup(this, thread_id) == per_thread);
|
|
}
|
|
return per_thread;
|
|
}
|
|
|
|
|
|
void Isolate::DiscardPerThreadDataForThisThread() {
|
|
int thread_id_int = base::Thread::GetThreadLocalInt(Isolate::thread_id_key_);
|
|
if (thread_id_int) {
|
|
ThreadId thread_id = ThreadId(thread_id_int);
|
|
DCHECK(!thread_manager_->mutex_owner_.Equals(thread_id));
|
|
base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
|
|
PerIsolateThreadData* per_thread =
|
|
thread_data_table_->Lookup(this, thread_id);
|
|
if (per_thread) {
|
|
DCHECK(!per_thread->thread_state_);
|
|
thread_data_table_->Remove(per_thread);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Isolate::PerIsolateThreadData* Isolate::FindPerThreadDataForThisThread() {
|
|
ThreadId thread_id = ThreadId::Current();
|
|
return FindPerThreadDataForThread(thread_id);
|
|
}
|
|
|
|
|
|
Isolate::PerIsolateThreadData* Isolate::FindPerThreadDataForThread(
|
|
ThreadId thread_id) {
|
|
PerIsolateThreadData* per_thread = NULL;
|
|
{
|
|
base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
|
|
per_thread = thread_data_table_->Lookup(this, thread_id);
|
|
}
|
|
return per_thread;
|
|
}
|
|
|
|
|
|
void Isolate::InitializeOncePerProcess() {
|
|
base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
|
|
CHECK(thread_data_table_ == NULL);
|
|
isolate_key_ = base::Thread::CreateThreadLocalKey();
|
|
#if DEBUG
|
|
base::NoBarrier_Store(&isolate_key_created_, 1);
|
|
#endif
|
|
thread_id_key_ = base::Thread::CreateThreadLocalKey();
|
|
per_isolate_thread_data_key_ = base::Thread::CreateThreadLocalKey();
|
|
thread_data_table_ = new Isolate::ThreadDataTable();
|
|
}
|
|
|
|
|
|
Address Isolate::get_address_from_id(Isolate::AddressId id) {
|
|
return isolate_addresses_[id];
|
|
}
|
|
|
|
|
|
char* Isolate::Iterate(ObjectVisitor* v, char* thread_storage) {
|
|
ThreadLocalTop* thread = reinterpret_cast<ThreadLocalTop*>(thread_storage);
|
|
Iterate(v, thread);
|
|
return thread_storage + sizeof(ThreadLocalTop);
|
|
}
|
|
|
|
|
|
void Isolate::IterateThread(ThreadVisitor* v, char* t) {
|
|
ThreadLocalTop* thread = reinterpret_cast<ThreadLocalTop*>(t);
|
|
v->VisitThread(this, thread);
|
|
}
|
|
|
|
|
|
void Isolate::Iterate(ObjectVisitor* v, ThreadLocalTop* thread) {
|
|
// Visit the roots from the top for a given thread.
|
|
v->VisitPointer(&thread->pending_exception_);
|
|
v->VisitPointer(&(thread->pending_message_obj_));
|
|
v->VisitPointer(bit_cast<Object**>(&(thread->context_)));
|
|
v->VisitPointer(&thread->scheduled_exception_);
|
|
|
|
for (v8::TryCatch* block = thread->try_catch_handler();
|
|
block != NULL;
|
|
block = block->next_) {
|
|
v->VisitPointer(bit_cast<Object**>(&(block->exception_)));
|
|
v->VisitPointer(bit_cast<Object**>(&(block->message_obj_)));
|
|
}
|
|
|
|
// Iterate over pointers on native execution stack.
|
|
for (StackFrameIterator it(this, thread); !it.done(); it.Advance()) {
|
|
it.frame()->Iterate(v);
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::Iterate(ObjectVisitor* v) {
|
|
ThreadLocalTop* current_t = thread_local_top();
|
|
Iterate(v, current_t);
|
|
}
|
|
|
|
|
|
void Isolate::IterateDeferredHandles(ObjectVisitor* visitor) {
|
|
for (DeferredHandles* deferred = deferred_handles_head_;
|
|
deferred != NULL;
|
|
deferred = deferred->next_) {
|
|
deferred->Iterate(visitor);
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
bool Isolate::IsDeferredHandle(Object** handle) {
|
|
// Each DeferredHandles instance keeps the handles to one job in the
|
|
// concurrent recompilation queue, containing a list of blocks. Each block
|
|
// contains kHandleBlockSize handles except for the first block, which may
|
|
// not be fully filled.
|
|
// We iterate through all the blocks to see whether the argument handle
|
|
// belongs to one of the blocks. If so, it is deferred.
|
|
for (DeferredHandles* deferred = deferred_handles_head_;
|
|
deferred != NULL;
|
|
deferred = deferred->next_) {
|
|
List<Object**>* blocks = &deferred->blocks_;
|
|
for (int i = 0; i < blocks->length(); i++) {
|
|
Object** block_limit = (i == 0) ? deferred->first_block_limit_
|
|
: blocks->at(i) + kHandleBlockSize;
|
|
if (blocks->at(i) <= handle && handle < block_limit) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
#endif // DEBUG
|
|
|
|
|
|
void Isolate::RegisterTryCatchHandler(v8::TryCatch* that) {
|
|
thread_local_top()->set_try_catch_handler(that);
|
|
}
|
|
|
|
|
|
void Isolate::UnregisterTryCatchHandler(v8::TryCatch* that) {
|
|
DCHECK(thread_local_top()->try_catch_handler() == that);
|
|
thread_local_top()->set_try_catch_handler(that->next_);
|
|
}
|
|
|
|
|
|
Handle<String> Isolate::StackTraceString() {
|
|
if (stack_trace_nesting_level_ == 0) {
|
|
stack_trace_nesting_level_++;
|
|
HeapStringAllocator allocator;
|
|
StringStream::ClearMentionedObjectCache(this);
|
|
StringStream accumulator(&allocator);
|
|
incomplete_message_ = &accumulator;
|
|
PrintStack(&accumulator);
|
|
Handle<String> stack_trace = accumulator.ToString(this);
|
|
incomplete_message_ = NULL;
|
|
stack_trace_nesting_level_ = 0;
|
|
return stack_trace;
|
|
} else if (stack_trace_nesting_level_ == 1) {
|
|
stack_trace_nesting_level_++;
|
|
base::OS::PrintError(
|
|
"\n\nAttempt to print stack while printing stack (double fault)\n");
|
|
base::OS::PrintError(
|
|
"If you are lucky you may find a partial stack dump on stdout.\n\n");
|
|
incomplete_message_->OutputToStdOut();
|
|
return factory()->empty_string();
|
|
} else {
|
|
base::OS::Abort();
|
|
// Unreachable
|
|
return factory()->empty_string();
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::PushStackTraceAndDie(unsigned int magic, void* ptr1, void* ptr2,
|
|
unsigned int magic2) {
|
|
const int kMaxStackTraceSize = 32 * KB;
|
|
Handle<String> trace = StackTraceString();
|
|
uint8_t buffer[kMaxStackTraceSize];
|
|
int length = Min(kMaxStackTraceSize - 1, trace->length());
|
|
String::WriteToFlat(*trace, buffer, 0, length);
|
|
buffer[length] = '\0';
|
|
// TODO(dcarney): convert buffer to utf8?
|
|
base::OS::PrintError("Stacktrace (%x-%x) %p %p: %s\n", magic, magic2, ptr1,
|
|
ptr2, reinterpret_cast<char*>(buffer));
|
|
base::OS::Abort();
|
|
}
|
|
|
|
|
|
// Determines whether the given stack frame should be displayed in
|
|
// a stack trace. The caller is the error constructor that asked
|
|
// for the stack trace to be collected. The first time a construct
|
|
// call to this function is encountered it is skipped. The seen_caller
|
|
// in/out parameter is used to remember if the caller has been seen
|
|
// yet.
|
|
static bool IsVisibleInStackTrace(JSFunction* fun,
|
|
Object* caller,
|
|
Object* receiver,
|
|
bool* seen_caller) {
|
|
if ((fun == caller) && !(*seen_caller)) {
|
|
*seen_caller = true;
|
|
return false;
|
|
}
|
|
// Skip all frames until we've seen the caller.
|
|
if (!(*seen_caller)) return false;
|
|
// Functions defined in native scripts are not visible unless directly
|
|
// exposed, in which case the native flag is set.
|
|
// The --builtins-in-stack-traces command line flag allows including
|
|
// internal call sites in the stack trace for debugging purposes.
|
|
if (!FLAG_builtins_in_stack_traces && fun->shared()->IsBuiltin()) {
|
|
return fun->shared()->native();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
Handle<Object> Isolate::CaptureSimpleStackTrace(Handle<JSObject> error_object,
|
|
Handle<Object> caller) {
|
|
// Get stack trace limit.
|
|
Handle<JSObject> error = error_function();
|
|
Handle<String> stackTraceLimit =
|
|
factory()->InternalizeUtf8String("stackTraceLimit");
|
|
DCHECK(!stackTraceLimit.is_null());
|
|
Handle<Object> stack_trace_limit =
|
|
JSReceiver::GetDataProperty(error, stackTraceLimit);
|
|
if (!stack_trace_limit->IsNumber()) return factory()->undefined_value();
|
|
int limit = FastD2IChecked(stack_trace_limit->Number());
|
|
limit = Max(limit, 0); // Ensure that limit is not negative.
|
|
|
|
int initial_size = Min(limit, 10);
|
|
Handle<FixedArray> elements =
|
|
factory()->NewFixedArrayWithHoles(initial_size * 4 + 1);
|
|
|
|
// If the caller parameter is a function we skip frames until we're
|
|
// under it before starting to collect.
|
|
bool seen_caller = !caller->IsJSFunction();
|
|
// First element is reserved to store the number of sloppy frames.
|
|
int cursor = 1;
|
|
int frames_seen = 0;
|
|
int sloppy_frames = 0;
|
|
bool encountered_strict_function = false;
|
|
for (JavaScriptFrameIterator iter(this);
|
|
!iter.done() && frames_seen < limit;
|
|
iter.Advance()) {
|
|
JavaScriptFrame* frame = iter.frame();
|
|
// Set initial size to the maximum inlining level + 1 for the outermost
|
|
// function.
|
|
List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
|
|
frame->Summarize(&frames);
|
|
for (int i = frames.length() - 1; i >= 0; i--) {
|
|
Handle<JSFunction> fun = frames[i].function();
|
|
Handle<Object> recv = frames[i].receiver();
|
|
// Filter out internal frames that we do not want to show.
|
|
if (!IsVisibleInStackTrace(*fun, *caller, *recv, &seen_caller)) continue;
|
|
// Filter out frames from other security contexts.
|
|
if (!this->context()->HasSameSecurityTokenAs(fun->context())) continue;
|
|
if (cursor + 4 > elements->length()) {
|
|
int new_capacity = JSObject::NewElementsCapacity(elements->length());
|
|
Handle<FixedArray> new_elements =
|
|
factory()->NewFixedArrayWithHoles(new_capacity);
|
|
for (int i = 0; i < cursor; i++) {
|
|
new_elements->set(i, elements->get(i));
|
|
}
|
|
elements = new_elements;
|
|
}
|
|
DCHECK(cursor + 4 <= elements->length());
|
|
|
|
Handle<AbstractCode> abstract_code = frames[i].abstract_code();
|
|
|
|
Handle<Smi> offset(Smi::FromInt(frames[i].code_offset()), this);
|
|
// The stack trace API should not expose receivers and function
|
|
// objects on frames deeper than the top-most one with a strict
|
|
// mode function. The number of sloppy frames is stored as
|
|
// first element in the result array.
|
|
if (!encountered_strict_function) {
|
|
if (is_strict(fun->shared()->language_mode())) {
|
|
encountered_strict_function = true;
|
|
} else {
|
|
sloppy_frames++;
|
|
}
|
|
}
|
|
elements->set(cursor++, *recv);
|
|
elements->set(cursor++, *fun);
|
|
elements->set(cursor++, *abstract_code);
|
|
elements->set(cursor++, *offset);
|
|
frames_seen++;
|
|
}
|
|
}
|
|
elements->set(0, Smi::FromInt(sloppy_frames));
|
|
elements->Shrink(cursor);
|
|
Handle<JSArray> result = factory()->NewJSArrayWithElements(elements);
|
|
result->set_length(Smi::FromInt(cursor));
|
|
// TODO(yangguo): Queue this structured stack trace for preprocessing on GC.
|
|
return result;
|
|
}
|
|
|
|
|
|
MaybeHandle<JSObject> Isolate::CaptureAndSetDetailedStackTrace(
|
|
Handle<JSObject> error_object) {
|
|
if (capture_stack_trace_for_uncaught_exceptions_) {
|
|
// Capture stack trace for a detailed exception message.
|
|
Handle<Name> key = factory()->detailed_stack_trace_symbol();
|
|
Handle<JSArray> stack_trace = CaptureCurrentStackTrace(
|
|
stack_trace_for_uncaught_exceptions_frame_limit_,
|
|
stack_trace_for_uncaught_exceptions_options_);
|
|
RETURN_ON_EXCEPTION(
|
|
this, JSObject::SetProperty(error_object, key, stack_trace, STRICT),
|
|
JSObject);
|
|
}
|
|
return error_object;
|
|
}
|
|
|
|
|
|
MaybeHandle<JSObject> Isolate::CaptureAndSetSimpleStackTrace(
|
|
Handle<JSObject> error_object, Handle<Object> caller) {
|
|
// Capture stack trace for simple stack trace string formatting.
|
|
Handle<Name> key = factory()->stack_trace_symbol();
|
|
Handle<Object> stack_trace = CaptureSimpleStackTrace(error_object, caller);
|
|
RETURN_ON_EXCEPTION(
|
|
this, JSObject::SetProperty(error_object, key, stack_trace, STRICT),
|
|
JSObject);
|
|
return error_object;
|
|
}
|
|
|
|
|
|
Handle<JSArray> Isolate::GetDetailedStackTrace(Handle<JSObject> error_object) {
|
|
Handle<Name> key_detailed = factory()->detailed_stack_trace_symbol();
|
|
Handle<Object> stack_trace =
|
|
JSReceiver::GetDataProperty(error_object, key_detailed);
|
|
if (stack_trace->IsJSArray()) return Handle<JSArray>::cast(stack_trace);
|
|
|
|
if (!capture_stack_trace_for_uncaught_exceptions_) return Handle<JSArray>();
|
|
|
|
// Try to get details from simple stack trace.
|
|
Handle<JSArray> detailed_stack_trace =
|
|
GetDetailedFromSimpleStackTrace(error_object);
|
|
if (!detailed_stack_trace.is_null()) {
|
|
// Save the detailed stack since the simple one might be withdrawn later.
|
|
JSObject::SetProperty(error_object, key_detailed, detailed_stack_trace,
|
|
STRICT).Assert();
|
|
}
|
|
return detailed_stack_trace;
|
|
}
|
|
|
|
|
|
class CaptureStackTraceHelper {
|
|
public:
|
|
CaptureStackTraceHelper(Isolate* isolate,
|
|
StackTrace::StackTraceOptions options)
|
|
: isolate_(isolate) {
|
|
if (options & StackTrace::kColumnOffset) {
|
|
column_key_ =
|
|
factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("column"));
|
|
}
|
|
if (options & StackTrace::kLineNumber) {
|
|
line_key_ =
|
|
factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("lineNumber"));
|
|
}
|
|
if (options & StackTrace::kScriptId) {
|
|
script_id_key_ =
|
|
factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptId"));
|
|
}
|
|
if (options & StackTrace::kScriptName) {
|
|
script_name_key_ =
|
|
factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptName"));
|
|
}
|
|
if (options & StackTrace::kScriptNameOrSourceURL) {
|
|
script_name_or_source_url_key_ = factory()->InternalizeOneByteString(
|
|
STATIC_CHAR_VECTOR("scriptNameOrSourceURL"));
|
|
}
|
|
if (options & StackTrace::kFunctionName) {
|
|
function_key_ = factory()->InternalizeOneByteString(
|
|
STATIC_CHAR_VECTOR("functionName"));
|
|
}
|
|
if (options & StackTrace::kIsEval) {
|
|
eval_key_ =
|
|
factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("isEval"));
|
|
}
|
|
if (options & StackTrace::kIsConstructor) {
|
|
constructor_key_ = factory()->InternalizeOneByteString(
|
|
STATIC_CHAR_VECTOR("isConstructor"));
|
|
}
|
|
}
|
|
|
|
Handle<JSObject> NewStackFrameObject(Handle<JSFunction> fun, int position,
|
|
bool is_constructor) {
|
|
Handle<JSObject> stack_frame =
|
|
factory()->NewJSObject(isolate_->object_function());
|
|
|
|
Handle<Script> script(Script::cast(fun->shared()->script()));
|
|
|
|
if (!line_key_.is_null()) {
|
|
int script_line_offset = script->line_offset();
|
|
int line_number = Script::GetLineNumber(script, position);
|
|
// line_number is already shifted by the script_line_offset.
|
|
int relative_line_number = line_number - script_line_offset;
|
|
if (!column_key_.is_null() && relative_line_number >= 0) {
|
|
Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
|
|
int start = (relative_line_number == 0) ? 0 :
|
|
Smi::cast(line_ends->get(relative_line_number - 1))->value() + 1;
|
|
int column_offset = position - start;
|
|
if (relative_line_number == 0) {
|
|
// For the case where the code is on the same line as the script
|
|
// tag.
|
|
column_offset += script->column_offset();
|
|
}
|
|
JSObject::AddProperty(stack_frame, column_key_,
|
|
handle(Smi::FromInt(column_offset + 1), isolate_),
|
|
NONE);
|
|
}
|
|
JSObject::AddProperty(stack_frame, line_key_,
|
|
handle(Smi::FromInt(line_number + 1), isolate_),
|
|
NONE);
|
|
}
|
|
|
|
if (!script_id_key_.is_null()) {
|
|
JSObject::AddProperty(stack_frame, script_id_key_,
|
|
handle(Smi::FromInt(script->id()), isolate_), NONE);
|
|
}
|
|
|
|
if (!script_name_key_.is_null()) {
|
|
JSObject::AddProperty(stack_frame, script_name_key_,
|
|
handle(script->name(), isolate_), NONE);
|
|
}
|
|
|
|
if (!script_name_or_source_url_key_.is_null()) {
|
|
Handle<Object> result = Script::GetNameOrSourceURL(script);
|
|
JSObject::AddProperty(stack_frame, script_name_or_source_url_key_, result,
|
|
NONE);
|
|
}
|
|
|
|
if (!function_key_.is_null()) {
|
|
Handle<Object> fun_name = JSFunction::GetDebugName(fun);
|
|
JSObject::AddProperty(stack_frame, function_key_, fun_name, NONE);
|
|
}
|
|
|
|
if (!eval_key_.is_null()) {
|
|
Handle<Object> is_eval = factory()->ToBoolean(
|
|
script->compilation_type() == Script::COMPILATION_TYPE_EVAL);
|
|
JSObject::AddProperty(stack_frame, eval_key_, is_eval, NONE);
|
|
}
|
|
|
|
if (!constructor_key_.is_null()) {
|
|
Handle<Object> is_constructor_obj = factory()->ToBoolean(is_constructor);
|
|
JSObject::AddProperty(stack_frame, constructor_key_, is_constructor_obj,
|
|
NONE);
|
|
}
|
|
|
|
return stack_frame;
|
|
}
|
|
|
|
private:
|
|
inline Factory* factory() { return isolate_->factory(); }
|
|
|
|
Isolate* isolate_;
|
|
Handle<String> column_key_;
|
|
Handle<String> line_key_;
|
|
Handle<String> script_id_key_;
|
|
Handle<String> script_name_key_;
|
|
Handle<String> script_name_or_source_url_key_;
|
|
Handle<String> function_key_;
|
|
Handle<String> eval_key_;
|
|
Handle<String> constructor_key_;
|
|
};
|
|
|
|
|
|
int PositionFromStackTrace(Handle<FixedArray> elements, int index) {
|
|
DisallowHeapAllocation no_gc;
|
|
Object* maybe_code = elements->get(index + 2);
|
|
if (maybe_code->IsSmi()) {
|
|
return Smi::cast(maybe_code)->value();
|
|
} else {
|
|
AbstractCode* abstract_code = AbstractCode::cast(maybe_code);
|
|
int code_offset = Smi::cast(elements->get(index + 3))->value();
|
|
return abstract_code->SourcePosition(code_offset);
|
|
}
|
|
}
|
|
|
|
|
|
Handle<JSArray> Isolate::GetDetailedFromSimpleStackTrace(
|
|
Handle<JSObject> error_object) {
|
|
Handle<Name> key = factory()->stack_trace_symbol();
|
|
Handle<Object> property = JSReceiver::GetDataProperty(error_object, key);
|
|
if (!property->IsJSArray()) return Handle<JSArray>();
|
|
Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
|
|
|
|
CaptureStackTraceHelper helper(this,
|
|
stack_trace_for_uncaught_exceptions_options_);
|
|
|
|
int frames_seen = 0;
|
|
Handle<FixedArray> elements(FixedArray::cast(simple_stack_trace->elements()));
|
|
int elements_limit = Smi::cast(simple_stack_trace->length())->value();
|
|
|
|
int frame_limit = stack_trace_for_uncaught_exceptions_frame_limit_;
|
|
if (frame_limit < 0) frame_limit = (elements_limit - 1) / 4;
|
|
|
|
Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
|
|
for (int i = 1; i < elements_limit && frames_seen < frame_limit; i += 4) {
|
|
Handle<Object> recv = handle(elements->get(i), this);
|
|
Handle<JSFunction> fun =
|
|
handle(JSFunction::cast(elements->get(i + 1)), this);
|
|
bool is_constructor =
|
|
recv->IsJSObject() &&
|
|
Handle<JSObject>::cast(recv)->map()->GetConstructor() == *fun;
|
|
int position = PositionFromStackTrace(elements, i);
|
|
|
|
Handle<JSObject> stack_frame =
|
|
helper.NewStackFrameObject(fun, position, is_constructor);
|
|
|
|
FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
|
|
frames_seen++;
|
|
}
|
|
|
|
stack_trace->set_length(Smi::FromInt(frames_seen));
|
|
return stack_trace;
|
|
}
|
|
|
|
|
|
Handle<JSArray> Isolate::CaptureCurrentStackTrace(
|
|
int frame_limit, StackTrace::StackTraceOptions options) {
|
|
CaptureStackTraceHelper helper(this, options);
|
|
|
|
// Ensure no negative values.
|
|
int limit = Max(frame_limit, 0);
|
|
Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
|
|
|
|
StackTraceFrameIterator it(this);
|
|
int frames_seen = 0;
|
|
while (!it.done() && (frames_seen < limit)) {
|
|
JavaScriptFrame* frame = it.frame();
|
|
// Set initial size to the maximum inlining level + 1 for the outermost
|
|
// function.
|
|
List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
|
|
frame->Summarize(&frames);
|
|
for (int i = frames.length() - 1; i >= 0 && frames_seen < limit; i--) {
|
|
Handle<JSFunction> fun = frames[i].function();
|
|
// Filter frames from other security contexts.
|
|
if (!(options & StackTrace::kExposeFramesAcrossSecurityOrigins) &&
|
|
!this->context()->HasSameSecurityTokenAs(fun->context())) continue;
|
|
int position =
|
|
frames[i].abstract_code()->SourcePosition(frames[i].code_offset());
|
|
Handle<JSObject> stack_frame =
|
|
helper.NewStackFrameObject(fun, position, frames[i].is_constructor());
|
|
|
|
FixedArray::cast(stack_trace->elements())->set(frames_seen, *stack_frame);
|
|
frames_seen++;
|
|
}
|
|
it.Advance();
|
|
}
|
|
|
|
stack_trace->set_length(Smi::FromInt(frames_seen));
|
|
return stack_trace;
|
|
}
|
|
|
|
|
|
void Isolate::PrintStack(FILE* out, PrintStackMode mode) {
|
|
if (stack_trace_nesting_level_ == 0) {
|
|
stack_trace_nesting_level_++;
|
|
StringStream::ClearMentionedObjectCache(this);
|
|
HeapStringAllocator allocator;
|
|
StringStream accumulator(&allocator);
|
|
incomplete_message_ = &accumulator;
|
|
PrintStack(&accumulator, mode);
|
|
accumulator.OutputToFile(out);
|
|
InitializeLoggingAndCounters();
|
|
accumulator.Log(this);
|
|
incomplete_message_ = NULL;
|
|
stack_trace_nesting_level_ = 0;
|
|
} else if (stack_trace_nesting_level_ == 1) {
|
|
stack_trace_nesting_level_++;
|
|
base::OS::PrintError(
|
|
"\n\nAttempt to print stack while printing stack (double fault)\n");
|
|
base::OS::PrintError(
|
|
"If you are lucky you may find a partial stack dump on stdout.\n\n");
|
|
incomplete_message_->OutputToFile(out);
|
|
}
|
|
}
|
|
|
|
|
|
static void PrintFrames(Isolate* isolate,
|
|
StringStream* accumulator,
|
|
StackFrame::PrintMode mode) {
|
|
StackFrameIterator it(isolate);
|
|
for (int i = 0; !it.done(); it.Advance()) {
|
|
it.frame()->Print(accumulator, mode, i++);
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::PrintStack(StringStream* accumulator, PrintStackMode mode) {
|
|
// The MentionedObjectCache is not GC-proof at the moment.
|
|
DisallowHeapAllocation no_gc;
|
|
DCHECK(accumulator->IsMentionedObjectCacheClear(this));
|
|
|
|
// Avoid printing anything if there are no frames.
|
|
if (c_entry_fp(thread_local_top()) == 0) return;
|
|
|
|
accumulator->Add(
|
|
"\n==== JS stack trace =========================================\n\n");
|
|
PrintFrames(this, accumulator, StackFrame::OVERVIEW);
|
|
if (mode == kPrintStackVerbose) {
|
|
accumulator->Add(
|
|
"\n==== Details ================================================\n\n");
|
|
PrintFrames(this, accumulator, StackFrame::DETAILS);
|
|
accumulator->PrintMentionedObjectCache(this);
|
|
}
|
|
accumulator->Add("=====================\n\n");
|
|
}
|
|
|
|
|
|
void Isolate::SetFailedAccessCheckCallback(
|
|
v8::FailedAccessCheckCallback callback) {
|
|
thread_local_top()->failed_access_check_callback_ = callback;
|
|
}
|
|
|
|
|
|
static inline AccessCheckInfo* GetAccessCheckInfo(Isolate* isolate,
|
|
Handle<JSObject> receiver) {
|
|
Object* maybe_constructor = receiver->map()->GetConstructor();
|
|
if (!maybe_constructor->IsJSFunction()) return NULL;
|
|
JSFunction* constructor = JSFunction::cast(maybe_constructor);
|
|
if (!constructor->shared()->IsApiFunction()) return NULL;
|
|
|
|
Object* data_obj =
|
|
constructor->shared()->get_api_func_data()->access_check_info();
|
|
if (data_obj == isolate->heap()->undefined_value()) return NULL;
|
|
|
|
return AccessCheckInfo::cast(data_obj);
|
|
}
|
|
|
|
|
|
void Isolate::ReportFailedAccessCheck(Handle<JSObject> receiver) {
|
|
if (!thread_local_top()->failed_access_check_callback_) {
|
|
return ScheduleThrow(*factory()->NewTypeError(MessageTemplate::kNoAccess));
|
|
}
|
|
|
|
DCHECK(receiver->IsAccessCheckNeeded());
|
|
DCHECK(context());
|
|
|
|
// Get the data object from access check info.
|
|
HandleScope scope(this);
|
|
Handle<Object> data;
|
|
{ DisallowHeapAllocation no_gc;
|
|
AccessCheckInfo* access_check_info = GetAccessCheckInfo(this, receiver);
|
|
if (!access_check_info) {
|
|
AllowHeapAllocation doesnt_matter_anymore;
|
|
return ScheduleThrow(
|
|
*factory()->NewTypeError(MessageTemplate::kNoAccess));
|
|
}
|
|
data = handle(access_check_info->data(), this);
|
|
}
|
|
|
|
// Leaving JavaScript.
|
|
VMState<EXTERNAL> state(this);
|
|
thread_local_top()->failed_access_check_callback_(
|
|
v8::Utils::ToLocal(receiver), v8::ACCESS_HAS, v8::Utils::ToLocal(data));
|
|
}
|
|
|
|
|
|
bool Isolate::IsInternallyUsedPropertyName(Handle<Object> name) {
|
|
if (name->IsSymbol()) {
|
|
return Handle<Symbol>::cast(name)->is_private();
|
|
}
|
|
return name.is_identical_to(factory()->hidden_string());
|
|
}
|
|
|
|
|
|
bool Isolate::MayAccess(Handle<Context> accessing_context,
|
|
Handle<JSObject> receiver) {
|
|
DCHECK(receiver->IsJSGlobalProxy() || receiver->IsAccessCheckNeeded());
|
|
|
|
// Check for compatibility between the security tokens in the
|
|
// current lexical context and the accessed object.
|
|
|
|
// During bootstrapping, callback functions are not enabled yet.
|
|
if (bootstrapper()->IsActive()) return true;
|
|
{
|
|
DisallowHeapAllocation no_gc;
|
|
|
|
if (receiver->IsJSGlobalProxy()) {
|
|
Object* receiver_context =
|
|
JSGlobalProxy::cast(*receiver)->native_context();
|
|
if (!receiver_context->IsContext()) return false;
|
|
|
|
// Get the native context of current top context.
|
|
// avoid using Isolate::native_context() because it uses Handle.
|
|
Context* native_context =
|
|
accessing_context->global_object()->native_context();
|
|
if (receiver_context == native_context) return true;
|
|
|
|
if (Context::cast(receiver_context)->security_token() ==
|
|
native_context->security_token())
|
|
return true;
|
|
}
|
|
}
|
|
|
|
HandleScope scope(this);
|
|
Handle<Object> data;
|
|
v8::AccessCheckCallback callback = nullptr;
|
|
v8::NamedSecurityCallback named_callback = nullptr;
|
|
{ DisallowHeapAllocation no_gc;
|
|
AccessCheckInfo* access_check_info = GetAccessCheckInfo(this, receiver);
|
|
if (!access_check_info) return false;
|
|
Object* fun_obj = access_check_info->callback();
|
|
callback = v8::ToCData<v8::AccessCheckCallback>(fun_obj);
|
|
data = handle(access_check_info->data(), this);
|
|
if (!callback) {
|
|
fun_obj = access_check_info->named_callback();
|
|
named_callback = v8::ToCData<v8::NamedSecurityCallback>(fun_obj);
|
|
if (!named_callback) return false;
|
|
}
|
|
}
|
|
|
|
LOG(this, ApiSecurityCheck());
|
|
|
|
{
|
|
// Leaving JavaScript.
|
|
VMState<EXTERNAL> state(this);
|
|
if (callback) {
|
|
return callback(v8::Utils::ToLocal(accessing_context),
|
|
v8::Utils::ToLocal(receiver), v8::Utils::ToLocal(data));
|
|
}
|
|
Handle<Object> key = factory()->undefined_value();
|
|
return named_callback(v8::Utils::ToLocal(receiver), v8::Utils::ToLocal(key),
|
|
v8::ACCESS_HAS, v8::Utils::ToLocal(data));
|
|
}
|
|
}
|
|
|
|
|
|
const char* const Isolate::kStackOverflowMessage =
|
|
"Uncaught RangeError: Maximum call stack size exceeded";
|
|
|
|
|
|
Object* Isolate::StackOverflow() {
|
|
HandleScope scope(this);
|
|
// At this point we cannot create an Error object using its javascript
|
|
// constructor. Instead, we copy the pre-constructed boilerplate and
|
|
// attach the stack trace as a hidden property.
|
|
Handle<Object> exception;
|
|
if (bootstrapper()->IsActive()) {
|
|
// There is no boilerplate to use during bootstrapping.
|
|
exception = factory()->NewStringFromAsciiChecked(
|
|
MessageTemplate::TemplateString(MessageTemplate::kStackOverflow));
|
|
} else {
|
|
Handle<JSObject> boilerplate = stack_overflow_boilerplate();
|
|
Handle<JSObject> copy = factory()->CopyJSObject(boilerplate);
|
|
CaptureAndSetSimpleStackTrace(copy, factory()->undefined_value());
|
|
exception = copy;
|
|
}
|
|
Throw(*exception, nullptr);
|
|
|
|
#ifdef VERIFY_HEAP
|
|
if (FLAG_verify_heap && FLAG_stress_compaction) {
|
|
heap()->CollectAllAvailableGarbage("trigger compaction");
|
|
}
|
|
#endif // VERIFY_HEAP
|
|
|
|
return heap()->exception();
|
|
}
|
|
|
|
|
|
Object* Isolate::TerminateExecution() {
|
|
return Throw(heap_.termination_exception(), nullptr);
|
|
}
|
|
|
|
|
|
void Isolate::CancelTerminateExecution() {
|
|
if (try_catch_handler()) {
|
|
try_catch_handler()->has_terminated_ = false;
|
|
}
|
|
if (has_pending_exception() &&
|
|
pending_exception() == heap_.termination_exception()) {
|
|
thread_local_top()->external_caught_exception_ = false;
|
|
clear_pending_exception();
|
|
}
|
|
if (has_scheduled_exception() &&
|
|
scheduled_exception() == heap_.termination_exception()) {
|
|
thread_local_top()->external_caught_exception_ = false;
|
|
clear_scheduled_exception();
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::RequestInterrupt(InterruptCallback callback, void* data) {
|
|
ExecutionAccess access(this);
|
|
api_interrupts_queue_.push(InterruptEntry(callback, data));
|
|
stack_guard()->RequestApiInterrupt();
|
|
}
|
|
|
|
|
|
void Isolate::InvokeApiInterruptCallbacks() {
|
|
// Note: callback below should be called outside of execution access lock.
|
|
while (true) {
|
|
InterruptEntry entry;
|
|
{
|
|
ExecutionAccess access(this);
|
|
if (api_interrupts_queue_.empty()) return;
|
|
entry = api_interrupts_queue_.front();
|
|
api_interrupts_queue_.pop();
|
|
}
|
|
VMState<EXTERNAL> state(this);
|
|
HandleScope handle_scope(this);
|
|
entry.first(reinterpret_cast<v8::Isolate*>(this), entry.second);
|
|
}
|
|
}
|
|
|
|
|
|
void ReportBootstrappingException(Handle<Object> exception,
|
|
MessageLocation* location) {
|
|
base::OS::PrintError("Exception thrown during bootstrapping\n");
|
|
if (location == NULL || location->script().is_null()) return;
|
|
// We are bootstrapping and caught an error where the location is set
|
|
// and we have a script for the location.
|
|
// In this case we could have an extension (or an internal error
|
|
// somewhere) and we print out the line number at which the error occured
|
|
// to the console for easier debugging.
|
|
int line_number =
|
|
location->script()->GetLineNumber(location->start_pos()) + 1;
|
|
if (exception->IsString() && location->script()->name()->IsString()) {
|
|
base::OS::PrintError(
|
|
"Extension or internal compilation error: %s in %s at line %d.\n",
|
|
String::cast(*exception)->ToCString().get(),
|
|
String::cast(location->script()->name())->ToCString().get(),
|
|
line_number);
|
|
} else if (location->script()->name()->IsString()) {
|
|
base::OS::PrintError(
|
|
"Extension or internal compilation error in %s at line %d.\n",
|
|
String::cast(location->script()->name())->ToCString().get(),
|
|
line_number);
|
|
} else if (exception->IsString()) {
|
|
base::OS::PrintError("Extension or internal compilation error: %s.\n",
|
|
String::cast(*exception)->ToCString().get());
|
|
} else {
|
|
base::OS::PrintError("Extension or internal compilation error.\n");
|
|
}
|
|
#ifdef OBJECT_PRINT
|
|
// Since comments and empty lines have been stripped from the source of
|
|
// builtins, print the actual source here so that line numbers match.
|
|
if (location->script()->source()->IsString()) {
|
|
Handle<String> src(String::cast(location->script()->source()));
|
|
PrintF("Failing script:");
|
|
int len = src->length();
|
|
if (len == 0) {
|
|
PrintF(" <not available>\n");
|
|
} else {
|
|
PrintF("\n");
|
|
int line_number = 1;
|
|
PrintF("%5d: ", line_number);
|
|
for (int i = 0; i < len; i++) {
|
|
uint16_t character = src->Get(i);
|
|
PrintF("%c", character);
|
|
if (character == '\n' && i < len - 2) {
|
|
PrintF("%5d: ", ++line_number);
|
|
}
|
|
}
|
|
PrintF("\n");
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
Object* Isolate::Throw(Object* exception, MessageLocation* location) {
|
|
DCHECK(!has_pending_exception());
|
|
|
|
HandleScope scope(this);
|
|
Handle<Object> exception_handle(exception, this);
|
|
|
|
// Determine whether a message needs to be created for the given exception
|
|
// depending on the following criteria:
|
|
// 1) External v8::TryCatch missing: Always create a message because any
|
|
// JavaScript handler for a finally-block might re-throw to top-level.
|
|
// 2) External v8::TryCatch exists: Only create a message if the handler
|
|
// captures messages or is verbose (which reports despite the catch).
|
|
// 3) ReThrow from v8::TryCatch: The message from a previous throw still
|
|
// exists and we preserve it instead of creating a new message.
|
|
bool requires_message = try_catch_handler() == nullptr ||
|
|
try_catch_handler()->is_verbose_ ||
|
|
try_catch_handler()->capture_message_;
|
|
bool rethrowing_message = thread_local_top()->rethrowing_message_;
|
|
|
|
thread_local_top()->rethrowing_message_ = false;
|
|
|
|
// Notify debugger of exception.
|
|
if (is_catchable_by_javascript(exception)) {
|
|
debug()->OnThrow(exception_handle);
|
|
}
|
|
|
|
// Generate the message if required.
|
|
if (requires_message && !rethrowing_message) {
|
|
MessageLocation computed_location;
|
|
// If no location was specified we try to use a computed one instead.
|
|
if (location == NULL && ComputeLocation(&computed_location)) {
|
|
location = &computed_location;
|
|
}
|
|
|
|
if (bootstrapper()->IsActive()) {
|
|
// It's not safe to try to make message objects or collect stack traces
|
|
// while the bootstrapper is active since the infrastructure may not have
|
|
// been properly initialized.
|
|
ReportBootstrappingException(exception_handle, location);
|
|
} else {
|
|
Handle<Object> message_obj = CreateMessage(exception_handle, location);
|
|
thread_local_top()->pending_message_obj_ = *message_obj;
|
|
|
|
// For any exception not caught by JavaScript, even when an external
|
|
// handler is present:
|
|
// If the abort-on-uncaught-exception flag is specified, and if the
|
|
// embedder didn't specify a custom uncaught exception callback,
|
|
// or if the custom callback determined that V8 should abort, then
|
|
// abort.
|
|
if (FLAG_abort_on_uncaught_exception &&
|
|
PredictExceptionCatcher() != CAUGHT_BY_JAVASCRIPT &&
|
|
(!abort_on_uncaught_exception_callback_ ||
|
|
abort_on_uncaught_exception_callback_(
|
|
reinterpret_cast<v8::Isolate*>(this)))) {
|
|
// Prevent endless recursion.
|
|
FLAG_abort_on_uncaught_exception = false;
|
|
// This flag is intended for use by JavaScript developers, so
|
|
// print a user-friendly stack trace (not an internal one).
|
|
PrintF(stderr, "%s\n\nFROM\n",
|
|
MessageHandler::GetLocalizedMessage(this, message_obj).get());
|
|
PrintCurrentStackTrace(stderr);
|
|
base::OS::Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the exception being thrown.
|
|
set_pending_exception(*exception_handle);
|
|
return heap()->exception();
|
|
}
|
|
|
|
|
|
Object* Isolate::ReThrow(Object* exception) {
|
|
DCHECK(!has_pending_exception());
|
|
|
|
// Set the exception being re-thrown.
|
|
set_pending_exception(exception);
|
|
return heap()->exception();
|
|
}
|
|
|
|
|
|
Object* Isolate::UnwindAndFindHandler() {
|
|
Object* exception = pending_exception();
|
|
|
|
Code* code = nullptr;
|
|
Context* context = nullptr;
|
|
intptr_t offset = 0;
|
|
Address handler_sp = nullptr;
|
|
Address handler_fp = nullptr;
|
|
|
|
// Special handling of termination exceptions, uncatchable by JavaScript code,
|
|
// we unwind the handlers until the top ENTRY handler is found.
|
|
bool catchable_by_js = is_catchable_by_javascript(exception);
|
|
|
|
// Compute handler and stack unwinding information by performing a full walk
|
|
// over the stack and dispatching according to the frame type.
|
|
for (StackFrameIterator iter(this); !iter.done(); iter.Advance()) {
|
|
StackFrame* frame = iter.frame();
|
|
|
|
// For JSEntryStub frames we always have a handler.
|
|
if (frame->is_entry() || frame->is_entry_construct()) {
|
|
StackHandler* handler = frame->top_handler();
|
|
|
|
// Restore the next handler.
|
|
thread_local_top()->handler_ = handler->next()->address();
|
|
|
|
// Gather information from the handler.
|
|
code = frame->LookupCode();
|
|
handler_sp = handler->address() + StackHandlerConstants::kSize;
|
|
offset = Smi::cast(code->handler_table()->get(0))->value();
|
|
break;
|
|
}
|
|
|
|
// For optimized frames we perform a lookup in the handler table.
|
|
if (frame->is_optimized() && catchable_by_js) {
|
|
OptimizedFrame* js_frame = static_cast<OptimizedFrame*>(frame);
|
|
int stack_slots = 0; // Will contain stack slot count of frame.
|
|
offset = js_frame->LookupExceptionHandlerInTable(&stack_slots, nullptr);
|
|
if (offset >= 0) {
|
|
// Compute the stack pointer from the frame pointer. This ensures that
|
|
// argument slots on the stack are dropped as returning would.
|
|
Address return_sp = frame->fp() -
|
|
StandardFrameConstants::kFixedFrameSizeFromFp -
|
|
stack_slots * kPointerSize;
|
|
|
|
// Gather information from the frame.
|
|
code = frame->LookupCode();
|
|
if (code->marked_for_deoptimization()) {
|
|
// If the target code is lazy deoptimized, we jump to the original
|
|
// return address, but we make a note that we are throwing, so that
|
|
// the deoptimizer can do the right thing.
|
|
offset = static_cast<int>(frame->pc() - code->entry());
|
|
set_deoptimizer_lazy_throw(true);
|
|
}
|
|
handler_sp = return_sp;
|
|
handler_fp = frame->fp();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// For interpreted frame we perform a range lookup in the handler table.
|
|
if (frame->is_interpreted() && catchable_by_js) {
|
|
InterpretedFrame* js_frame = static_cast<InterpretedFrame*>(frame);
|
|
int context_reg = 0; // Will contain register index holding context.
|
|
offset = js_frame->LookupExceptionHandlerInTable(&context_reg, nullptr);
|
|
if (offset >= 0) {
|
|
// Patch the bytecode offset in the interpreted frame to reflect the
|
|
// position of the exception handler. The special builtin below will
|
|
// take care of continuing to dispatch at that position. Also restore
|
|
// the correct context for the handler from the interpreter register.
|
|
context = Context::cast(js_frame->GetInterpreterRegister(context_reg));
|
|
js_frame->PatchBytecodeOffset(static_cast<int>(offset));
|
|
offset = 0;
|
|
|
|
// Gather information from the frame.
|
|
code = *builtins()->InterpreterEnterBytecodeDispatch();
|
|
handler_sp = frame->sp();
|
|
handler_fp = frame->fp();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// For JavaScript frames we perform a range lookup in the handler table.
|
|
if (frame->is_java_script() && catchable_by_js) {
|
|
JavaScriptFrame* js_frame = static_cast<JavaScriptFrame*>(frame);
|
|
int stack_depth = 0; // Will contain operand stack depth of handler.
|
|
offset = js_frame->LookupExceptionHandlerInTable(&stack_depth, nullptr);
|
|
if (offset >= 0) {
|
|
// Compute the stack pointer from the frame pointer. This ensures that
|
|
// operand stack slots are dropped for nested statements. Also restore
|
|
// correct context for the handler which is pushed within the try-block.
|
|
Address return_sp = frame->fp() -
|
|
StandardFrameConstants::kFixedFrameSizeFromFp -
|
|
stack_depth * kPointerSize;
|
|
STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
|
|
context = Context::cast(Memory::Object_at(return_sp - kPointerSize));
|
|
|
|
// Gather information from the frame.
|
|
code = frame->LookupCode();
|
|
handler_sp = return_sp;
|
|
handler_fp = frame->fp();
|
|
break;
|
|
}
|
|
}
|
|
|
|
RemoveMaterializedObjectsOnUnwind(frame);
|
|
}
|
|
|
|
// Handler must exist.
|
|
CHECK(code != nullptr);
|
|
|
|
// Store information to be consumed by the CEntryStub.
|
|
thread_local_top()->pending_handler_context_ = context;
|
|
thread_local_top()->pending_handler_code_ = code;
|
|
thread_local_top()->pending_handler_offset_ = offset;
|
|
thread_local_top()->pending_handler_fp_ = handler_fp;
|
|
thread_local_top()->pending_handler_sp_ = handler_sp;
|
|
|
|
// Return and clear pending exception.
|
|
clear_pending_exception();
|
|
return exception;
|
|
}
|
|
|
|
|
|
Isolate::CatchType Isolate::PredictExceptionCatcher() {
|
|
Address external_handler = thread_local_top()->try_catch_handler_address();
|
|
Address entry_handler = Isolate::handler(thread_local_top());
|
|
if (IsExternalHandlerOnTop(nullptr)) return CAUGHT_BY_EXTERNAL;
|
|
|
|
// Search for an exception handler by performing a full walk over the stack.
|
|
for (StackFrameIterator iter(this); !iter.done(); iter.Advance()) {
|
|
StackFrame* frame = iter.frame();
|
|
|
|
// For JSEntryStub frames we update the JS_ENTRY handler.
|
|
if (frame->is_entry() || frame->is_entry_construct()) {
|
|
entry_handler = frame->top_handler()->next()->address();
|
|
}
|
|
|
|
// For JavaScript frames we perform a lookup in the handler table.
|
|
if (frame->is_java_script()) {
|
|
JavaScriptFrame* js_frame = static_cast<JavaScriptFrame*>(frame);
|
|
HandlerTable::CatchPrediction prediction;
|
|
if (js_frame->LookupExceptionHandlerInTable(nullptr, &prediction) > 0) {
|
|
// We are conservative with our prediction: try-finally is considered
|
|
// to always rethrow, to meet the expectation of the debugger.
|
|
if (prediction == HandlerTable::CAUGHT) return CAUGHT_BY_JAVASCRIPT;
|
|
}
|
|
}
|
|
|
|
// The exception has been externally caught if and only if there is an
|
|
// external handler which is on top of the top-most JS_ENTRY handler.
|
|
if (external_handler != nullptr && !try_catch_handler()->is_verbose_) {
|
|
if (entry_handler == nullptr || entry_handler > external_handler) {
|
|
return CAUGHT_BY_EXTERNAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handler not found.
|
|
return NOT_CAUGHT;
|
|
}
|
|
|
|
|
|
void Isolate::RemoveMaterializedObjectsOnUnwind(StackFrame* frame) {
|
|
if (frame->is_optimized()) {
|
|
bool removed = materialized_object_store_->Remove(frame->fp());
|
|
USE(removed);
|
|
// If there were any materialized objects, the code should be
|
|
// marked for deopt.
|
|
DCHECK(!removed || frame->LookupCode()->marked_for_deoptimization());
|
|
}
|
|
}
|
|
|
|
|
|
Object* Isolate::ThrowIllegalOperation() {
|
|
if (FLAG_stack_trace_on_illegal) PrintStack(stdout);
|
|
return Throw(heap()->illegal_access_string());
|
|
}
|
|
|
|
|
|
void Isolate::ScheduleThrow(Object* exception) {
|
|
// When scheduling a throw we first throw the exception to get the
|
|
// error reporting if it is uncaught before rescheduling it.
|
|
Throw(exception);
|
|
PropagatePendingExceptionToExternalTryCatch();
|
|
if (has_pending_exception()) {
|
|
thread_local_top()->scheduled_exception_ = pending_exception();
|
|
thread_local_top()->external_caught_exception_ = false;
|
|
clear_pending_exception();
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::RestorePendingMessageFromTryCatch(v8::TryCatch* handler) {
|
|
DCHECK(handler == try_catch_handler());
|
|
DCHECK(handler->HasCaught());
|
|
DCHECK(handler->rethrow_);
|
|
DCHECK(handler->capture_message_);
|
|
Object* message = reinterpret_cast<Object*>(handler->message_obj_);
|
|
DCHECK(message->IsJSMessageObject() || message->IsTheHole());
|
|
thread_local_top()->pending_message_obj_ = message;
|
|
}
|
|
|
|
|
|
void Isolate::CancelScheduledExceptionFromTryCatch(v8::TryCatch* handler) {
|
|
DCHECK(has_scheduled_exception());
|
|
if (scheduled_exception() == handler->exception_) {
|
|
DCHECK(scheduled_exception() != heap()->termination_exception());
|
|
clear_scheduled_exception();
|
|
}
|
|
}
|
|
|
|
|
|
Object* Isolate::PromoteScheduledException() {
|
|
Object* thrown = scheduled_exception();
|
|
clear_scheduled_exception();
|
|
// Re-throw the exception to avoid getting repeated error reporting.
|
|
return ReThrow(thrown);
|
|
}
|
|
|
|
|
|
void Isolate::PrintCurrentStackTrace(FILE* out) {
|
|
StackTraceFrameIterator it(this);
|
|
while (!it.done()) {
|
|
HandleScope scope(this);
|
|
// Find code position if recorded in relocation info.
|
|
JavaScriptFrame* frame = it.frame();
|
|
Code* code = frame->LookupCode();
|
|
int offset = static_cast<int>(frame->pc() - code->instruction_start());
|
|
int pos = frame->LookupCode()->SourcePosition(offset);
|
|
Handle<Object> pos_obj(Smi::FromInt(pos), this);
|
|
// Fetch function and receiver.
|
|
Handle<JSFunction> fun(frame->function());
|
|
Handle<Object> recv(frame->receiver(), this);
|
|
// Advance to the next JavaScript frame and determine if the
|
|
// current frame is the top-level frame.
|
|
it.Advance();
|
|
Handle<Object> is_top_level = factory()->ToBoolean(it.done());
|
|
// Generate and print stack trace line.
|
|
Handle<String> line =
|
|
Execution::GetStackTraceLine(recv, fun, pos_obj, is_top_level);
|
|
if (line->length() > 0) {
|
|
line->PrintOn(out);
|
|
PrintF(out, "\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool Isolate::ComputeLocation(MessageLocation* target) {
|
|
StackTraceFrameIterator it(this);
|
|
if (!it.done()) {
|
|
JavaScriptFrame* frame = it.frame();
|
|
JSFunction* fun = frame->function();
|
|
Object* script = fun->shared()->script();
|
|
if (script->IsScript() &&
|
|
!(Script::cast(script)->source()->IsUndefined())) {
|
|
Handle<Script> casted_script(Script::cast(script));
|
|
// Compute the location from the function and the relocation info of the
|
|
// baseline code. For optimized code this will use the deoptimization
|
|
// information to get canonical location information.
|
|
List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
|
|
it.frame()->Summarize(&frames);
|
|
FrameSummary& summary = frames.last();
|
|
int pos = summary.abstract_code()->SourcePosition(summary.code_offset());
|
|
*target = MessageLocation(casted_script, pos, pos + 1, handle(fun));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Isolate::ComputeLocationFromException(MessageLocation* target,
|
|
Handle<Object> exception) {
|
|
if (!exception->IsJSObject()) return false;
|
|
|
|
Handle<Name> start_pos_symbol = factory()->error_start_pos_symbol();
|
|
Handle<Object> start_pos = JSReceiver::GetDataProperty(
|
|
Handle<JSObject>::cast(exception), start_pos_symbol);
|
|
if (!start_pos->IsSmi()) return false;
|
|
int start_pos_value = Handle<Smi>::cast(start_pos)->value();
|
|
|
|
Handle<Name> end_pos_symbol = factory()->error_end_pos_symbol();
|
|
Handle<Object> end_pos = JSReceiver::GetDataProperty(
|
|
Handle<JSObject>::cast(exception), end_pos_symbol);
|
|
if (!end_pos->IsSmi()) return false;
|
|
int end_pos_value = Handle<Smi>::cast(end_pos)->value();
|
|
|
|
Handle<Name> script_symbol = factory()->error_script_symbol();
|
|
Handle<Object> script = JSReceiver::GetDataProperty(
|
|
Handle<JSObject>::cast(exception), script_symbol);
|
|
if (!script->IsScript()) return false;
|
|
|
|
Handle<Script> cast_script(Script::cast(*script));
|
|
*target = MessageLocation(cast_script, start_pos_value, end_pos_value);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Isolate::ComputeLocationFromStackTrace(MessageLocation* target,
|
|
Handle<Object> exception) {
|
|
if (!exception->IsJSObject()) return false;
|
|
Handle<Name> key = factory()->stack_trace_symbol();
|
|
Handle<Object> property =
|
|
JSReceiver::GetDataProperty(Handle<JSObject>::cast(exception), key);
|
|
if (!property->IsJSArray()) return false;
|
|
Handle<JSArray> simple_stack_trace = Handle<JSArray>::cast(property);
|
|
|
|
Handle<FixedArray> elements(FixedArray::cast(simple_stack_trace->elements()));
|
|
int elements_limit = Smi::cast(simple_stack_trace->length())->value();
|
|
|
|
for (int i = 1; i < elements_limit; i += 4) {
|
|
Handle<JSFunction> fun =
|
|
handle(JSFunction::cast(elements->get(i + 1)), this);
|
|
if (!fun->shared()->IsSubjectToDebugging()) continue;
|
|
|
|
Object* script = fun->shared()->script();
|
|
if (script->IsScript() &&
|
|
!(Script::cast(script)->source()->IsUndefined())) {
|
|
int pos = PositionFromStackTrace(elements, i);
|
|
Handle<Script> casted_script(Script::cast(script));
|
|
*target = MessageLocation(casted_script, pos, pos + 1);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
Handle<JSMessageObject> Isolate::CreateMessage(Handle<Object> exception,
|
|
MessageLocation* location) {
|
|
Handle<JSArray> stack_trace_object;
|
|
if (capture_stack_trace_for_uncaught_exceptions_) {
|
|
if (Object::IsErrorObject(this, exception)) {
|
|
// We fetch the stack trace that corresponds to this error object.
|
|
// If the lookup fails, the exception is probably not a valid Error
|
|
// object. In that case, we fall through and capture the stack trace
|
|
// at this throw site.
|
|
stack_trace_object =
|
|
GetDetailedStackTrace(Handle<JSObject>::cast(exception));
|
|
}
|
|
if (stack_trace_object.is_null()) {
|
|
// Not an error object, we capture stack and location at throw site.
|
|
stack_trace_object = CaptureCurrentStackTrace(
|
|
stack_trace_for_uncaught_exceptions_frame_limit_,
|
|
stack_trace_for_uncaught_exceptions_options_);
|
|
}
|
|
}
|
|
MessageLocation computed_location;
|
|
if (location == NULL &&
|
|
(ComputeLocationFromException(&computed_location, exception) ||
|
|
ComputeLocationFromStackTrace(&computed_location, exception) ||
|
|
ComputeLocation(&computed_location))) {
|
|
location = &computed_location;
|
|
}
|
|
|
|
return MessageHandler::MakeMessageObject(
|
|
this, MessageTemplate::kUncaughtException, location, exception,
|
|
stack_trace_object);
|
|
}
|
|
|
|
|
|
bool Isolate::IsJavaScriptHandlerOnTop(Object* exception) {
|
|
DCHECK_NE(heap()->the_hole_value(), exception);
|
|
|
|
// For uncatchable exceptions, the JavaScript handler cannot be on top.
|
|
if (!is_catchable_by_javascript(exception)) return false;
|
|
|
|
// Get the top-most JS_ENTRY handler, cannot be on top if it doesn't exist.
|
|
Address entry_handler = Isolate::handler(thread_local_top());
|
|
if (entry_handler == nullptr) return false;
|
|
|
|
// Get the address of the external handler so we can compare the address to
|
|
// determine which one is closer to the top of the stack.
|
|
Address external_handler = thread_local_top()->try_catch_handler_address();
|
|
if (external_handler == nullptr) return true;
|
|
|
|
// The exception has been externally caught if and only if there is an
|
|
// external handler which is on top of the top-most JS_ENTRY handler.
|
|
//
|
|
// Note, that finally clauses would re-throw an exception unless it's aborted
|
|
// by jumps in control flow (like return, break, etc.) and we'll have another
|
|
// chance to set proper v8::TryCatch later.
|
|
return (entry_handler < external_handler);
|
|
}
|
|
|
|
|
|
bool Isolate::IsExternalHandlerOnTop(Object* exception) {
|
|
DCHECK_NE(heap()->the_hole_value(), exception);
|
|
|
|
// Get the address of the external handler so we can compare the address to
|
|
// determine which one is closer to the top of the stack.
|
|
Address external_handler = thread_local_top()->try_catch_handler_address();
|
|
if (external_handler == nullptr) return false;
|
|
|
|
// For uncatchable exceptions, the external handler is always on top.
|
|
if (!is_catchable_by_javascript(exception)) return true;
|
|
|
|
// Get the top-most JS_ENTRY handler, cannot be on top if it doesn't exist.
|
|
Address entry_handler = Isolate::handler(thread_local_top());
|
|
if (entry_handler == nullptr) return true;
|
|
|
|
// The exception has been externally caught if and only if there is an
|
|
// external handler which is on top of the top-most JS_ENTRY handler.
|
|
//
|
|
// Note, that finally clauses would re-throw an exception unless it's aborted
|
|
// by jumps in control flow (like return, break, etc.) and we'll have another
|
|
// chance to set proper v8::TryCatch later.
|
|
return (entry_handler > external_handler);
|
|
}
|
|
|
|
|
|
void Isolate::ReportPendingMessages() {
|
|
Object* exception = pending_exception();
|
|
|
|
// Try to propagate the exception to an external v8::TryCatch handler. If
|
|
// propagation was unsuccessful, then we will get another chance at reporting
|
|
// the pending message if the exception is re-thrown.
|
|
bool has_been_propagated = PropagatePendingExceptionToExternalTryCatch();
|
|
if (!has_been_propagated) return;
|
|
|
|
// Clear the pending message object early to avoid endless recursion.
|
|
Object* message_obj = thread_local_top_.pending_message_obj_;
|
|
clear_pending_message();
|
|
|
|
// For uncatchable exceptions we do nothing. If needed, the exception and the
|
|
// message have already been propagated to v8::TryCatch.
|
|
if (!is_catchable_by_javascript(exception)) return;
|
|
|
|
// Determine whether the message needs to be reported to all message handlers
|
|
// depending on whether and external v8::TryCatch or an internal JavaScript
|
|
// handler is on top.
|
|
bool should_report_exception;
|
|
if (IsExternalHandlerOnTop(exception)) {
|
|
// Only report the exception if the external handler is verbose.
|
|
should_report_exception = try_catch_handler()->is_verbose_;
|
|
} else {
|
|
// Report the exception if it isn't caught by JavaScript code.
|
|
should_report_exception = !IsJavaScriptHandlerOnTop(exception);
|
|
}
|
|
|
|
// Actually report the pending message to all message handlers.
|
|
if (!message_obj->IsTheHole() && should_report_exception) {
|
|
HandleScope scope(this);
|
|
Handle<JSMessageObject> message(JSMessageObject::cast(message_obj));
|
|
Handle<JSValue> script_wrapper(JSValue::cast(message->script()));
|
|
Handle<Script> script(Script::cast(script_wrapper->value()));
|
|
int start_pos = message->start_position();
|
|
int end_pos = message->end_position();
|
|
MessageLocation location(script, start_pos, end_pos);
|
|
MessageHandler::ReportMessage(this, &location, message);
|
|
}
|
|
}
|
|
|
|
|
|
MessageLocation Isolate::GetMessageLocation() {
|
|
DCHECK(has_pending_exception());
|
|
|
|
if (thread_local_top_.pending_exception_ != heap()->termination_exception() &&
|
|
!thread_local_top_.pending_message_obj_->IsTheHole()) {
|
|
Handle<JSMessageObject> message_obj(
|
|
JSMessageObject::cast(thread_local_top_.pending_message_obj_));
|
|
Handle<JSValue> script_wrapper(JSValue::cast(message_obj->script()));
|
|
Handle<Script> script(Script::cast(script_wrapper->value()));
|
|
int start_pos = message_obj->start_position();
|
|
int end_pos = message_obj->end_position();
|
|
return MessageLocation(script, start_pos, end_pos);
|
|
}
|
|
|
|
return MessageLocation();
|
|
}
|
|
|
|
|
|
bool Isolate::OptionalRescheduleException(bool is_bottom_call) {
|
|
DCHECK(has_pending_exception());
|
|
PropagatePendingExceptionToExternalTryCatch();
|
|
|
|
bool is_termination_exception =
|
|
pending_exception() == heap_.termination_exception();
|
|
|
|
// Do not reschedule the exception if this is the bottom call.
|
|
bool clear_exception = is_bottom_call;
|
|
|
|
if (is_termination_exception) {
|
|
if (is_bottom_call) {
|
|
thread_local_top()->external_caught_exception_ = false;
|
|
clear_pending_exception();
|
|
return false;
|
|
}
|
|
} else if (thread_local_top()->external_caught_exception_) {
|
|
// If the exception is externally caught, clear it if there are no
|
|
// JavaScript frames on the way to the C++ frame that has the
|
|
// external handler.
|
|
DCHECK(thread_local_top()->try_catch_handler_address() != NULL);
|
|
Address external_handler_address =
|
|
thread_local_top()->try_catch_handler_address();
|
|
JavaScriptFrameIterator it(this);
|
|
if (it.done() || (it.frame()->sp() > external_handler_address)) {
|
|
clear_exception = true;
|
|
}
|
|
}
|
|
|
|
// Clear the exception if needed.
|
|
if (clear_exception) {
|
|
thread_local_top()->external_caught_exception_ = false;
|
|
clear_pending_exception();
|
|
return false;
|
|
}
|
|
|
|
// Reschedule the exception.
|
|
thread_local_top()->scheduled_exception_ = pending_exception();
|
|
clear_pending_exception();
|
|
return true;
|
|
}
|
|
|
|
|
|
void Isolate::PushPromise(Handle<JSObject> promise,
|
|
Handle<JSFunction> function) {
|
|
ThreadLocalTop* tltop = thread_local_top();
|
|
PromiseOnStack* prev = tltop->promise_on_stack_;
|
|
Handle<JSObject> global_promise =
|
|
Handle<JSObject>::cast(global_handles()->Create(*promise));
|
|
Handle<JSFunction> global_function =
|
|
Handle<JSFunction>::cast(global_handles()->Create(*function));
|
|
tltop->promise_on_stack_ =
|
|
new PromiseOnStack(global_function, global_promise, prev);
|
|
}
|
|
|
|
|
|
void Isolate::PopPromise() {
|
|
ThreadLocalTop* tltop = thread_local_top();
|
|
if (tltop->promise_on_stack_ == NULL) return;
|
|
PromiseOnStack* prev = tltop->promise_on_stack_->prev();
|
|
Handle<Object> global_function = tltop->promise_on_stack_->function();
|
|
Handle<Object> global_promise = tltop->promise_on_stack_->promise();
|
|
delete tltop->promise_on_stack_;
|
|
tltop->promise_on_stack_ = prev;
|
|
global_handles()->Destroy(global_function.location());
|
|
global_handles()->Destroy(global_promise.location());
|
|
}
|
|
|
|
|
|
Handle<Object> Isolate::GetPromiseOnStackOnThrow() {
|
|
Handle<Object> undefined = factory()->undefined_value();
|
|
ThreadLocalTop* tltop = thread_local_top();
|
|
if (tltop->promise_on_stack_ == NULL) return undefined;
|
|
Handle<JSFunction> promise_function = tltop->promise_on_stack_->function();
|
|
// Find the top-most try-catch or try-finally handler.
|
|
if (PredictExceptionCatcher() != CAUGHT_BY_JAVASCRIPT) return undefined;
|
|
for (JavaScriptFrameIterator it(this); !it.done(); it.Advance()) {
|
|
JavaScriptFrame* frame = it.frame();
|
|
if (frame->LookupExceptionHandlerInTable(nullptr, nullptr) > 0) {
|
|
// Throwing inside a Promise only leads to a reject if not caught by an
|
|
// inner try-catch or try-finally.
|
|
if (frame->function() == *promise_function) {
|
|
return tltop->promise_on_stack_->promise();
|
|
}
|
|
return undefined;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
|
|
void Isolate::SetCaptureStackTraceForUncaughtExceptions(
|
|
bool capture,
|
|
int frame_limit,
|
|
StackTrace::StackTraceOptions options) {
|
|
capture_stack_trace_for_uncaught_exceptions_ = capture;
|
|
stack_trace_for_uncaught_exceptions_frame_limit_ = frame_limit;
|
|
stack_trace_for_uncaught_exceptions_options_ = options;
|
|
}
|
|
|
|
|
|
void Isolate::SetAbortOnUncaughtExceptionCallback(
|
|
v8::Isolate::AbortOnUncaughtExceptionCallback callback) {
|
|
abort_on_uncaught_exception_callback_ = callback;
|
|
}
|
|
|
|
|
|
Handle<Context> Isolate::native_context() {
|
|
return handle(context()->native_context());
|
|
}
|
|
|
|
|
|
Handle<Context> Isolate::GetCallingNativeContext() {
|
|
JavaScriptFrameIterator it(this);
|
|
if (debug_->in_debug_scope()) {
|
|
while (!it.done()) {
|
|
JavaScriptFrame* frame = it.frame();
|
|
Context* context = Context::cast(frame->context());
|
|
if (context->native_context() == *debug_->debug_context()) {
|
|
it.Advance();
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (it.done()) return Handle<Context>::null();
|
|
JavaScriptFrame* frame = it.frame();
|
|
Context* context = Context::cast(frame->context());
|
|
return Handle<Context>(context->native_context());
|
|
}
|
|
|
|
|
|
char* Isolate::ArchiveThread(char* to) {
|
|
MemCopy(to, reinterpret_cast<char*>(thread_local_top()),
|
|
sizeof(ThreadLocalTop));
|
|
InitializeThreadLocal();
|
|
clear_pending_exception();
|
|
clear_pending_message();
|
|
clear_scheduled_exception();
|
|
return to + sizeof(ThreadLocalTop);
|
|
}
|
|
|
|
|
|
char* Isolate::RestoreThread(char* from) {
|
|
MemCopy(reinterpret_cast<char*>(thread_local_top()), from,
|
|
sizeof(ThreadLocalTop));
|
|
// This might be just paranoia, but it seems to be needed in case a
|
|
// thread_local_top_ is restored on a separate OS thread.
|
|
#ifdef USE_SIMULATOR
|
|
thread_local_top()->simulator_ = Simulator::current(this);
|
|
#endif
|
|
DCHECK(context() == NULL || context()->IsContext());
|
|
return from + sizeof(ThreadLocalTop);
|
|
}
|
|
|
|
|
|
Isolate::ThreadDataTable::ThreadDataTable()
|
|
: list_(NULL) {
|
|
}
|
|
|
|
|
|
Isolate::ThreadDataTable::~ThreadDataTable() {
|
|
// TODO(svenpanne) The assertion below would fire if an embedder does not
|
|
// cleanly dispose all Isolates before disposing v8, so we are conservative
|
|
// and leave it out for now.
|
|
// DCHECK_NULL(list_);
|
|
}
|
|
|
|
|
|
Isolate::PerIsolateThreadData::~PerIsolateThreadData() {
|
|
#if defined(USE_SIMULATOR)
|
|
delete simulator_;
|
|
#endif
|
|
}
|
|
|
|
|
|
Isolate::PerIsolateThreadData*
|
|
Isolate::ThreadDataTable::Lookup(Isolate* isolate,
|
|
ThreadId thread_id) {
|
|
for (PerIsolateThreadData* data = list_; data != NULL; data = data->next_) {
|
|
if (data->Matches(isolate, thread_id)) return data;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void Isolate::ThreadDataTable::Insert(Isolate::PerIsolateThreadData* data) {
|
|
if (list_ != NULL) list_->prev_ = data;
|
|
data->next_ = list_;
|
|
list_ = data;
|
|
}
|
|
|
|
|
|
void Isolate::ThreadDataTable::Remove(PerIsolateThreadData* data) {
|
|
if (list_ == data) list_ = data->next_;
|
|
if (data->next_ != NULL) data->next_->prev_ = data->prev_;
|
|
if (data->prev_ != NULL) data->prev_->next_ = data->next_;
|
|
delete data;
|
|
}
|
|
|
|
|
|
void Isolate::ThreadDataTable::RemoveAllThreads(Isolate* isolate) {
|
|
PerIsolateThreadData* data = list_;
|
|
while (data != NULL) {
|
|
PerIsolateThreadData* next = data->next_;
|
|
if (data->isolate() == isolate) Remove(data);
|
|
data = next;
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
#define TRACE_ISOLATE(tag) \
|
|
do { \
|
|
if (FLAG_trace_isolates) { \
|
|
PrintF("Isolate %p (id %d)" #tag "\n", \
|
|
reinterpret_cast<void*>(this), id()); \
|
|
} \
|
|
} while (false)
|
|
#else
|
|
#define TRACE_ISOLATE(tag)
|
|
#endif
|
|
|
|
Isolate::Isolate(bool enable_serializer)
|
|
: embedder_data_(),
|
|
entry_stack_(NULL),
|
|
stack_trace_nesting_level_(0),
|
|
incomplete_message_(NULL),
|
|
bootstrapper_(NULL),
|
|
runtime_profiler_(NULL),
|
|
compilation_cache_(NULL),
|
|
counters_(NULL),
|
|
code_range_(NULL),
|
|
logger_(NULL),
|
|
stats_table_(NULL),
|
|
stub_cache_(NULL),
|
|
code_aging_helper_(NULL),
|
|
deoptimizer_data_(NULL),
|
|
deoptimizer_lazy_throw_(false),
|
|
materialized_object_store_(NULL),
|
|
capture_stack_trace_for_uncaught_exceptions_(false),
|
|
stack_trace_for_uncaught_exceptions_frame_limit_(0),
|
|
stack_trace_for_uncaught_exceptions_options_(StackTrace::kOverview),
|
|
memory_allocator_(NULL),
|
|
keyed_lookup_cache_(NULL),
|
|
context_slot_cache_(NULL),
|
|
descriptor_lookup_cache_(NULL),
|
|
handle_scope_implementer_(NULL),
|
|
unicode_cache_(NULL),
|
|
inner_pointer_to_code_cache_(NULL),
|
|
global_handles_(NULL),
|
|
eternal_handles_(NULL),
|
|
thread_manager_(NULL),
|
|
has_installed_extensions_(false),
|
|
regexp_stack_(NULL),
|
|
date_cache_(NULL),
|
|
call_descriptor_data_(NULL),
|
|
// TODO(bmeurer) Initialized lazily because it depends on flags; can
|
|
// be fixed once the default isolate cleanup is done.
|
|
random_number_generator_(NULL),
|
|
serializer_enabled_(enable_serializer),
|
|
has_fatal_error_(false),
|
|
initialized_from_snapshot_(false),
|
|
cpu_profiler_(NULL),
|
|
heap_profiler_(NULL),
|
|
function_entry_hook_(NULL),
|
|
deferred_handles_head_(NULL),
|
|
optimizing_compile_dispatcher_(NULL),
|
|
stress_deopt_count_(0),
|
|
virtual_handler_register_(NULL),
|
|
virtual_slot_register_(NULL),
|
|
next_optimization_id_(0),
|
|
js_calls_from_api_counter_(0),
|
|
#if TRACE_MAPS
|
|
next_unique_sfi_id_(0),
|
|
#endif
|
|
use_counter_callback_(NULL),
|
|
basic_block_profiler_(NULL),
|
|
cancelable_task_manager_(new CancelableTaskManager()),
|
|
abort_on_uncaught_exception_callback_(NULL) {
|
|
{
|
|
base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
|
|
CHECK(thread_data_table_);
|
|
}
|
|
id_ = base::NoBarrier_AtomicIncrement(&isolate_counter_, 1);
|
|
TRACE_ISOLATE(constructor);
|
|
|
|
memset(isolate_addresses_, 0,
|
|
sizeof(isolate_addresses_[0]) * (kIsolateAddressCount + 1));
|
|
|
|
heap_.isolate_ = this;
|
|
stack_guard_.isolate_ = this;
|
|
|
|
// ThreadManager is initialized early to support locking an isolate
|
|
// before it is entered.
|
|
thread_manager_ = new ThreadManager();
|
|
thread_manager_->isolate_ = this;
|
|
|
|
#ifdef DEBUG
|
|
// heap_histograms_ initializes itself.
|
|
memset(&js_spill_information_, 0, sizeof(js_spill_information_));
|
|
#endif
|
|
|
|
handle_scope_data_.Initialize();
|
|
|
|
#define ISOLATE_INIT_EXECUTE(type, name, initial_value) \
|
|
name##_ = (initial_value);
|
|
ISOLATE_INIT_LIST(ISOLATE_INIT_EXECUTE)
|
|
#undef ISOLATE_INIT_EXECUTE
|
|
|
|
#define ISOLATE_INIT_ARRAY_EXECUTE(type, name, length) \
|
|
memset(name##_, 0, sizeof(type) * length);
|
|
ISOLATE_INIT_ARRAY_LIST(ISOLATE_INIT_ARRAY_EXECUTE)
|
|
#undef ISOLATE_INIT_ARRAY_EXECUTE
|
|
|
|
InitializeLoggingAndCounters();
|
|
debug_ = new Debug(this);
|
|
|
|
init_memcopy_functions(this);
|
|
}
|
|
|
|
|
|
void Isolate::TearDown() {
|
|
TRACE_ISOLATE(tear_down);
|
|
|
|
// Temporarily set this isolate as current so that various parts of
|
|
// the isolate can access it in their destructors without having a
|
|
// direct pointer. We don't use Enter/Exit here to avoid
|
|
// initializing the thread data.
|
|
PerIsolateThreadData* saved_data = CurrentPerIsolateThreadData();
|
|
DCHECK(base::NoBarrier_Load(&isolate_key_created_) == 1);
|
|
Isolate* saved_isolate =
|
|
reinterpret_cast<Isolate*>(base::Thread::GetThreadLocal(isolate_key_));
|
|
SetIsolateThreadLocals(this, NULL);
|
|
|
|
Deinit();
|
|
|
|
{
|
|
base::LockGuard<base::Mutex> lock_guard(thread_data_table_mutex_.Pointer());
|
|
thread_data_table_->RemoveAllThreads(this);
|
|
}
|
|
|
|
delete this;
|
|
|
|
// Restore the previous current isolate.
|
|
SetIsolateThreadLocals(saved_isolate, saved_data);
|
|
}
|
|
|
|
|
|
void Isolate::GlobalTearDown() {
|
|
delete thread_data_table_;
|
|
thread_data_table_ = NULL;
|
|
}
|
|
|
|
|
|
void Isolate::ClearSerializerData() {
|
|
delete external_reference_table_;
|
|
external_reference_table_ = NULL;
|
|
delete external_reference_map_;
|
|
external_reference_map_ = NULL;
|
|
}
|
|
|
|
|
|
void Isolate::Deinit() {
|
|
TRACE_ISOLATE(deinit);
|
|
|
|
debug()->Unload();
|
|
|
|
FreeThreadResources();
|
|
|
|
if (concurrent_recompilation_enabled()) {
|
|
optimizing_compile_dispatcher_->Stop();
|
|
delete optimizing_compile_dispatcher_;
|
|
optimizing_compile_dispatcher_ = NULL;
|
|
}
|
|
|
|
if (heap_.mark_compact_collector()->sweeping_in_progress()) {
|
|
heap_.mark_compact_collector()->EnsureSweepingCompleted();
|
|
}
|
|
|
|
DumpAndResetCompilationStats();
|
|
|
|
if (FLAG_print_deopt_stress) {
|
|
PrintF(stdout, "=== Stress deopt counter: %u\n", stress_deopt_count_);
|
|
}
|
|
|
|
if (cpu_profiler_) {
|
|
cpu_profiler_->DeleteAllProfiles();
|
|
}
|
|
|
|
// We must stop the logger before we tear down other components.
|
|
Sampler* sampler = logger_->sampler();
|
|
if (sampler && sampler->IsActive()) sampler->Stop();
|
|
|
|
delete deoptimizer_data_;
|
|
deoptimizer_data_ = NULL;
|
|
builtins_.TearDown();
|
|
bootstrapper_->TearDown();
|
|
|
|
if (runtime_profiler_ != NULL) {
|
|
delete runtime_profiler_;
|
|
runtime_profiler_ = NULL;
|
|
}
|
|
|
|
delete basic_block_profiler_;
|
|
basic_block_profiler_ = NULL;
|
|
|
|
delete heap_profiler_;
|
|
heap_profiler_ = NULL;
|
|
|
|
heap_.TearDown();
|
|
logger_->TearDown();
|
|
|
|
delete interpreter_;
|
|
interpreter_ = NULL;
|
|
|
|
cancelable_task_manager()->CancelAndWait();
|
|
|
|
delete cpu_profiler_;
|
|
cpu_profiler_ = NULL;
|
|
|
|
delete root_index_map_;
|
|
root_index_map_ = NULL;
|
|
|
|
ClearSerializerData();
|
|
}
|
|
|
|
|
|
void Isolate::SetIsolateThreadLocals(Isolate* isolate,
|
|
PerIsolateThreadData* data) {
|
|
base::Thread::SetThreadLocal(isolate_key_, isolate);
|
|
base::Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
|
|
}
|
|
|
|
|
|
Isolate::~Isolate() {
|
|
TRACE_ISOLATE(destructor);
|
|
|
|
// Has to be called while counters_ are still alive
|
|
runtime_zone_.DeleteKeptSegment();
|
|
|
|
// The entry stack must be empty when we get here.
|
|
DCHECK(entry_stack_ == NULL || entry_stack_->previous_item == NULL);
|
|
|
|
delete entry_stack_;
|
|
entry_stack_ = NULL;
|
|
|
|
delete unicode_cache_;
|
|
unicode_cache_ = NULL;
|
|
|
|
delete date_cache_;
|
|
date_cache_ = NULL;
|
|
|
|
delete[] call_descriptor_data_;
|
|
call_descriptor_data_ = NULL;
|
|
|
|
delete regexp_stack_;
|
|
regexp_stack_ = NULL;
|
|
|
|
delete descriptor_lookup_cache_;
|
|
descriptor_lookup_cache_ = NULL;
|
|
delete context_slot_cache_;
|
|
context_slot_cache_ = NULL;
|
|
delete keyed_lookup_cache_;
|
|
keyed_lookup_cache_ = NULL;
|
|
|
|
delete stub_cache_;
|
|
stub_cache_ = NULL;
|
|
delete code_aging_helper_;
|
|
code_aging_helper_ = NULL;
|
|
delete stats_table_;
|
|
stats_table_ = NULL;
|
|
|
|
delete materialized_object_store_;
|
|
materialized_object_store_ = NULL;
|
|
|
|
delete logger_;
|
|
logger_ = NULL;
|
|
|
|
delete counters_;
|
|
counters_ = NULL;
|
|
|
|
delete handle_scope_implementer_;
|
|
handle_scope_implementer_ = NULL;
|
|
|
|
delete code_tracer();
|
|
set_code_tracer(NULL);
|
|
|
|
delete compilation_cache_;
|
|
compilation_cache_ = NULL;
|
|
delete bootstrapper_;
|
|
bootstrapper_ = NULL;
|
|
delete inner_pointer_to_code_cache_;
|
|
inner_pointer_to_code_cache_ = NULL;
|
|
|
|
delete thread_manager_;
|
|
thread_manager_ = NULL;
|
|
|
|
delete memory_allocator_;
|
|
memory_allocator_ = NULL;
|
|
delete code_range_;
|
|
code_range_ = NULL;
|
|
delete global_handles_;
|
|
global_handles_ = NULL;
|
|
delete eternal_handles_;
|
|
eternal_handles_ = NULL;
|
|
|
|
delete string_stream_debug_object_cache_;
|
|
string_stream_debug_object_cache_ = NULL;
|
|
|
|
delete random_number_generator_;
|
|
random_number_generator_ = NULL;
|
|
|
|
delete debug_;
|
|
debug_ = NULL;
|
|
|
|
delete cancelable_task_manager_;
|
|
cancelable_task_manager_ = nullptr;
|
|
|
|
#if USE_SIMULATOR
|
|
Simulator::TearDown(simulator_i_cache_, simulator_redirection_);
|
|
simulator_i_cache_ = nullptr;
|
|
simulator_redirection_ = nullptr;
|
|
#endif
|
|
}
|
|
|
|
|
|
void Isolate::InitializeThreadLocal() {
|
|
thread_local_top_.isolate_ = this;
|
|
thread_local_top_.Initialize();
|
|
}
|
|
|
|
|
|
bool Isolate::PropagatePendingExceptionToExternalTryCatch() {
|
|
Object* exception = pending_exception();
|
|
|
|
if (IsJavaScriptHandlerOnTop(exception)) {
|
|
thread_local_top_.external_caught_exception_ = false;
|
|
return false;
|
|
}
|
|
|
|
if (!IsExternalHandlerOnTop(exception)) {
|
|
thread_local_top_.external_caught_exception_ = false;
|
|
return true;
|
|
}
|
|
|
|
thread_local_top_.external_caught_exception_ = true;
|
|
if (!is_catchable_by_javascript(exception)) {
|
|
try_catch_handler()->can_continue_ = false;
|
|
try_catch_handler()->has_terminated_ = true;
|
|
try_catch_handler()->exception_ = heap()->null_value();
|
|
} else {
|
|
v8::TryCatch* handler = try_catch_handler();
|
|
DCHECK(thread_local_top_.pending_message_obj_->IsJSMessageObject() ||
|
|
thread_local_top_.pending_message_obj_->IsTheHole());
|
|
handler->can_continue_ = true;
|
|
handler->has_terminated_ = false;
|
|
handler->exception_ = pending_exception();
|
|
// Propagate to the external try-catch only if we got an actual message.
|
|
if (thread_local_top_.pending_message_obj_->IsTheHole()) return true;
|
|
|
|
handler->message_obj_ = thread_local_top_.pending_message_obj_;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void Isolate::InitializeLoggingAndCounters() {
|
|
if (logger_ == NULL) {
|
|
logger_ = new Logger(this);
|
|
}
|
|
if (counters_ == NULL) {
|
|
counters_ = new Counters(this);
|
|
}
|
|
}
|
|
|
|
|
|
bool Isolate::Init(Deserializer* des) {
|
|
TRACE_ISOLATE(init);
|
|
|
|
stress_deopt_count_ = FLAG_deopt_every_n_times;
|
|
|
|
has_fatal_error_ = false;
|
|
|
|
if (function_entry_hook() != NULL) {
|
|
// When function entry hooking is in effect, we have to create the code
|
|
// stubs from scratch to get entry hooks, rather than loading the previously
|
|
// generated stubs from disk.
|
|
// If this assert fires, the initialization path has regressed.
|
|
DCHECK(des == NULL);
|
|
}
|
|
|
|
// The initialization process does not handle memory exhaustion.
|
|
AlwaysAllocateScope always_allocate(this);
|
|
|
|
memory_allocator_ = new MemoryAllocator(this);
|
|
code_range_ = new CodeRange(this);
|
|
|
|
// Safe after setting Heap::isolate_, and initializing StackGuard
|
|
heap_.SetStackLimits();
|
|
|
|
#define ASSIGN_ELEMENT(CamelName, hacker_name) \
|
|
isolate_addresses_[Isolate::k##CamelName##Address] = \
|
|
reinterpret_cast<Address>(hacker_name##_address());
|
|
FOR_EACH_ISOLATE_ADDRESS_NAME(ASSIGN_ELEMENT)
|
|
#undef ASSIGN_ELEMENT
|
|
|
|
compilation_cache_ = new CompilationCache(this);
|
|
keyed_lookup_cache_ = new KeyedLookupCache();
|
|
context_slot_cache_ = new ContextSlotCache();
|
|
descriptor_lookup_cache_ = new DescriptorLookupCache();
|
|
unicode_cache_ = new UnicodeCache();
|
|
inner_pointer_to_code_cache_ = new InnerPointerToCodeCache(this);
|
|
global_handles_ = new GlobalHandles(this);
|
|
eternal_handles_ = new EternalHandles();
|
|
bootstrapper_ = new Bootstrapper(this);
|
|
handle_scope_implementer_ = new HandleScopeImplementer(this);
|
|
stub_cache_ = new StubCache(this);
|
|
materialized_object_store_ = new MaterializedObjectStore(this);
|
|
regexp_stack_ = new RegExpStack();
|
|
regexp_stack_->isolate_ = this;
|
|
date_cache_ = new DateCache();
|
|
call_descriptor_data_ =
|
|
new CallInterfaceDescriptorData[CallDescriptors::NUMBER_OF_DESCRIPTORS];
|
|
cpu_profiler_ = new CpuProfiler(this);
|
|
heap_profiler_ = new HeapProfiler(heap());
|
|
interpreter_ = new interpreter::Interpreter(this);
|
|
|
|
// Enable logging before setting up the heap
|
|
logger_->SetUp(this);
|
|
|
|
// Initialize other runtime facilities
|
|
#if defined(USE_SIMULATOR)
|
|
#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_MIPS || \
|
|
V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC
|
|
Simulator::Initialize(this);
|
|
#endif
|
|
#endif
|
|
|
|
code_aging_helper_ = new CodeAgingHelper(this);
|
|
|
|
{ // NOLINT
|
|
// Ensure that the thread has a valid stack guard. The v8::Locker object
|
|
// will ensure this too, but we don't have to use lockers if we are only
|
|
// using one thread.
|
|
ExecutionAccess lock(this);
|
|
stack_guard_.InitThread(lock);
|
|
}
|
|
|
|
// SetUp the object heap.
|
|
DCHECK(!heap_.HasBeenSetUp());
|
|
if (!heap_.SetUp()) {
|
|
V8::FatalProcessOutOfMemory("heap setup");
|
|
return false;
|
|
}
|
|
|
|
deoptimizer_data_ = new DeoptimizerData(memory_allocator_);
|
|
|
|
const bool create_heap_objects = (des == NULL);
|
|
if (create_heap_objects && !heap_.CreateHeapObjects()) {
|
|
V8::FatalProcessOutOfMemory("heap object creation");
|
|
return false;
|
|
}
|
|
|
|
if (create_heap_objects) {
|
|
// Terminate the cache array with the sentinel so we can iterate.
|
|
partial_snapshot_cache_.Add(heap_.undefined_value());
|
|
}
|
|
|
|
InitializeThreadLocal();
|
|
|
|
bootstrapper_->Initialize(create_heap_objects);
|
|
builtins_.SetUp(this, create_heap_objects);
|
|
|
|
if (FLAG_log_internal_timer_events) {
|
|
set_event_logger(Logger::DefaultEventLoggerSentinel);
|
|
}
|
|
|
|
if (FLAG_trace_hydrogen || FLAG_trace_hydrogen_stubs) {
|
|
PrintF("Concurrent recompilation has been disabled for tracing.\n");
|
|
} else if (OptimizingCompileDispatcher::Enabled()) {
|
|
optimizing_compile_dispatcher_ = new OptimizingCompileDispatcher(this);
|
|
}
|
|
|
|
// Initialize runtime profiler before deserialization, because collections may
|
|
// occur, clearing/updating ICs.
|
|
runtime_profiler_ = new RuntimeProfiler(this);
|
|
|
|
// If we are deserializing, read the state into the now-empty heap.
|
|
if (!create_heap_objects) {
|
|
des->Deserialize(this);
|
|
}
|
|
stub_cache_->Initialize();
|
|
|
|
if (FLAG_ignition) {
|
|
interpreter_->Initialize();
|
|
}
|
|
|
|
// Finish initialization of ThreadLocal after deserialization is done.
|
|
clear_pending_exception();
|
|
clear_pending_message();
|
|
clear_scheduled_exception();
|
|
|
|
// Deserializing may put strange things in the root array's copy of the
|
|
// stack guard.
|
|
heap_.SetStackLimits();
|
|
|
|
// Quiet the heap NaN if needed on target platform.
|
|
if (!create_heap_objects) Assembler::QuietNaN(heap_.nan_value());
|
|
|
|
if (FLAG_trace_turbo) {
|
|
// Create an empty file.
|
|
std::ofstream(GetTurboCfgFileName().c_str(), std::ios_base::trunc);
|
|
}
|
|
|
|
CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, embedder_data_)),
|
|
Internals::kIsolateEmbedderDataOffset);
|
|
CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, heap_.roots_)),
|
|
Internals::kIsolateRootsOffset);
|
|
CHECK_EQ(static_cast<int>(
|
|
OFFSET_OF(Isolate, heap_.amount_of_external_allocated_memory_)),
|
|
Internals::kAmountOfExternalAllocatedMemoryOffset);
|
|
CHECK_EQ(static_cast<int>(OFFSET_OF(
|
|
Isolate,
|
|
heap_.amount_of_external_allocated_memory_at_last_global_gc_)),
|
|
Internals::kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset);
|
|
|
|
time_millis_at_init_ = heap_.MonotonicallyIncreasingTimeInMs();
|
|
|
|
heap_.NotifyDeserializationComplete();
|
|
|
|
if (!create_heap_objects) {
|
|
// Now that the heap is consistent, it's OK to generate the code for the
|
|
// deopt entry table that might have been referred to by optimized code in
|
|
// the snapshot.
|
|
HandleScope scope(this);
|
|
Deoptimizer::EnsureCodeForDeoptimizationEntry(
|
|
this,
|
|
Deoptimizer::LAZY,
|
|
kDeoptTableSerializeEntryCount - 1);
|
|
}
|
|
|
|
if (!serializer_enabled()) {
|
|
// Ensure that all stubs which need to be generated ahead of time, but
|
|
// cannot be serialized into the snapshot have been generated.
|
|
HandleScope scope(this);
|
|
CodeStub::GenerateFPStubs(this);
|
|
StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(this);
|
|
StubFailureTrampolineStub::GenerateAheadOfTime(this);
|
|
}
|
|
|
|
initialized_from_snapshot_ = (des != NULL);
|
|
|
|
if (!FLAG_inline_new) heap_.DisableInlineAllocation();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// Initialized lazily to allow early
|
|
// v8::V8::SetAddHistogramSampleFunction calls.
|
|
StatsTable* Isolate::stats_table() {
|
|
if (stats_table_ == NULL) {
|
|
stats_table_ = new StatsTable;
|
|
}
|
|
return stats_table_;
|
|
}
|
|
|
|
|
|
void Isolate::Enter() {
|
|
Isolate* current_isolate = NULL;
|
|
PerIsolateThreadData* current_data = CurrentPerIsolateThreadData();
|
|
if (current_data != NULL) {
|
|
current_isolate = current_data->isolate_;
|
|
DCHECK(current_isolate != NULL);
|
|
if (current_isolate == this) {
|
|
DCHECK(Current() == this);
|
|
DCHECK(entry_stack_ != NULL);
|
|
DCHECK(entry_stack_->previous_thread_data == NULL ||
|
|
entry_stack_->previous_thread_data->thread_id().Equals(
|
|
ThreadId::Current()));
|
|
// Same thread re-enters the isolate, no need to re-init anything.
|
|
entry_stack_->entry_count++;
|
|
return;
|
|
}
|
|
}
|
|
|
|
PerIsolateThreadData* data = FindOrAllocatePerThreadDataForThisThread();
|
|
DCHECK(data != NULL);
|
|
DCHECK(data->isolate_ == this);
|
|
|
|
EntryStackItem* item = new EntryStackItem(current_data,
|
|
current_isolate,
|
|
entry_stack_);
|
|
entry_stack_ = item;
|
|
|
|
SetIsolateThreadLocals(this, data);
|
|
|
|
// In case it's the first time some thread enters the isolate.
|
|
set_thread_id(data->thread_id());
|
|
}
|
|
|
|
|
|
void Isolate::Exit() {
|
|
DCHECK(entry_stack_ != NULL);
|
|
DCHECK(entry_stack_->previous_thread_data == NULL ||
|
|
entry_stack_->previous_thread_data->thread_id().Equals(
|
|
ThreadId::Current()));
|
|
|
|
if (--entry_stack_->entry_count > 0) return;
|
|
|
|
DCHECK(CurrentPerIsolateThreadData() != NULL);
|
|
DCHECK(CurrentPerIsolateThreadData()->isolate_ == this);
|
|
|
|
// Pop the stack.
|
|
EntryStackItem* item = entry_stack_;
|
|
entry_stack_ = item->previous_item;
|
|
|
|
PerIsolateThreadData* previous_thread_data = item->previous_thread_data;
|
|
Isolate* previous_isolate = item->previous_isolate;
|
|
|
|
delete item;
|
|
|
|
// Reinit the current thread for the isolate it was running before this one.
|
|
SetIsolateThreadLocals(previous_isolate, previous_thread_data);
|
|
}
|
|
|
|
|
|
void Isolate::LinkDeferredHandles(DeferredHandles* deferred) {
|
|
deferred->next_ = deferred_handles_head_;
|
|
if (deferred_handles_head_ != NULL) {
|
|
deferred_handles_head_->previous_ = deferred;
|
|
}
|
|
deferred_handles_head_ = deferred;
|
|
}
|
|
|
|
|
|
void Isolate::UnlinkDeferredHandles(DeferredHandles* deferred) {
|
|
#ifdef DEBUG
|
|
// In debug mode assert that the linked list is well-formed.
|
|
DeferredHandles* deferred_iterator = deferred;
|
|
while (deferred_iterator->previous_ != NULL) {
|
|
deferred_iterator = deferred_iterator->previous_;
|
|
}
|
|
DCHECK(deferred_handles_head_ == deferred_iterator);
|
|
#endif
|
|
if (deferred_handles_head_ == deferred) {
|
|
deferred_handles_head_ = deferred_handles_head_->next_;
|
|
}
|
|
if (deferred->next_ != NULL) {
|
|
deferred->next_->previous_ = deferred->previous_;
|
|
}
|
|
if (deferred->previous_ != NULL) {
|
|
deferred->previous_->next_ = deferred->next_;
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::DumpAndResetCompilationStats() {
|
|
if (turbo_statistics() != nullptr) {
|
|
OFStream os(stdout);
|
|
os << *turbo_statistics() << std::endl;
|
|
}
|
|
if (hstatistics() != nullptr) hstatistics()->Print();
|
|
delete turbo_statistics_;
|
|
turbo_statistics_ = nullptr;
|
|
delete hstatistics_;
|
|
hstatistics_ = nullptr;
|
|
if (FLAG_runtime_call_stats) {
|
|
OFStream os(stdout);
|
|
counters()->runtime_call_stats()->Print(os);
|
|
counters()->runtime_call_stats()->Reset();
|
|
}
|
|
}
|
|
|
|
|
|
HStatistics* Isolate::GetHStatistics() {
|
|
if (hstatistics() == NULL) set_hstatistics(new HStatistics());
|
|
return hstatistics();
|
|
}
|
|
|
|
|
|
CompilationStatistics* Isolate::GetTurboStatistics() {
|
|
if (turbo_statistics() == NULL)
|
|
set_turbo_statistics(new CompilationStatistics());
|
|
return turbo_statistics();
|
|
}
|
|
|
|
|
|
HTracer* Isolate::GetHTracer() {
|
|
if (htracer() == NULL) set_htracer(new HTracer(id()));
|
|
return htracer();
|
|
}
|
|
|
|
|
|
CodeTracer* Isolate::GetCodeTracer() {
|
|
if (code_tracer() == NULL) set_code_tracer(new CodeTracer(id()));
|
|
return code_tracer();
|
|
}
|
|
|
|
|
|
Map* Isolate::get_initial_js_array_map(ElementsKind kind, Strength strength) {
|
|
if (IsFastElementsKind(kind)) {
|
|
DisallowHeapAllocation no_gc;
|
|
Object* const initial_js_array_map = context()->native_context()->get(
|
|
Context::ArrayMapIndex(kind, strength));
|
|
if (!initial_js_array_map->IsUndefined()) {
|
|
return Map::cast(initial_js_array_map);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
bool Isolate::use_crankshaft() const {
|
|
return FLAG_crankshaft &&
|
|
!serializer_enabled_ &&
|
|
CpuFeatures::SupportsCrankshaft();
|
|
}
|
|
|
|
|
|
bool Isolate::IsFastArrayConstructorPrototypeChainIntact() {
|
|
PropertyCell* no_elements_cell = heap()->array_protector();
|
|
bool cell_reports_intact =
|
|
no_elements_cell->value()->IsSmi() &&
|
|
Smi::cast(no_elements_cell->value())->value() == kArrayProtectorValid;
|
|
|
|
#ifdef DEBUG
|
|
Map* root_array_map =
|
|
get_initial_js_array_map(GetInitialFastElementsKind());
|
|
Context* native_context = context()->native_context();
|
|
JSObject* initial_array_proto = JSObject::cast(
|
|
native_context->get(Context::INITIAL_ARRAY_PROTOTYPE_INDEX));
|
|
JSObject* initial_object_proto = JSObject::cast(
|
|
native_context->get(Context::INITIAL_OBJECT_PROTOTYPE_INDEX));
|
|
|
|
if (root_array_map == NULL || initial_array_proto == initial_object_proto) {
|
|
// We are in the bootstrapping process, and the entire check sequence
|
|
// shouldn't be performed.
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
// Check that the array prototype hasn't been altered WRT empty elements.
|
|
if (root_array_map->prototype() != initial_array_proto) {
|
|
DCHECK_EQ(false, cell_reports_intact);
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
FixedArrayBase* elements = initial_array_proto->elements();
|
|
if (elements != heap()->empty_fixed_array() &&
|
|
elements != heap()->empty_slow_element_dictionary()) {
|
|
DCHECK_EQ(false, cell_reports_intact);
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
// Check that the object prototype hasn't been altered WRT empty elements.
|
|
PrototypeIterator iter(this, initial_array_proto);
|
|
if (iter.IsAtEnd() || iter.GetCurrent() != initial_object_proto) {
|
|
DCHECK_EQ(false, cell_reports_intact);
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
elements = initial_object_proto->elements();
|
|
if (elements != heap()->empty_fixed_array() &&
|
|
elements != heap()->empty_slow_element_dictionary()) {
|
|
DCHECK_EQ(false, cell_reports_intact);
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
iter.Advance();
|
|
if (!iter.IsAtEnd()) {
|
|
DCHECK_EQ(false, cell_reports_intact);
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
#endif
|
|
|
|
return cell_reports_intact;
|
|
}
|
|
|
|
|
|
void Isolate::UpdateArrayProtectorOnSetElement(Handle<JSObject> object) {
|
|
if (IsFastArrayConstructorPrototypeChainIntact() &&
|
|
object->map()->is_prototype_map()) {
|
|
Object* context = heap()->native_contexts_list();
|
|
while (!context->IsUndefined()) {
|
|
Context* current_context = Context::cast(context);
|
|
if (current_context->get(Context::INITIAL_OBJECT_PROTOTYPE_INDEX) ==
|
|
*object ||
|
|
current_context->get(Context::INITIAL_ARRAY_PROTOTYPE_INDEX) ==
|
|
*object) {
|
|
PropertyCell::SetValueWithInvalidation(
|
|
factory()->array_protector(),
|
|
handle(Smi::FromInt(kArrayProtectorInvalid), this));
|
|
break;
|
|
}
|
|
context = current_context->get(Context::NEXT_CONTEXT_LINK);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool Isolate::IsAnyInitialArrayPrototype(Handle<JSArray> array) {
|
|
if (array->map()->is_prototype_map()) {
|
|
Object* context = heap()->native_contexts_list();
|
|
while (!context->IsUndefined()) {
|
|
Context* current_context = Context::cast(context);
|
|
if (current_context->get(Context::INITIAL_ARRAY_PROTOTYPE_INDEX) ==
|
|
*array) {
|
|
return true;
|
|
}
|
|
context = current_context->get(Context::NEXT_CONTEXT_LINK);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
CallInterfaceDescriptorData* Isolate::call_descriptor_data(int index) {
|
|
DCHECK(0 <= index && index < CallDescriptors::NUMBER_OF_DESCRIPTORS);
|
|
return &call_descriptor_data_[index];
|
|
}
|
|
|
|
|
|
base::RandomNumberGenerator* Isolate::random_number_generator() {
|
|
if (random_number_generator_ == NULL) {
|
|
if (FLAG_random_seed != 0) {
|
|
random_number_generator_ =
|
|
new base::RandomNumberGenerator(FLAG_random_seed);
|
|
} else {
|
|
random_number_generator_ = new base::RandomNumberGenerator();
|
|
}
|
|
}
|
|
return random_number_generator_;
|
|
}
|
|
|
|
|
|
Object* Isolate::FindCodeObject(Address a) {
|
|
return inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(a);
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
#define ISOLATE_FIELD_OFFSET(type, name, ignored) \
|
|
const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
|
|
ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
|
|
ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
|
|
#undef ISOLATE_FIELD_OFFSET
|
|
#endif
|
|
|
|
|
|
Handle<JSObject> Isolate::SetUpSubregistry(Handle<JSObject> registry,
|
|
Handle<Map> map, const char* cname) {
|
|
Handle<String> name = factory()->InternalizeUtf8String(cname);
|
|
Handle<JSObject> obj = factory()->NewJSObjectFromMap(map);
|
|
JSObject::NormalizeProperties(obj, CLEAR_INOBJECT_PROPERTIES, 0,
|
|
"SetupSymbolRegistry");
|
|
JSObject::AddProperty(registry, name, obj, NONE);
|
|
return obj;
|
|
}
|
|
|
|
|
|
Handle<JSObject> Isolate::GetSymbolRegistry() {
|
|
if (heap()->symbol_registry()->IsSmi()) {
|
|
Handle<Map> map = factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
|
|
Handle<JSObject> registry = factory()->NewJSObjectFromMap(map);
|
|
heap()->set_symbol_registry(*registry);
|
|
|
|
SetUpSubregistry(registry, map, "for");
|
|
SetUpSubregistry(registry, map, "for_api");
|
|
SetUpSubregistry(registry, map, "keyFor");
|
|
SetUpSubregistry(registry, map, "private_api");
|
|
}
|
|
return Handle<JSObject>::cast(factory()->symbol_registry());
|
|
}
|
|
|
|
|
|
void Isolate::AddCallCompletedCallback(CallCompletedCallback callback) {
|
|
for (int i = 0; i < call_completed_callbacks_.length(); i++) {
|
|
if (callback == call_completed_callbacks_.at(i)) return;
|
|
}
|
|
call_completed_callbacks_.Add(callback);
|
|
}
|
|
|
|
|
|
void Isolate::RemoveCallCompletedCallback(CallCompletedCallback callback) {
|
|
for (int i = 0; i < call_completed_callbacks_.length(); i++) {
|
|
if (callback == call_completed_callbacks_.at(i)) {
|
|
call_completed_callbacks_.Remove(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::FireCallCompletedCallback() {
|
|
bool has_call_completed_callbacks = !call_completed_callbacks_.is_empty();
|
|
bool run_microtasks = autorun_microtasks() && pending_microtask_count();
|
|
if (!has_call_completed_callbacks && !run_microtasks) return;
|
|
|
|
if (!handle_scope_implementer()->CallDepthIsZero()) return;
|
|
if (run_microtasks) RunMicrotasks();
|
|
// Fire callbacks. Increase call depth to prevent recursive callbacks.
|
|
v8::Isolate::SuppressMicrotaskExecutionScope suppress(
|
|
reinterpret_cast<v8::Isolate*>(this));
|
|
for (int i = 0; i < call_completed_callbacks_.length(); i++) {
|
|
call_completed_callbacks_.at(i)();
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
|
|
promise_reject_callback_ = callback;
|
|
}
|
|
|
|
|
|
void Isolate::ReportPromiseReject(Handle<JSObject> promise,
|
|
Handle<Object> value,
|
|
v8::PromiseRejectEvent event) {
|
|
if (promise_reject_callback_ == NULL) return;
|
|
Handle<JSArray> stack_trace;
|
|
if (event == v8::kPromiseRejectWithNoHandler && value->IsJSObject()) {
|
|
stack_trace = GetDetailedStackTrace(Handle<JSObject>::cast(value));
|
|
}
|
|
promise_reject_callback_(v8::PromiseRejectMessage(
|
|
v8::Utils::PromiseToLocal(promise), event, v8::Utils::ToLocal(value),
|
|
v8::Utils::StackTraceToLocal(stack_trace)));
|
|
}
|
|
|
|
|
|
void Isolate::EnqueueMicrotask(Handle<Object> microtask) {
|
|
DCHECK(microtask->IsJSFunction() || microtask->IsCallHandlerInfo());
|
|
Handle<FixedArray> queue(heap()->microtask_queue(), this);
|
|
int num_tasks = pending_microtask_count();
|
|
DCHECK(num_tasks <= queue->length());
|
|
if (num_tasks == 0) {
|
|
queue = factory()->NewFixedArray(8);
|
|
heap()->set_microtask_queue(*queue);
|
|
} else if (num_tasks == queue->length()) {
|
|
queue = factory()->CopyFixedArrayAndGrow(queue, num_tasks);
|
|
heap()->set_microtask_queue(*queue);
|
|
}
|
|
DCHECK(queue->get(num_tasks)->IsUndefined());
|
|
queue->set(num_tasks, *microtask);
|
|
set_pending_microtask_count(num_tasks + 1);
|
|
}
|
|
|
|
|
|
void Isolate::RunMicrotasks() {
|
|
// Increase call depth to prevent recursive callbacks.
|
|
v8::Isolate::SuppressMicrotaskExecutionScope suppress(
|
|
reinterpret_cast<v8::Isolate*>(this));
|
|
|
|
while (pending_microtask_count() > 0) {
|
|
HandleScope scope(this);
|
|
int num_tasks = pending_microtask_count();
|
|
Handle<FixedArray> queue(heap()->microtask_queue(), this);
|
|
DCHECK(num_tasks <= queue->length());
|
|
set_pending_microtask_count(0);
|
|
heap()->set_microtask_queue(heap()->empty_fixed_array());
|
|
|
|
for (int i = 0; i < num_tasks; i++) {
|
|
HandleScope scope(this);
|
|
Handle<Object> microtask(queue->get(i), this);
|
|
if (microtask->IsJSFunction()) {
|
|
Handle<JSFunction> microtask_function =
|
|
Handle<JSFunction>::cast(microtask);
|
|
SaveContext save(this);
|
|
set_context(microtask_function->context()->native_context());
|
|
MaybeHandle<Object> maybe_exception;
|
|
MaybeHandle<Object> result = Execution::TryCall(
|
|
this, microtask_function, factory()->undefined_value(), 0, NULL,
|
|
&maybe_exception);
|
|
// If execution is terminating, just bail out.
|
|
Handle<Object> exception;
|
|
if (result.is_null() && maybe_exception.is_null()) {
|
|
// Clear out any remaining callbacks in the queue.
|
|
heap()->set_microtask_queue(heap()->empty_fixed_array());
|
|
set_pending_microtask_count(0);
|
|
return;
|
|
}
|
|
} else {
|
|
Handle<CallHandlerInfo> callback_info =
|
|
Handle<CallHandlerInfo>::cast(microtask);
|
|
v8::MicrotaskCallback callback =
|
|
v8::ToCData<v8::MicrotaskCallback>(callback_info->callback());
|
|
void* data = v8::ToCData<void*>(callback_info->data());
|
|
callback(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Isolate::SetUseCounterCallback(v8::Isolate::UseCounterCallback callback) {
|
|
DCHECK(!use_counter_callback_);
|
|
use_counter_callback_ = callback;
|
|
}
|
|
|
|
|
|
void Isolate::CountUsage(v8::Isolate::UseCounterFeature feature) {
|
|
// The counter callback may cause the embedder to call into V8, which is not
|
|
// generally possible during GC.
|
|
if (heap_.gc_state() == Heap::NOT_IN_GC) {
|
|
if (use_counter_callback_) {
|
|
HandleScope handle_scope(this);
|
|
use_counter_callback_(reinterpret_cast<v8::Isolate*>(this), feature);
|
|
}
|
|
} else {
|
|
heap_.IncrementDeferredCount(feature);
|
|
}
|
|
}
|
|
|
|
|
|
BasicBlockProfiler* Isolate::GetOrCreateBasicBlockProfiler() {
|
|
if (basic_block_profiler_ == NULL) {
|
|
basic_block_profiler_ = new BasicBlockProfiler();
|
|
}
|
|
return basic_block_profiler_;
|
|
}
|
|
|
|
|
|
std::string Isolate::GetTurboCfgFileName() {
|
|
if (FLAG_trace_turbo_cfg_file == NULL) {
|
|
std::ostringstream os;
|
|
os << "turbo-" << base::OS::GetCurrentProcessId() << "-" << id() << ".cfg";
|
|
return os.str();
|
|
} else {
|
|
return FLAG_trace_turbo_cfg_file;
|
|
}
|
|
}
|
|
|
|
|
|
// Heap::detached_contexts tracks detached contexts as pairs
|
|
// (number of GC since the context was detached, the context).
|
|
void Isolate::AddDetachedContext(Handle<Context> context) {
|
|
HandleScope scope(this);
|
|
Handle<WeakCell> cell = factory()->NewWeakCell(context);
|
|
Handle<FixedArray> detached_contexts(heap()->detached_contexts());
|
|
int length = detached_contexts->length();
|
|
detached_contexts = factory()->CopyFixedArrayAndGrow(detached_contexts, 2);
|
|
detached_contexts->set(length, Smi::FromInt(0));
|
|
detached_contexts->set(length + 1, *cell);
|
|
heap()->set_detached_contexts(*detached_contexts);
|
|
}
|
|
|
|
|
|
void Isolate::CheckDetachedContextsAfterGC() {
|
|
HandleScope scope(this);
|
|
Handle<FixedArray> detached_contexts(heap()->detached_contexts());
|
|
int length = detached_contexts->length();
|
|
if (length == 0) return;
|
|
int new_length = 0;
|
|
for (int i = 0; i < length; i += 2) {
|
|
int mark_sweeps = Smi::cast(detached_contexts->get(i))->value();
|
|
DCHECK(detached_contexts->get(i + 1)->IsWeakCell());
|
|
WeakCell* cell = WeakCell::cast(detached_contexts->get(i + 1));
|
|
if (!cell->cleared()) {
|
|
detached_contexts->set(new_length, Smi::FromInt(mark_sweeps + 1));
|
|
detached_contexts->set(new_length + 1, cell);
|
|
new_length += 2;
|
|
}
|
|
counters()->detached_context_age_in_gc()->AddSample(mark_sweeps + 1);
|
|
}
|
|
if (FLAG_trace_detached_contexts) {
|
|
PrintF("%d detached contexts are collected out of %d\n",
|
|
length - new_length, length);
|
|
for (int i = 0; i < new_length; i += 2) {
|
|
int mark_sweeps = Smi::cast(detached_contexts->get(i))->value();
|
|
DCHECK(detached_contexts->get(i + 1)->IsWeakCell());
|
|
WeakCell* cell = WeakCell::cast(detached_contexts->get(i + 1));
|
|
if (mark_sweeps > 3) {
|
|
PrintF("detached context 0x%p\n survived %d GCs (leak?)\n",
|
|
static_cast<void*>(cell->value()), mark_sweeps);
|
|
}
|
|
}
|
|
}
|
|
if (new_length == 0) {
|
|
heap()->set_detached_contexts(heap()->empty_fixed_array());
|
|
} else if (new_length < length) {
|
|
heap()->RightTrimFixedArray<Heap::CONCURRENT_TO_SWEEPER>(
|
|
*detached_contexts, length - new_length);
|
|
}
|
|
}
|
|
|
|
|
|
bool StackLimitCheck::JsHasOverflowed(uintptr_t gap) const {
|
|
StackGuard* stack_guard = isolate_->stack_guard();
|
|
#ifdef USE_SIMULATOR
|
|
// The simulator uses a separate JS stack.
|
|
Address jssp_address = Simulator::current(isolate_)->get_sp();
|
|
uintptr_t jssp = reinterpret_cast<uintptr_t>(jssp_address);
|
|
if (jssp - gap < stack_guard->real_jslimit()) return true;
|
|
#endif // USE_SIMULATOR
|
|
return GetCurrentStackPosition() - gap < stack_guard->real_climit();
|
|
}
|
|
|
|
|
|
SaveContext::SaveContext(Isolate* isolate)
|
|
: isolate_(isolate), prev_(isolate->save_context()) {
|
|
if (isolate->context() != NULL) {
|
|
context_ = Handle<Context>(isolate->context());
|
|
}
|
|
isolate->set_save_context(this);
|
|
|
|
c_entry_fp_ = isolate->c_entry_fp(isolate->thread_local_top());
|
|
}
|
|
|
|
|
|
SaveContext::~SaveContext() {
|
|
isolate_->set_context(context_.is_null() ? NULL : *context_);
|
|
isolate_->set_save_context(prev_);
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
AssertNoContextChange::AssertNoContextChange(Isolate* isolate)
|
|
: isolate_(isolate), context_(isolate->context(), isolate) {}
|
|
#endif // DEBUG
|
|
|
|
|
|
bool PostponeInterruptsScope::Intercept(StackGuard::InterruptFlag flag) {
|
|
// First check whether the previous scope intercepts.
|
|
if (prev_ && prev_->Intercept(flag)) return true;
|
|
// Then check whether this scope intercepts.
|
|
if ((flag & intercept_mask_)) {
|
|
intercepted_flags_ |= flag;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace v8
|