mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 01:45:06 +00:00
f97e11f624
The safestack stack pointer is cached when invoking Dart code, and manually restored when jumping over C++ frames for Dart exceptions in Exceptions::JumpToFrame(). fixes #31356 Change-Id: I71c2e86d1d4f24571dd618a5db06fd1277339ebc Reviewed-on: https://dart-review.googlesource.com/23141 Commit-Queue: Zach Anderson <zra@google.com> Reviewed-by: Vyacheslav Egorov <vegorov@google.com>
970 lines
36 KiB
C++
970 lines
36 KiB
C++
// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#include "vm/exceptions.h"
|
|
|
|
#include "platform/address_sanitizer.h"
|
|
|
|
#include "lib/stacktrace.h"
|
|
|
|
#include "vm/dart_api_impl.h"
|
|
#include "vm/dart_entry.h"
|
|
#include "vm/datastream.h"
|
|
#include "vm/debugger.h"
|
|
#include "vm/deopt_instructions.h"
|
|
#include "vm/flags.h"
|
|
#include "vm/log.h"
|
|
#include "vm/longjump.h"
|
|
#include "vm/object.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/stack_frame.h"
|
|
#include "vm/stub_code.h"
|
|
#include "vm/symbols.h"
|
|
#include "vm/tags.h"
|
|
|
|
namespace dart {
|
|
|
|
DECLARE_FLAG(bool, trace_deoptimization);
|
|
DEFINE_FLAG(bool,
|
|
print_stacktrace_at_throw,
|
|
false,
|
|
"Prints a stack trace everytime a throw occurs.");
|
|
|
|
class StackTraceBuilder : public ValueObject {
|
|
public:
|
|
StackTraceBuilder() {}
|
|
virtual ~StackTraceBuilder() {}
|
|
|
|
virtual void AddFrame(const Code& code, const Smi& offset) = 0;
|
|
};
|
|
|
|
class RegularStackTraceBuilder : public StackTraceBuilder {
|
|
public:
|
|
explicit RegularStackTraceBuilder(Zone* zone)
|
|
: code_list_(
|
|
GrowableObjectArray::Handle(zone, GrowableObjectArray::New())),
|
|
pc_offset_list_(
|
|
GrowableObjectArray::Handle(zone, GrowableObjectArray::New())) {}
|
|
~RegularStackTraceBuilder() {}
|
|
|
|
const GrowableObjectArray& code_list() const { return code_list_; }
|
|
const GrowableObjectArray& pc_offset_list() const { return pc_offset_list_; }
|
|
|
|
virtual void AddFrame(const Code& code, const Smi& offset) {
|
|
code_list_.Add(code);
|
|
pc_offset_list_.Add(offset);
|
|
}
|
|
|
|
private:
|
|
const GrowableObjectArray& code_list_;
|
|
const GrowableObjectArray& pc_offset_list_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(RegularStackTraceBuilder);
|
|
};
|
|
|
|
class PreallocatedStackTraceBuilder : public StackTraceBuilder {
|
|
public:
|
|
explicit PreallocatedStackTraceBuilder(const Instance& stacktrace)
|
|
: stacktrace_(StackTrace::Cast(stacktrace)),
|
|
cur_index_(0),
|
|
dropped_frames_(0) {
|
|
ASSERT(stacktrace_.raw() ==
|
|
Isolate::Current()->object_store()->preallocated_stack_trace());
|
|
}
|
|
~PreallocatedStackTraceBuilder() {}
|
|
|
|
virtual void AddFrame(const Code& code, const Smi& offset);
|
|
|
|
private:
|
|
static const int kNumTopframes = StackTrace::kPreallocatedStackdepth / 2;
|
|
|
|
const StackTrace& stacktrace_;
|
|
intptr_t cur_index_;
|
|
intptr_t dropped_frames_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(PreallocatedStackTraceBuilder);
|
|
};
|
|
|
|
void PreallocatedStackTraceBuilder::AddFrame(const Code& code,
|
|
const Smi& offset) {
|
|
if (cur_index_ >= StackTrace::kPreallocatedStackdepth) {
|
|
// The number of frames is overflowing the preallocated stack trace object.
|
|
Code& frame_code = Code::Handle();
|
|
Smi& frame_offset = Smi::Handle();
|
|
intptr_t start = StackTrace::kPreallocatedStackdepth - (kNumTopframes - 1);
|
|
intptr_t null_slot = start - 2;
|
|
// We are going to drop one frame.
|
|
dropped_frames_++;
|
|
// Add an empty slot to indicate the overflow so that the toString
|
|
// method can account for the overflow.
|
|
if (stacktrace_.CodeAtFrame(null_slot) != Code::null()) {
|
|
stacktrace_.SetCodeAtFrame(null_slot, frame_code);
|
|
// We drop an extra frame here too.
|
|
dropped_frames_++;
|
|
}
|
|
// Encode the number of dropped frames into the pc offset.
|
|
frame_offset ^= Smi::New(dropped_frames_);
|
|
stacktrace_.SetPcOffsetAtFrame(null_slot, frame_offset);
|
|
// Move frames one slot down so that we can accommodate the new frame.
|
|
for (intptr_t i = start; i < StackTrace::kPreallocatedStackdepth; i++) {
|
|
intptr_t prev = (i - 1);
|
|
frame_code = stacktrace_.CodeAtFrame(i);
|
|
frame_offset = stacktrace_.PcOffsetAtFrame(i);
|
|
stacktrace_.SetCodeAtFrame(prev, frame_code);
|
|
stacktrace_.SetPcOffsetAtFrame(prev, frame_offset);
|
|
}
|
|
cur_index_ = (StackTrace::kPreallocatedStackdepth - 1);
|
|
}
|
|
stacktrace_.SetCodeAtFrame(cur_index_, code);
|
|
stacktrace_.SetPcOffsetAtFrame(cur_index_, offset);
|
|
cur_index_ += 1;
|
|
}
|
|
|
|
static void BuildStackTrace(StackTraceBuilder* builder) {
|
|
StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
|
|
Thread::Current(),
|
|
StackFrameIterator::kNoCrossThreadIteration);
|
|
StackFrame* frame = frames.NextFrame();
|
|
ASSERT(frame != NULL); // We expect to find a dart invocation frame.
|
|
Code& code = Code::Handle();
|
|
Smi& offset = Smi::Handle();
|
|
while (frame != NULL) {
|
|
if (frame->IsDartFrame()) {
|
|
code = frame->LookupDartCode();
|
|
ASSERT(code.ContainsInstructionAt(frame->pc()));
|
|
offset = Smi::New(frame->pc() - code.PayloadStart());
|
|
builder->AddFrame(code, offset);
|
|
}
|
|
frame = frames.NextFrame();
|
|
}
|
|
}
|
|
|
|
static RawObject** VariableAt(uword fp, int stack_slot) {
|
|
#if defined(TARGET_ARCH_DBC)
|
|
return reinterpret_cast<RawObject**>(fp + stack_slot * kWordSize);
|
|
#else
|
|
if (stack_slot < 0) {
|
|
return reinterpret_cast<RawObject**>(ParamAddress(fp, -stack_slot));
|
|
} else {
|
|
return reinterpret_cast<RawObject**>(
|
|
LocalVarAddress(fp, kFirstLocalSlotFromFp - stack_slot));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
class ExceptionHandlerFinder : public StackResource {
|
|
public:
|
|
explicit ExceptionHandlerFinder(Thread* thread)
|
|
: StackResource(thread), thread_(thread), cache_(NULL), metadata_(NULL) {}
|
|
|
|
// Iterate through the stack frames and try to find a frame with an
|
|
// exception handler. Once found, set the pc, sp and fp so that execution
|
|
// can continue in that frame. Sets 'needs_stacktrace' if there is no
|
|
// cath-all handler or if a stack-trace is specified in the catch.
|
|
bool Find() {
|
|
StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
|
|
Thread::Current(),
|
|
StackFrameIterator::kNoCrossThreadIteration);
|
|
StackFrame* frame = frames.NextFrame();
|
|
if (frame == NULL) return false; // No Dart frame.
|
|
handler_pc_set_ = false;
|
|
needs_stacktrace = false;
|
|
bool is_catch_all = false;
|
|
uword temp_handler_pc = kUwordMax;
|
|
bool is_optimized = false;
|
|
code_ = NULL;
|
|
cache_ = thread_->isolate()->catch_entry_state_cache();
|
|
|
|
while (!frame->IsEntryFrame()) {
|
|
if (frame->IsDartFrame()) {
|
|
if (frame->FindExceptionHandler(thread_, &temp_handler_pc,
|
|
&needs_stacktrace, &is_catch_all,
|
|
&is_optimized)) {
|
|
if (!handler_pc_set_) {
|
|
handler_pc_set_ = true;
|
|
handler_pc = temp_handler_pc;
|
|
handler_sp = frame->sp();
|
|
handler_fp = frame->fp();
|
|
if (is_optimized) {
|
|
pc_ = frame->pc();
|
|
code_ = &Code::Handle(frame->LookupDartCode());
|
|
CatchEntryState* state = cache_->Lookup(pc_);
|
|
if (state != NULL) cached_ = *state;
|
|
#if !defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_PRECOMPILER)
|
|
intptr_t num_vars = Smi::Value(code_->variables());
|
|
if (cached_.Empty()) GetMetaDataFromDeopt(num_vars, frame);
|
|
#else
|
|
if (cached_.Empty()) ReadCompressedMetaData();
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_PRECOMPILER)
|
|
}
|
|
}
|
|
if (needs_stacktrace || is_catch_all) {
|
|
return true;
|
|
}
|
|
}
|
|
} // if frame->IsDartFrame
|
|
frame = frames.NextFrame();
|
|
ASSERT(frame != NULL);
|
|
} // while !frame->IsEntryFrame
|
|
ASSERT(frame->IsEntryFrame());
|
|
if (!handler_pc_set_) {
|
|
handler_pc = frame->pc();
|
|
handler_sp = frame->sp();
|
|
handler_fp = frame->fp();
|
|
}
|
|
// No catch-all encountered, needs stacktrace.
|
|
needs_stacktrace = true;
|
|
return handler_pc_set_;
|
|
}
|
|
|
|
void TrySync() {
|
|
if (code_ == NULL || !code_->is_optimized()) {
|
|
return;
|
|
}
|
|
if (!cached_.Empty()) {
|
|
// Cache hit.
|
|
TrySyncCached(&cached_);
|
|
} else {
|
|
// New cache entry.
|
|
CatchEntryState m(metadata_);
|
|
TrySyncCached(&m);
|
|
cache_->Insert(pc_, m);
|
|
}
|
|
}
|
|
|
|
void TrySyncCached(CatchEntryState* md) {
|
|
uword fp = handler_fp;
|
|
ObjectPool* pool = NULL;
|
|
intptr_t pairs = md->Pairs();
|
|
for (int j = 0; j < pairs; j++) {
|
|
intptr_t src = md->Src(j);
|
|
intptr_t dest = md->Dest(j);
|
|
if (md->isMove(j)) {
|
|
*VariableAt(fp, dest) = *VariableAt(fp, src);
|
|
} else {
|
|
if (pool == NULL) {
|
|
pool = &ObjectPool::Handle(code_->object_pool());
|
|
}
|
|
RawObject* obj = pool->ObjectAt(src);
|
|
*VariableAt(fp, dest) = obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(DART_PRECOMPILED_RUNTIME) || defined(DART_PRECOMPILER)
|
|
void ReadCompressedMetaData() {
|
|
intptr_t pc_offset = pc_ - code_->PayloadStart();
|
|
const TypedData& td = TypedData::Handle(code_->catch_entry_state_maps());
|
|
NoSafepointScope no_safepoint;
|
|
ReadStream stream(static_cast<uint8_t*>(td.DataAddr(0)), td.Length());
|
|
|
|
bool found_metadata = false;
|
|
while (stream.PendingBytes() > 0) {
|
|
intptr_t target_pc_offset = Reader::Read(&stream);
|
|
intptr_t variables = Reader::Read(&stream);
|
|
intptr_t suffix_length = Reader::Read(&stream);
|
|
intptr_t suffix_offset = Reader::Read(&stream);
|
|
if (pc_offset == target_pc_offset) {
|
|
metadata_ = new intptr_t[2 * (variables + suffix_length) + 1];
|
|
metadata_[0] = variables + suffix_length;
|
|
for (int j = 0; j < variables; j++) {
|
|
intptr_t src = Reader::Read(&stream);
|
|
intptr_t dest = Reader::Read(&stream);
|
|
metadata_[1 + 2 * j] = src;
|
|
metadata_[2 + 2 * j] = dest;
|
|
}
|
|
ReadCompressedSuffix(&stream, suffix_offset, suffix_length, metadata_,
|
|
2 * variables + 1);
|
|
found_metadata = true;
|
|
break;
|
|
} else {
|
|
for (intptr_t j = 0; j < 2 * variables; j++) {
|
|
Reader::Read(&stream);
|
|
}
|
|
}
|
|
}
|
|
ASSERT(found_metadata);
|
|
}
|
|
|
|
void ReadCompressedSuffix(ReadStream* stream,
|
|
intptr_t offset,
|
|
intptr_t length,
|
|
intptr_t* target,
|
|
intptr_t target_offset) {
|
|
stream->SetPosition(offset);
|
|
Reader::Read(stream); // skip pc_offset
|
|
Reader::Read(stream); // skip variables
|
|
intptr_t suffix_length = Reader::Read(stream);
|
|
intptr_t suffix_offset = Reader::Read(stream);
|
|
intptr_t to_read = length - suffix_length;
|
|
for (int j = 0; j < to_read; j++) {
|
|
target[target_offset + 2 * j] = Reader::Read(stream);
|
|
target[target_offset + 2 * j + 1] = Reader::Read(stream);
|
|
}
|
|
if (suffix_length > 0) {
|
|
ReadCompressedSuffix(stream, suffix_offset, suffix_length, target,
|
|
target_offset + to_read * 2);
|
|
}
|
|
}
|
|
|
|
#else
|
|
void GetMetaDataFromDeopt(intptr_t num_vars, StackFrame* frame) {
|
|
Isolate* isolate = thread_->isolate();
|
|
DeoptContext* deopt_context =
|
|
new DeoptContext(frame, *code_, DeoptContext::kDestIsAllocated, NULL,
|
|
NULL, true, false /* deoptimizing_code */);
|
|
isolate->set_deopt_context(deopt_context);
|
|
|
|
metadata_ = deopt_context->CatchEntryState(num_vars);
|
|
|
|
isolate->set_deopt_context(NULL);
|
|
delete deopt_context;
|
|
}
|
|
#endif // defined(DART_PRECOMPILED_RUNTIME) || defined(DART_PRECOMPILER)
|
|
|
|
bool needs_stacktrace;
|
|
uword handler_pc;
|
|
uword handler_sp;
|
|
uword handler_fp;
|
|
|
|
private:
|
|
typedef ReadStream::Raw<sizeof(intptr_t), intptr_t> Reader;
|
|
Thread* thread_;
|
|
CatchEntryStateCache* cache_;
|
|
Code* code_;
|
|
bool handler_pc_set_;
|
|
intptr_t* metadata_; // MetaData generated from deopt.
|
|
CatchEntryState cached_; // Value of per PC MetaData cache.
|
|
intptr_t pc_; // Current pc in the handler frame.
|
|
};
|
|
|
|
static void FindErrorHandler(uword* handler_pc,
|
|
uword* handler_sp,
|
|
uword* handler_fp) {
|
|
StackFrameIterator frames(StackFrameIterator::kDontValidateFrames,
|
|
Thread::Current(),
|
|
StackFrameIterator::kNoCrossThreadIteration);
|
|
StackFrame* frame = frames.NextFrame();
|
|
ASSERT(frame != NULL);
|
|
while (!frame->IsEntryFrame()) {
|
|
frame = frames.NextFrame();
|
|
ASSERT(frame != NULL);
|
|
}
|
|
ASSERT(frame->IsEntryFrame());
|
|
*handler_pc = frame->pc();
|
|
*handler_sp = frame->sp();
|
|
*handler_fp = frame->fp();
|
|
}
|
|
|
|
static uword RemapExceptionPCForDeopt(Thread* thread,
|
|
uword program_counter,
|
|
uword frame_pointer) {
|
|
#if !defined(TARGET_ARCH_DBC)
|
|
MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
|
|
thread->isolate()->pending_deopts();
|
|
if (pending_deopts->length() > 0) {
|
|
// Check if the target frame is scheduled for lazy deopt.
|
|
for (intptr_t i = 0; i < pending_deopts->length(); i++) {
|
|
if ((*pending_deopts)[i].fp() == frame_pointer) {
|
|
// Deopt should now resume in the catch handler instead of after the
|
|
// call.
|
|
(*pending_deopts)[i].set_pc(program_counter);
|
|
|
|
// Jump to the deopt stub instead of the catch handler.
|
|
program_counter =
|
|
StubCode::DeoptimizeLazyFromThrow_entry()->EntryPoint();
|
|
if (FLAG_trace_deoptimization) {
|
|
THR_Print("Throwing to frame scheduled for lazy deopt fp=%" Pp "\n",
|
|
frame_pointer);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif // !DBC
|
|
return program_counter;
|
|
}
|
|
|
|
static void ClearLazyDeopts(Thread* thread, uword frame_pointer) {
|
|
#if !defined(TARGET_ARCH_DBC)
|
|
MallocGrowableArray<PendingLazyDeopt>* pending_deopts =
|
|
thread->isolate()->pending_deopts();
|
|
if (pending_deopts->length() > 0) {
|
|
// We may be jumping over frames scheduled for lazy deopt. Remove these
|
|
// frames from the pending deopt table, but only after unmarking them so
|
|
// any stack walk that happens before the stack is unwound will still work.
|
|
{
|
|
DartFrameIterator frames(thread,
|
|
StackFrameIterator::kNoCrossThreadIteration);
|
|
StackFrame* frame = frames.NextFrame();
|
|
while ((frame != NULL) && (frame->fp() < frame_pointer)) {
|
|
if (frame->IsMarkedForLazyDeopt()) {
|
|
frame->UnmarkForLazyDeopt();
|
|
}
|
|
frame = frames.NextFrame();
|
|
}
|
|
}
|
|
|
|
#if defined(DEBUG)
|
|
ValidateFrames();
|
|
#endif
|
|
|
|
for (intptr_t i = 0; i < pending_deopts->length(); i++) {
|
|
if ((*pending_deopts)[i].fp() < frame_pointer) {
|
|
if (FLAG_trace_deoptimization) {
|
|
THR_Print(
|
|
"Lazy deopt skipped due to throw for "
|
|
"fp=%" Pp ", pc=%" Pp "\n",
|
|
(*pending_deopts)[i].fp(), (*pending_deopts)[i].pc());
|
|
}
|
|
pending_deopts->RemoveAt(i);
|
|
}
|
|
}
|
|
|
|
#if defined(DEBUG)
|
|
ValidateFrames();
|
|
#endif
|
|
}
|
|
#endif // !DBC
|
|
}
|
|
|
|
static void JumpToExceptionHandler(Thread* thread,
|
|
uword program_counter,
|
|
uword stack_pointer,
|
|
uword frame_pointer,
|
|
const Object& exception_object,
|
|
const Object& stacktrace_object) {
|
|
uword remapped_pc =
|
|
RemapExceptionPCForDeopt(thread, program_counter, frame_pointer);
|
|
thread->set_active_exception(exception_object);
|
|
thread->set_active_stacktrace(stacktrace_object);
|
|
thread->set_resume_pc(remapped_pc);
|
|
uword run_exception_pc = StubCode::RunExceptionHandler_entry()->EntryPoint();
|
|
Exceptions::JumpToFrame(thread, run_exception_pc, stack_pointer,
|
|
frame_pointer, false /* do not clear deopt */);
|
|
}
|
|
|
|
NO_SANITIZE_SAFE_STACK // This function manipulates the safestack pointer.
|
|
void Exceptions::JumpToFrame(Thread* thread,
|
|
uword program_counter,
|
|
uword stack_pointer,
|
|
uword frame_pointer,
|
|
bool clear_deopt_at_target) {
|
|
uword fp_for_clearing =
|
|
(clear_deopt_at_target ? frame_pointer + 1 : frame_pointer);
|
|
ClearLazyDeopts(thread, fp_for_clearing);
|
|
#if defined(USING_SIMULATOR)
|
|
// Unwinding of the C++ frames and destroying of their stack resources is done
|
|
// by the simulator, because the target stack_pointer is a simulated stack
|
|
// pointer and not the C++ stack pointer.
|
|
|
|
// Continue simulating at the given pc in the given frame after setting up the
|
|
// exception object in the kExceptionObjectReg register and the stacktrace
|
|
// object (may be raw null) in the kStackTraceObjectReg register.
|
|
|
|
Simulator::Current()->JumpToFrame(program_counter, stack_pointer,
|
|
frame_pointer, thread);
|
|
#else
|
|
// Prepare for unwinding frames by destroying all the stack resources
|
|
// in the previous frames.
|
|
StackResource::Unwind(thread);
|
|
|
|
// Call a stub to set up the exception object in kExceptionObjectReg,
|
|
// to set up the stacktrace object in kStackTraceObjectReg, and to
|
|
// continue execution at the given pc in the given frame.
|
|
typedef void (*ExcpHandler)(uword, uword, uword, Thread*);
|
|
ExcpHandler func = reinterpret_cast<ExcpHandler>(
|
|
StubCode::JumpToFrame_entry()->EntryPoint());
|
|
|
|
// Unpoison the stack before we tear it down in the generated stub code.
|
|
uword current_sp = Thread::GetCurrentStackPointer() - 1024;
|
|
ASAN_UNPOISON(reinterpret_cast<void*>(current_sp),
|
|
stack_pointer - current_sp);
|
|
|
|
// We are jumping over C++ frames, so we have to set the safestack pointer
|
|
// back to what it was when we entered the runtime from Dart code.
|
|
#if defined(USING_SAFE_STACK)
|
|
const uword saved_ssp = thread->saved_safestack_limit();
|
|
OSThread::SetCurrentSafestackPointer(saved_ssp);
|
|
#endif
|
|
|
|
func(program_counter, stack_pointer, frame_pointer, thread);
|
|
#endif
|
|
UNREACHABLE();
|
|
}
|
|
|
|
static RawField* LookupStackTraceField(const Instance& instance) {
|
|
if (instance.GetClassId() < kNumPredefinedCids) {
|
|
// 'class Error' is not a predefined class.
|
|
return Field::null();
|
|
}
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
Isolate* isolate = thread->isolate();
|
|
Class& error_class =
|
|
Class::Handle(zone, isolate->object_store()->error_class());
|
|
if (error_class.IsNull()) {
|
|
const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
|
|
error_class = core_lib.LookupClass(Symbols::Error());
|
|
ASSERT(!error_class.IsNull());
|
|
isolate->object_store()->set_error_class(error_class);
|
|
}
|
|
// If instance class extends 'class Error' return '_stackTrace' field.
|
|
Class& test_class = Class::Handle(zone, instance.clazz());
|
|
AbstractType& type = AbstractType::Handle(zone, AbstractType::null());
|
|
while (true) {
|
|
if (test_class.raw() == error_class.raw()) {
|
|
return error_class.LookupInstanceFieldAllowPrivate(
|
|
Symbols::_stackTrace());
|
|
}
|
|
type = test_class.super_type();
|
|
if (type.IsNull()) return Field::null();
|
|
test_class = type.type_class();
|
|
}
|
|
UNREACHABLE();
|
|
return Field::null();
|
|
}
|
|
|
|
RawStackTrace* Exceptions::CurrentStackTrace() {
|
|
return GetStackTraceForException();
|
|
}
|
|
|
|
static void ThrowExceptionHelper(Thread* thread,
|
|
const Instance& incoming_exception,
|
|
const Instance& existing_stacktrace,
|
|
const bool is_rethrow) {
|
|
Zone* zone = thread->zone();
|
|
Isolate* isolate = thread->isolate();
|
|
bool use_preallocated_stacktrace = false;
|
|
Instance& exception = Instance::Handle(zone, incoming_exception.raw());
|
|
if (exception.IsNull()) {
|
|
exception ^=
|
|
Exceptions::Create(Exceptions::kNullThrown, Object::empty_array());
|
|
} else if (exception.raw() == isolate->object_store()->out_of_memory() ||
|
|
exception.raw() == isolate->object_store()->stack_overflow()) {
|
|
use_preallocated_stacktrace = true;
|
|
}
|
|
// Find the exception handler and determine if the handler needs a
|
|
// stacktrace.
|
|
ExceptionHandlerFinder finder(thread);
|
|
bool handler_exists = finder.Find();
|
|
uword handler_pc = finder.handler_pc;
|
|
uword handler_sp = finder.handler_sp;
|
|
uword handler_fp = finder.handler_fp;
|
|
bool handler_needs_stacktrace = finder.needs_stacktrace;
|
|
Instance& stacktrace = Instance::Handle(zone);
|
|
if (use_preallocated_stacktrace) {
|
|
if (handler_pc == 0) {
|
|
// No Dart frame.
|
|
ASSERT(incoming_exception.raw() ==
|
|
isolate->object_store()->out_of_memory());
|
|
const UnhandledException& error = UnhandledException::Handle(
|
|
zone, isolate->object_store()->preallocated_unhandled_exception());
|
|
thread->long_jump_base()->Jump(1, error);
|
|
UNREACHABLE();
|
|
}
|
|
stacktrace ^= isolate->object_store()->preallocated_stack_trace();
|
|
PreallocatedStackTraceBuilder frame_builder(stacktrace);
|
|
ASSERT(existing_stacktrace.IsNull() ||
|
|
(existing_stacktrace.raw() == stacktrace.raw()));
|
|
ASSERT(existing_stacktrace.IsNull() || is_rethrow);
|
|
if (handler_needs_stacktrace && existing_stacktrace.IsNull()) {
|
|
BuildStackTrace(&frame_builder);
|
|
}
|
|
} else {
|
|
if (!existing_stacktrace.IsNull()) {
|
|
// If we have an existing stack trace then this better be a rethrow. The
|
|
// reverse is not necessarily true (e.g. Dart_PropagateError can cause
|
|
// a rethrow being called without an existing stacktrace.)
|
|
ASSERT(is_rethrow);
|
|
stacktrace = existing_stacktrace.raw();
|
|
} else {
|
|
// Get stacktrace field of class Error to determine whether we have a
|
|
// subclass of Error which carries around its stack trace.
|
|
const Field& stacktrace_field =
|
|
Field::Handle(zone, LookupStackTraceField(exception));
|
|
if (!stacktrace_field.IsNull() || handler_needs_stacktrace) {
|
|
// Collect the stacktrace if needed.
|
|
ASSERT(existing_stacktrace.IsNull());
|
|
stacktrace = Exceptions::CurrentStackTrace();
|
|
// If we have an Error object, then set its stackTrace field only if it
|
|
// not yet initialized.
|
|
if (!stacktrace_field.IsNull() &&
|
|
(exception.GetField(stacktrace_field) == Object::null())) {
|
|
exception.SetField(stacktrace_field, stacktrace);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// We expect to find a handler_pc, if the exception is unhandled
|
|
// then we expect to at least have the dart entry frame on the
|
|
// stack as Exceptions::Throw should happen only after a dart
|
|
// invocation has been done.
|
|
ASSERT(handler_pc != 0);
|
|
|
|
if (FLAG_print_stacktrace_at_throw) {
|
|
THR_Print("Exception '%s' thrown:\n", exception.ToCString());
|
|
THR_Print("%s\n", stacktrace.ToCString());
|
|
}
|
|
if (handler_exists) {
|
|
finder.TrySync();
|
|
// Found a dart handler for the exception, jump to it.
|
|
JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
|
|
exception, stacktrace);
|
|
} else {
|
|
// No dart exception handler found in this invocation sequence,
|
|
// so we create an unhandled exception object and return to the
|
|
// invocation stub so that it returns this unhandled exception
|
|
// object. The C++ code which invoked this dart sequence can check
|
|
// and do the appropriate thing (rethrow the exception to the
|
|
// dart invocation sequence above it, print diagnostics and terminate
|
|
// the isolate etc.).
|
|
const UnhandledException& unhandled_exception = UnhandledException::Handle(
|
|
zone, UnhandledException::New(exception, stacktrace));
|
|
stacktrace = StackTrace::null();
|
|
JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
|
|
unhandled_exception, stacktrace);
|
|
}
|
|
UNREACHABLE();
|
|
}
|
|
|
|
// Static helpers for allocating, initializing, and throwing an error instance.
|
|
|
|
// Return the script of the Dart function that called the native entry or the
|
|
// runtime entry. The frame iterator points to the callee.
|
|
RawScript* Exceptions::GetCallerScript(DartFrameIterator* iterator) {
|
|
StackFrame* caller_frame = iterator->NextFrame();
|
|
ASSERT(caller_frame != NULL && caller_frame->IsDartFrame());
|
|
const Function& caller = Function::Handle(caller_frame->LookupDartFunction());
|
|
ASSERT(!caller.IsNull());
|
|
return caller.script();
|
|
}
|
|
|
|
// Allocate a new instance of the given class name.
|
|
// TODO(hausner): Rename this NewCoreInstance to call out the fact that
|
|
// the class name is resolved in the core library implicitly?
|
|
RawInstance* Exceptions::NewInstance(const char* class_name) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
const String& cls_name =
|
|
String::Handle(zone, Symbols::New(thread, class_name));
|
|
const Library& core_lib = Library::Handle(Library::CoreLibrary());
|
|
// No ambiguity error expected: passing NULL.
|
|
Class& cls = Class::Handle(core_lib.LookupClass(cls_name));
|
|
ASSERT(!cls.IsNull());
|
|
// There are no parameterized error types, so no need to set type arguments.
|
|
return Instance::New(cls);
|
|
}
|
|
|
|
// Allocate, initialize, and throw a TypeError or CastError.
|
|
// If error_msg is not null, throw a TypeError, even for a type cast.
|
|
void Exceptions::CreateAndThrowTypeError(TokenPosition location,
|
|
const AbstractType& src_type,
|
|
const AbstractType& dst_type,
|
|
const String& dst_name,
|
|
const String& bound_error_msg) {
|
|
ASSERT(!dst_name.IsNull()); // Pass Symbols::Empty() instead.
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
const Array& args = Array::Handle(zone, Array::New(4));
|
|
|
|
ExceptionType exception_type =
|
|
(bound_error_msg.IsNull() &&
|
|
(dst_name.raw() == Symbols::InTypeCast().raw()))
|
|
? kCast
|
|
: kType;
|
|
|
|
DartFrameIterator iterator(thread,
|
|
StackFrameIterator::kNoCrossThreadIteration);
|
|
const Script& script = Script::Handle(zone, GetCallerScript(&iterator));
|
|
intptr_t line = -1;
|
|
intptr_t column = -1;
|
|
ASSERT(!script.IsNull());
|
|
if (location.IsReal()) {
|
|
if (script.HasSource() || script.kind() == RawScript::kKernelTag) {
|
|
script.GetTokenLocation(location, &line, &column);
|
|
} else {
|
|
script.GetTokenLocation(location, &line, NULL);
|
|
}
|
|
}
|
|
// Initialize '_url', '_line', and '_column' arguments.
|
|
args.SetAt(0, String::Handle(zone, script.url()));
|
|
args.SetAt(1, Smi::Handle(zone, Smi::New(line)));
|
|
args.SetAt(2, Smi::Handle(zone, Smi::New(column)));
|
|
|
|
// Construct '_errorMsg'.
|
|
const GrowableObjectArray& pieces =
|
|
GrowableObjectArray::Handle(zone, GrowableObjectArray::New(20));
|
|
|
|
// Print bound error first, if any.
|
|
if (!bound_error_msg.IsNull() && (bound_error_msg.Length() > 0)) {
|
|
pieces.Add(bound_error_msg);
|
|
pieces.Add(Symbols::NewLine());
|
|
}
|
|
|
|
// If dst_type is malformed or malbounded, only print the embedded error.
|
|
if (!dst_type.IsNull()) {
|
|
const LanguageError& error = LanguageError::Handle(zone, dst_type.error());
|
|
if (!error.IsNull()) {
|
|
// Print the embedded error only.
|
|
pieces.Add(String::Handle(zone, String::New(error.ToErrorCString())));
|
|
pieces.Add(Symbols::NewLine());
|
|
} else {
|
|
// Describe the type error.
|
|
if (!src_type.IsNull()) {
|
|
pieces.Add(Symbols::TypeQuote());
|
|
pieces.Add(String::Handle(zone, src_type.UserVisibleName()));
|
|
pieces.Add(Symbols::QuoteIsNotASubtypeOf());
|
|
}
|
|
pieces.Add(Symbols::TypeQuote());
|
|
pieces.Add(String::Handle(zone, dst_type.UserVisibleName()));
|
|
pieces.Add(Symbols::SingleQuote());
|
|
if (exception_type == kCast) {
|
|
pieces.Add(dst_name);
|
|
} else if (dst_name.Length() > 0) {
|
|
pieces.Add(Symbols::SpaceOfSpace());
|
|
pieces.Add(Symbols::SingleQuote());
|
|
pieces.Add(dst_name);
|
|
pieces.Add(Symbols::SingleQuote());
|
|
}
|
|
// Print URIs of src and dst types.
|
|
// Do not print "where" when no URIs get printed.
|
|
bool printed_where = false;
|
|
if (!src_type.IsNull()) {
|
|
const String& uris = String::Handle(zone, src_type.EnumerateURIs());
|
|
if (uris.Length() > Symbols::SpaceIsFromSpace().Length()) {
|
|
printed_where = true;
|
|
pieces.Add(Symbols::SpaceWhereNewLine());
|
|
pieces.Add(uris);
|
|
}
|
|
}
|
|
if (!dst_type.IsDynamicType() && !dst_type.IsVoidType()) {
|
|
const String& uris = String::Handle(zone, dst_type.EnumerateURIs());
|
|
if (uris.Length() > Symbols::SpaceIsFromSpace().Length()) {
|
|
if (!printed_where) {
|
|
pieces.Add(Symbols::SpaceWhereNewLine());
|
|
}
|
|
pieces.Add(uris);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const Array& arr = Array::Handle(zone, Array::MakeFixedLength(pieces));
|
|
const String& error_msg = String::Handle(zone, String::ConcatAll(arr));
|
|
args.SetAt(3, error_msg);
|
|
|
|
// Type errors in the core library may be difficult to diagnose.
|
|
// Print type error information before throwing the error when debugging.
|
|
if (FLAG_print_stacktrace_at_throw) {
|
|
THR_Print("'%s': Failed type check: line %" Pd " pos %" Pd ": ",
|
|
String::Handle(zone, script.url()).ToCString(), line, column);
|
|
THR_Print("%s\n", error_msg.ToCString());
|
|
}
|
|
|
|
// Throw TypeError or CastError instance.
|
|
Exceptions::ThrowByType(exception_type, args);
|
|
UNREACHABLE();
|
|
}
|
|
|
|
void Exceptions::Throw(Thread* thread, const Instance& exception) {
|
|
// Do not notify debugger on stack overflow and out of memory exceptions.
|
|
// The VM would crash when the debugger calls back into the VM to
|
|
// get values of variables.
|
|
#if !defined(PRODUCT)
|
|
Isolate* isolate = thread->isolate();
|
|
if (exception.raw() != isolate->object_store()->out_of_memory() &&
|
|
exception.raw() != isolate->object_store()->stack_overflow()) {
|
|
isolate->debugger()->PauseException(exception);
|
|
}
|
|
#endif
|
|
// Null object is a valid exception object.
|
|
ThrowExceptionHelper(thread, exception, StackTrace::Handle(thread->zone()),
|
|
false);
|
|
}
|
|
|
|
void Exceptions::ReThrow(Thread* thread,
|
|
const Instance& exception,
|
|
const Instance& stacktrace) {
|
|
// Null object is a valid exception object.
|
|
ThrowExceptionHelper(thread, exception, stacktrace, true);
|
|
}
|
|
|
|
void Exceptions::PropagateError(const Error& error) {
|
|
Thread* thread = Thread::Current();
|
|
Zone* zone = thread->zone();
|
|
ASSERT(thread->top_exit_frame_info() != 0);
|
|
if (error.IsUnhandledException()) {
|
|
// If the error object represents an unhandled exception, then
|
|
// rethrow the exception in the normal fashion.
|
|
const UnhandledException& uhe = UnhandledException::Cast(error);
|
|
const Instance& exc = Instance::Handle(zone, uhe.exception());
|
|
const Instance& stk = Instance::Handle(zone, uhe.stacktrace());
|
|
Exceptions::ReThrow(thread, exc, stk);
|
|
} else {
|
|
// Return to the invocation stub and return this error object. The
|
|
// C++ code which invoked this dart sequence can check and do the
|
|
// appropriate thing.
|
|
uword handler_pc = 0;
|
|
uword handler_sp = 0;
|
|
uword handler_fp = 0;
|
|
FindErrorHandler(&handler_pc, &handler_sp, &handler_fp);
|
|
JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp, error,
|
|
StackTrace::Handle(zone)); // Null stacktrace.
|
|
}
|
|
UNREACHABLE();
|
|
}
|
|
|
|
void Exceptions::ThrowByType(ExceptionType type, const Array& arguments) {
|
|
Thread* thread = Thread::Current();
|
|
const Object& result =
|
|
Object::Handle(thread->zone(), Create(type, arguments));
|
|
if (result.IsError()) {
|
|
// We got an error while constructing the exception object.
|
|
// Propagate the error instead of throwing the exception.
|
|
PropagateError(Error::Cast(result));
|
|
} else {
|
|
ASSERT(result.IsInstance());
|
|
Throw(thread, Instance::Cast(result));
|
|
}
|
|
}
|
|
|
|
void Exceptions::ThrowOOM() {
|
|
Thread* thread = Thread::Current();
|
|
Isolate* isolate = thread->isolate();
|
|
const Instance& oom = Instance::Handle(
|
|
thread->zone(), isolate->object_store()->out_of_memory());
|
|
Throw(thread, oom);
|
|
}
|
|
|
|
void Exceptions::ThrowStackOverflow() {
|
|
Thread* thread = Thread::Current();
|
|
Isolate* isolate = thread->isolate();
|
|
const Instance& stack_overflow = Instance::Handle(
|
|
thread->zone(), isolate->object_store()->stack_overflow());
|
|
Throw(thread, stack_overflow);
|
|
}
|
|
|
|
void Exceptions::ThrowArgumentError(const Instance& arg) {
|
|
const Array& args = Array::Handle(Array::New(1));
|
|
args.SetAt(0, arg);
|
|
Exceptions::ThrowByType(Exceptions::kArgument, args);
|
|
}
|
|
|
|
void Exceptions::ThrowRangeError(const char* argument_name,
|
|
const Integer& argument_value,
|
|
intptr_t expected_from,
|
|
intptr_t expected_to) {
|
|
const Array& args = Array::Handle(Array::New(4));
|
|
args.SetAt(0, argument_value);
|
|
args.SetAt(1, Integer::Handle(Integer::New(expected_from)));
|
|
args.SetAt(2, Integer::Handle(Integer::New(expected_to)));
|
|
args.SetAt(3, String::Handle(String::New(argument_name)));
|
|
Exceptions::ThrowByType(Exceptions::kRange, args);
|
|
}
|
|
|
|
void Exceptions::ThrowRangeErrorMsg(const char* msg) {
|
|
const Array& args = Array::Handle(Array::New(1));
|
|
args.SetAt(0, String::Handle(String::New(msg)));
|
|
Exceptions::ThrowByType(Exceptions::kRangeMsg, args);
|
|
}
|
|
|
|
void Exceptions::ThrowCompileTimeError(const LanguageError& error) {
|
|
const Array& args = Array::Handle(Array::New(1));
|
|
args.SetAt(0, String::Handle(error.FormatMessage()));
|
|
Exceptions::ThrowByType(Exceptions::kCompileTimeError, args);
|
|
}
|
|
|
|
RawObject* Exceptions::Create(ExceptionType type, const Array& arguments) {
|
|
Library& library = Library::Handle();
|
|
const String* class_name = NULL;
|
|
const String* constructor_name = &Symbols::Dot();
|
|
switch (type) {
|
|
case kNone:
|
|
case kStackOverflow:
|
|
case kOutOfMemory:
|
|
UNREACHABLE();
|
|
break;
|
|
case kRange:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::RangeError();
|
|
constructor_name = &Symbols::DotRange();
|
|
break;
|
|
case kRangeMsg:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::RangeError();
|
|
constructor_name = &Symbols::Dot();
|
|
break;
|
|
case kArgument:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::ArgumentError();
|
|
break;
|
|
case kArgumentValue:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::ArgumentError();
|
|
constructor_name = &Symbols::DotValue();
|
|
break;
|
|
case kNoSuchMethod:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::NoSuchMethodError();
|
|
constructor_name = &Symbols::DotWithType();
|
|
break;
|
|
case kFormat:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::FormatException();
|
|
break;
|
|
case kUnsupported:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::UnsupportedError();
|
|
break;
|
|
case kNullThrown:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::NullThrownError();
|
|
break;
|
|
case kIsolateSpawn:
|
|
library = Library::IsolateLibrary();
|
|
class_name = &Symbols::IsolateSpawnException();
|
|
break;
|
|
case kAssertion:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::AssertionError();
|
|
constructor_name = &Symbols::DotCreate();
|
|
break;
|
|
case kCast:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::CastError();
|
|
constructor_name = &Symbols::DotCreate();
|
|
break;
|
|
case kType:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::TypeError();
|
|
constructor_name = &Symbols::DotCreate();
|
|
break;
|
|
case kFallThrough:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::FallThroughError();
|
|
constructor_name = &Symbols::DotCreate();
|
|
break;
|
|
case kAbstractClassInstantiation:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::AbstractClassInstantiationError();
|
|
constructor_name = &Symbols::DotCreate();
|
|
break;
|
|
case kCyclicInitializationError:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::CyclicInitializationError();
|
|
break;
|
|
case kCompileTimeError:
|
|
library = Library::CoreLibrary();
|
|
class_name = &Symbols::_CompileTimeError();
|
|
break;
|
|
}
|
|
|
|
Thread* thread = Thread::Current();
|
|
NoReloadScope no_reload_scope(thread->isolate(), thread);
|
|
return DartLibraryCalls::InstanceCreate(library, *class_name,
|
|
*constructor_name, arguments);
|
|
}
|
|
|
|
} // namespace dart
|