mirror of
https://github.com/dart-lang/sdk
synced 2024-10-15 00:04:55 +00:00
2280b06202
Improve the handling of code where the async flow forks: e.g. for `fut.whenComplete(c.complete)` we might proceed unwinding through awaiters of `c.future` and forget about the future returned from `whenComplete`. This happens because we choose to present result of the unwinding as a single stack and not a tree. In this situation the error will only propagate into that future and whether or not the error will be handled depends on that future alone. As part of this change also start respecting ignored bit on futures without listeners. TEST=pkg/vm_service/test/pause_on_unhandled_async_exceptions7_test.dart CoreLibraryReviewExempt: Comment only changes to core library Change-Id: I27b689ab07a725e8faa8d91cf40e88ebc8c441a0 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/352904 Reviewed-by: Martin Kustermann <kustermann@google.com> Reviewed-by: Lasse Nielsen <lrn@google.com> Commit-Queue: Slava Egorov <vegorov@google.com>
763 lines
29 KiB
C++
763 lines
29 KiB
C++
// Copyright (c) 2017, 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/stack_trace.h"
|
|
|
|
#include "vm/dart_api_impl.h"
|
|
#include "vm/object_store.h"
|
|
#include "vm/stack_frame.h"
|
|
#include "vm/symbols.h"
|
|
|
|
namespace dart {
|
|
|
|
namespace {
|
|
|
|
// Keep in sync with:
|
|
// - _StreamController._STATE_SUBSCRIBED.
|
|
const intptr_t k_StreamController__STATE_SUBSCRIBED = 1;
|
|
// - _StreamController._STATE_SUBSCRIPTION_MASK.
|
|
const intptr_t k_StreamController__STATE_SUBSCRIPTION_MASK = 3;
|
|
// - _StreamController._STATE_ADDSTREAM.
|
|
const intptr_t k_StreamController__STATE_ADDSTREAM = 8;
|
|
// - _BufferingStreamSubscription._STATE_HAS_ERROR_HANDLER.
|
|
const intptr_t k_BufferingStreamSubscription__STATE_HAS_ERROR_HANDLER = 1 << 5;
|
|
// - _Future._stateIgnoreError
|
|
const intptr_t k_Future__stateIgnoreError = 1;
|
|
// - _FutureListener.stateThen.
|
|
const intptr_t k_FutureListener_stateThen = 1;
|
|
// - _FutureListener.stateCatchError.
|
|
const intptr_t k_FutureListener_stateCatchError = 2;
|
|
// - _FutureListener.stateWhenComplete.
|
|
const intptr_t k_FutureListener_stateWhenComplete = 8;
|
|
// - sdk/lib/async/future_impl.dart:_FutureListener.maskAwait.
|
|
const intptr_t k_FutureListener_maskAwait = 16;
|
|
|
|
bool WasPreviouslySuspended(const Function& function,
|
|
const Object& suspend_state_var) {
|
|
if (!suspend_state_var.IsSuspendState()) {
|
|
return false;
|
|
}
|
|
if (function.IsAsyncFunction()) {
|
|
// Error callback is set after both 'then' and 'error' callbacks are
|
|
// registered with the Zone. Callback registration may query
|
|
// stack trace and should still collect the synchronous stack trace.
|
|
return SuspendState::Cast(suspend_state_var).error_callback() !=
|
|
Object::null();
|
|
} else if (function.IsAsyncGenerator()) {
|
|
return true;
|
|
} else {
|
|
UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
bool TryGetAwaiterLink(const Closure& closure, Object* link) {
|
|
*link = Object::null();
|
|
const auto& function = Function::Handle(closure.function());
|
|
const auto awaiter_link = function.awaiter_link();
|
|
if (awaiter_link.depth != ClosureData::kNoAwaiterLinkDepth) {
|
|
if (function.IsImplicitClosureFunction()) {
|
|
ASSERT(awaiter_link.depth == 0 && awaiter_link.index == 0);
|
|
*link = closure.GetImplicitClosureReceiver();
|
|
return true;
|
|
}
|
|
|
|
auto& context = Context::Handle(closure.GetContext());
|
|
intptr_t depth = awaiter_link.depth;
|
|
while (depth-- > 0) {
|
|
context = context.parent();
|
|
}
|
|
|
|
*link = context.At(awaiter_link.index);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Unwinder which starts by unwinding the synchronous portion of the stack
|
|
// until it reaches a frame which has an asynchronous awaiter (e.g. an
|
|
// activation of the async function which has a listener attached to the
|
|
// corresponding Future object) and then unwinds through the chain
|
|
// of awaiters.
|
|
class AsyncAwareStackUnwinder : public ValueObject {
|
|
public:
|
|
explicit AsyncAwareStackUnwinder(Thread* thread,
|
|
bool* encountered_async_catch_error)
|
|
: zone_(thread->zone()),
|
|
sync_frames_(thread, StackFrameIterator::kNoCrossThreadIteration),
|
|
sync_frame_(nullptr),
|
|
awaiter_frame_{Closure::Handle(zone_), Object::Handle(zone_)},
|
|
encountered_async_catch_error_(encountered_async_catch_error),
|
|
closure_(Closure::Handle(zone_)),
|
|
code_(Code::Handle(zone_)),
|
|
context_(Context::Handle(zone_)),
|
|
function_(Function::Handle(zone_)),
|
|
parent_function_(Function::Handle(zone_)),
|
|
object_(Object::Handle(zone_)),
|
|
result_future_(Object::Handle(zone_)),
|
|
suspend_state_(SuspendState::Handle(zone_)),
|
|
controller_(Object::Handle(zone_)),
|
|
subscription_(Object::Handle(zone_)),
|
|
stream_iterator_(Object::Handle(zone_)),
|
|
async_lib_(Library::Handle(zone_, Library::AsyncLibrary())),
|
|
null_closure_(Closure::Handle(zone_)) {
|
|
if (encountered_async_catch_error_ != nullptr) {
|
|
*encountered_async_catch_error_ = false;
|
|
}
|
|
}
|
|
|
|
void Unwind(intptr_t skip_frames,
|
|
std::function<void(const StackTraceUtils::Frame&)> handle_frame);
|
|
|
|
private:
|
|
bool HandleSynchronousFrame();
|
|
|
|
void UnwindAwaiterFrame();
|
|
|
|
// Returns either the `onData` or the Future awaiter.
|
|
ObjectPtr FindCallerInAsyncStarStreamController(
|
|
const Object& async_star_stream_controller);
|
|
|
|
void InitializeAwaiterFrameFromSuspendState();
|
|
|
|
void InitializeAwaiterFrameFromFutureListener(const Object& listener);
|
|
|
|
void UnwindToAwaiter();
|
|
|
|
// |frame.next| is a |_Future| instance. Unwind to the next frame.
|
|
void UnwindFrameToFutureListener();
|
|
|
|
// |frame.next| is an |_SyncStreamController| instance.
|
|
void UnwindFrameToStreamController();
|
|
|
|
// Follow awaiter-links from the given closure until the first
|
|
// non-closure awaiter-link is encountered.
|
|
//
|
|
// |link| will contain the first non-closure awaiter-link or `null`.
|
|
// |closure| will be updated to point to the last closure in the chain.
|
|
void FollowAwaiterLinks(Closure* closure, Object* link);
|
|
|
|
// Update |awaiter_frame| by unwinding awaiter links of the current closure.
|
|
void ComputeNextFrameFromAwaiterLink();
|
|
|
|
ObjectPtr GetReceiver() const;
|
|
|
|
// Returns |true| if propagating an error to the listeners of this `_Future`
|
|
// will always encounter an error handler. Future handles error iff:
|
|
//
|
|
// * It has no listeners and is marked as ignoring errors
|
|
// * All of its listeners either have an error handler or corresponding
|
|
// result future handles error.
|
|
//
|
|
// Note: this ignores simple error forwarding/rethrow which occurs in `await`
|
|
// or patterns like `fut.then(onError: c.completeError)`.
|
|
bool WillFutureHandleError(const Object& future, intptr_t depth = 0);
|
|
|
|
void MarkAsHandlingAsyncError() const {
|
|
if (ShouldComputeIfAsyncErrorIsHandled()) {
|
|
*encountered_async_catch_error_ = true;
|
|
}
|
|
}
|
|
|
|
bool ShouldComputeIfAsyncErrorIsHandled() const {
|
|
return encountered_async_catch_error_ != nullptr &&
|
|
!*encountered_async_catch_error_;
|
|
}
|
|
|
|
#define USED_CLASS_LIST(V) \
|
|
V(_AsyncStarStreamController) \
|
|
V(_BufferingStreamSubscription) \
|
|
V(_Completer) \
|
|
V(_AsyncCompleter) \
|
|
V(_SyncCompleter) \
|
|
V(_ControllerSubscription) \
|
|
V(_Future) \
|
|
V(_FutureListener) \
|
|
V(_StreamController) \
|
|
V(_StreamIterator) \
|
|
V(_SyncStreamController) \
|
|
V(_StreamControllerAddStreamState) \
|
|
V(_AddStreamState)
|
|
|
|
enum ClassId {
|
|
#define DECLARE_CONSTANT(symbol) k##symbol,
|
|
USED_CLASS_LIST(DECLARE_CONSTANT)
|
|
#undef DECLARE_CONSTANT
|
|
};
|
|
|
|
#define USED_FIELD_LIST(V) \
|
|
V(_AsyncStarStreamController, asyncStarBody) \
|
|
V(_AsyncStarStreamController, controller) \
|
|
V(_BufferingStreamSubscription, _onData) \
|
|
V(_BufferingStreamSubscription, _onDone) \
|
|
V(_BufferingStreamSubscription, _onError) \
|
|
V(_BufferingStreamSubscription, _state) \
|
|
V(_Completer, future) \
|
|
V(_Future, _resultOrListeners) \
|
|
V(_Future, _state) \
|
|
V(_FutureListener, callback) \
|
|
V(_FutureListener, result) \
|
|
V(_FutureListener, state) \
|
|
V(_FutureListener, _nextListener) \
|
|
V(_StreamController, _state) \
|
|
V(_StreamController, _varData) \
|
|
V(_StreamControllerAddStreamState, _varData) \
|
|
V(_StreamIterator, _hasValue) \
|
|
V(_StreamIterator, _stateData) \
|
|
V(_AddStreamState, addStreamFuture)
|
|
|
|
enum FieldId {
|
|
#define DECLARE_CONSTANT(class_symbol, field_symbol) \
|
|
k##class_symbol##_##field_symbol,
|
|
USED_FIELD_LIST(DECLARE_CONSTANT)
|
|
#undef DECLARE_CONSTANT
|
|
};
|
|
|
|
#define PLUS_ONE(...) +1
|
|
static constexpr intptr_t kUsedClassCount = 0 USED_CLASS_LIST(PLUS_ONE);
|
|
static constexpr intptr_t kUsedFieldCount = 0 USED_FIELD_LIST(PLUS_ONE);
|
|
#undef PLUS_ONE
|
|
|
|
#define DECLARE_GETTER(symbol) \
|
|
const Class& symbol() { \
|
|
auto& cls = classes_[k##symbol]; \
|
|
if (cls == nullptr) { \
|
|
cls = &Class::Handle( \
|
|
zone_, async_lib_.LookupClassAllowPrivate(Symbols::symbol())); \
|
|
ASSERT(!cls->IsNull()); \
|
|
} \
|
|
return *cls; \
|
|
}
|
|
USED_CLASS_LIST(DECLARE_GETTER)
|
|
#undef DECLARE_GETTER
|
|
|
|
#define DECLARE_GETTER(class_symbol, field_symbol) \
|
|
ObjectPtr Get##class_symbol##_##field_symbol(const Object& obj) { \
|
|
auto& field = fields_[k##class_symbol##_##field_symbol]; \
|
|
if (field == nullptr) { \
|
|
field = &Field::Handle(zone_, class_symbol().LookupFieldAllowPrivate( \
|
|
Symbols::field_symbol())); \
|
|
ASSERT(!field->IsNull()); \
|
|
} \
|
|
return Instance::Cast(obj).GetField(*field); \
|
|
}
|
|
USED_FIELD_LIST(DECLARE_GETTER)
|
|
#undef DECLARE_GETTER
|
|
|
|
struct AwaiterFrame {
|
|
Closure& closure;
|
|
Object& next;
|
|
};
|
|
|
|
Zone* zone_;
|
|
DartFrameIterator sync_frames_;
|
|
|
|
StackFrame* sync_frame_;
|
|
AwaiterFrame awaiter_frame_;
|
|
|
|
bool* encountered_async_catch_error_;
|
|
|
|
Closure& closure_;
|
|
Code& code_;
|
|
Context& context_;
|
|
Function& function_;
|
|
Function& parent_function_;
|
|
Object& object_;
|
|
Object& result_future_;
|
|
SuspendState& suspend_state_;
|
|
|
|
Object& controller_;
|
|
Object& subscription_;
|
|
Object& stream_iterator_;
|
|
|
|
const Library& async_lib_;
|
|
Class* classes_[kUsedClassCount] = {};
|
|
Field* fields_[kUsedFieldCount] = {};
|
|
|
|
const Closure& null_closure_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(AsyncAwareStackUnwinder);
|
|
};
|
|
|
|
void AsyncAwareStackUnwinder::Unwind(
|
|
intptr_t skip_frames,
|
|
std::function<void(const StackTraceUtils::Frame&)> handle_frame) {
|
|
// First skip the given number of synchronous frames.
|
|
sync_frame_ = sync_frames_.NextFrame();
|
|
while (skip_frames > 0 && sync_frame_ != nullptr) {
|
|
sync_frame_ = sync_frames_.NextFrame();
|
|
skip_frames--;
|
|
}
|
|
|
|
// Continue unwinding synchronous portion of the stack looking for
|
|
// a synchronous frame which has an awaiter.
|
|
while (sync_frame_ != nullptr && awaiter_frame_.closure.IsNull()) {
|
|
const bool was_handled = HandleSynchronousFrame();
|
|
if (!was_handled) {
|
|
code_ = sync_frame_->LookupDartCode();
|
|
const uword pc_offset = sync_frame_->pc() - code_.PayloadStart();
|
|
handle_frame({sync_frame_, code_, pc_offset, null_closure_});
|
|
}
|
|
sync_frame_ = sync_frames_.NextFrame();
|
|
}
|
|
|
|
const StackTraceUtils::Frame gap_frame = {nullptr,
|
|
StubCode::AsynchronousGapMarker(),
|
|
/*pc_offset=*/0, null_closure_};
|
|
|
|
// Traverse awaiter frames.
|
|
bool any_async = false;
|
|
for (; !awaiter_frame_.closure.IsNull(); UnwindToAwaiter()) {
|
|
function_ = awaiter_frame_.closure.function();
|
|
if (function_.IsNull()) {
|
|
continue;
|
|
}
|
|
|
|
any_async = true;
|
|
uword pc_offset;
|
|
if (awaiter_frame_.next.IsSuspendState()) {
|
|
const uword pc = SuspendState::Cast(awaiter_frame_.next).pc();
|
|
if (pc == 0) {
|
|
// Async function is already resumed.
|
|
continue;
|
|
}
|
|
|
|
code_ = SuspendState::Cast(awaiter_frame_.next).GetCodeObject();
|
|
pc_offset = pc - code_.PayloadStart();
|
|
} else {
|
|
// This is an asynchronous continuation represented by a closure which
|
|
// will handle successful completion. This function is not yet executing
|
|
// so we have to use artificial marker offset (1).
|
|
code_ = function_.EnsureHasCode();
|
|
RELEASE_ASSERT(!code_.IsNull());
|
|
pc_offset =
|
|
(function_.entry_point() + StackTraceUtils::kFutureListenerPcOffset) -
|
|
code_.PayloadStart();
|
|
}
|
|
|
|
handle_frame(gap_frame);
|
|
handle_frame({nullptr, code_, pc_offset, awaiter_frame_.closure});
|
|
}
|
|
|
|
if (any_async) {
|
|
handle_frame(gap_frame);
|
|
}
|
|
}
|
|
|
|
ObjectPtr AsyncAwareStackUnwinder::GetReceiver() const {
|
|
return *(reinterpret_cast<ObjectPtr*>(sync_frame_->GetCallerSp()) +
|
|
function_.num_fixed_parameters() - 1);
|
|
}
|
|
|
|
bool AsyncAwareStackUnwinder::HandleSynchronousFrame() {
|
|
function_ = sync_frame_->LookupDartFunction();
|
|
if (function_.IsNull()) {
|
|
return false;
|
|
}
|
|
|
|
// This is an invocation of an `async` or `async*` function.
|
|
if (function_.IsAsyncFunction() || function_.IsAsyncGenerator()) {
|
|
InitializeAwaiterFrameFromSuspendState();
|
|
return false;
|
|
}
|
|
|
|
// This is an invocation of a closure which has a variable marked
|
|
// with `@pragma('vm:awaiter-link')` which points to the awaiter.
|
|
if (function_.HasAwaiterLink()) {
|
|
object_ = GetReceiver();
|
|
if (object_.IsClosure() &&
|
|
StackTraceUtils::GetSuspendState(Closure::Cast(object_),
|
|
&awaiter_frame_.next)) {
|
|
awaiter_frame_.closure ^= object_.ptr();
|
|
return true; // Hide this frame from the stack trace.
|
|
}
|
|
}
|
|
|
|
// This is `_FutureListener.handleValue(...)` invocation.
|
|
if (function_.recognized_kind() ==
|
|
MethodRecognizer::kFutureListenerHandleValue) {
|
|
object_ = GetReceiver();
|
|
InitializeAwaiterFrameFromFutureListener(object_);
|
|
UnwindToAwaiter();
|
|
return true; // Hide this frame from the stack trace.
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::InitializeAwaiterFrameFromSuspendState() {
|
|
if (function_.IsAsyncFunction() || function_.IsAsyncGenerator()) {
|
|
// Check if we reached a resumed asynchronous function. In this case we
|
|
// are going to start following async frames after we emit this frame.
|
|
object_ = *reinterpret_cast<ObjectPtr*>(LocalVarAddress(
|
|
sync_frame_->fp(), runtime_frame_layout.FrameSlotForVariableIndex(
|
|
SuspendState::kSuspendStateVarIndex)));
|
|
|
|
awaiter_frame_.closure = Closure::null();
|
|
if (WasPreviouslySuspended(function_, object_)) {
|
|
awaiter_frame_.next = object_.ptr();
|
|
UnwindToAwaiter();
|
|
}
|
|
}
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::UnwindToAwaiter() {
|
|
do {
|
|
UnwindAwaiterFrame();
|
|
} while (awaiter_frame_.closure.IsNull() && !awaiter_frame_.next.IsNull());
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::FollowAwaiterLinks(Closure* closure,
|
|
Object* link) {
|
|
*link = Object::null();
|
|
while (!closure->IsNull() && TryGetAwaiterLink(*closure, link) &&
|
|
link->IsClosure()) {
|
|
*closure ^= link->ptr();
|
|
}
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::ComputeNextFrameFromAwaiterLink() {
|
|
FollowAwaiterLinks(&awaiter_frame_.closure, &object_);
|
|
if (!object_.IsNull()) {
|
|
awaiter_frame_.next = object_.ptr();
|
|
}
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::UnwindAwaiterFrame() {
|
|
if (awaiter_frame_.next.IsSuspendState()) {
|
|
awaiter_frame_.next =
|
|
SuspendState::Cast(awaiter_frame_.next).function_data();
|
|
} else if (awaiter_frame_.next.GetClassId() == _SyncCompleter().id() ||
|
|
awaiter_frame_.next.GetClassId() == _AsyncCompleter().id()) {
|
|
awaiter_frame_.next = Get_Completer_future(awaiter_frame_.next);
|
|
}
|
|
|
|
if (awaiter_frame_.next.GetClassId() == _AsyncStarStreamController().id()) {
|
|
awaiter_frame_.next =
|
|
Get_AsyncStarStreamController_controller(awaiter_frame_.next);
|
|
}
|
|
|
|
if (awaiter_frame_.next.GetClassId() == _Future().id()) {
|
|
UnwindFrameToFutureListener();
|
|
} else if (awaiter_frame_.next.GetClassId() == _SyncStreamController().id()) {
|
|
UnwindFrameToStreamController();
|
|
ComputeNextFrameFromAwaiterLink();
|
|
} else {
|
|
awaiter_frame_.closure = Closure::null();
|
|
awaiter_frame_.next = Object::null();
|
|
}
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::UnwindFrameToFutureListener() {
|
|
object_ = Get_Future__resultOrListeners(awaiter_frame_.next);
|
|
if (object_.GetClassId() == _FutureListener().id()) {
|
|
InitializeAwaiterFrameFromFutureListener(object_);
|
|
} else {
|
|
if (ShouldComputeIfAsyncErrorIsHandled()) {
|
|
// Check if error on this future was ignored through |Future.ignore|.
|
|
const auto state =
|
|
Smi::Value(Smi::RawCast(Get_Future__state(awaiter_frame_.next)));
|
|
if ((state & k_Future__stateIgnoreError) != 0) {
|
|
MarkAsHandlingAsyncError();
|
|
}
|
|
}
|
|
|
|
awaiter_frame_.closure = Closure::null();
|
|
awaiter_frame_.next = Object::null();
|
|
}
|
|
}
|
|
|
|
bool AsyncAwareStackUnwinder::WillFutureHandleError(const Object& future,
|
|
intptr_t depth /* = 0 */) {
|
|
if (depth > 100 || future.GetClassId() != _Future().id()) {
|
|
return true; // Conservative.
|
|
}
|
|
|
|
if (Get_Future__resultOrListeners(future) == Object::null()) {
|
|
// No listeners: check if future is simply ignoring errors.
|
|
const auto state = Smi::Value(Smi::RawCast(Get_Future__state(future)));
|
|
return (state & k_Future__stateIgnoreError) != 0;
|
|
}
|
|
|
|
for (auto& listener = Object::Handle(Get_Future__resultOrListeners(future));
|
|
listener.GetClassId() == _FutureListener().id();
|
|
listener = Get_FutureListener__nextListener(listener)) {
|
|
const auto state =
|
|
Smi::Value(Smi::RawCast(Get_FutureListener_state(listener)));
|
|
if ((state & k_FutureListener_stateCatchError) == 0 &&
|
|
!WillFutureHandleError(
|
|
Object::Handle(Get_FutureListener_result(listener)), depth + 1)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::InitializeAwaiterFrameFromFutureListener(
|
|
const Object& listener) {
|
|
if (listener.GetClassId() != _FutureListener().id()) {
|
|
awaiter_frame_.closure = Closure::null();
|
|
awaiter_frame_.next = Object::null();
|
|
return;
|
|
}
|
|
|
|
const auto state =
|
|
Smi::Value(Smi::RawCast(Get_FutureListener_state(listener)));
|
|
if (state == k_FutureListener_stateThen ||
|
|
state == k_FutureListener_stateCatchError ||
|
|
state == k_FutureListener_stateWhenComplete ||
|
|
state ==
|
|
(k_FutureListener_stateThen | k_FutureListener_stateCatchError) ||
|
|
state == (k_FutureListener_stateThen | k_FutureListener_stateCatchError |
|
|
k_FutureListener_maskAwait)) {
|
|
result_future_ = Get_FutureListener_result(listener);
|
|
} else {
|
|
result_future_ = Object::null();
|
|
}
|
|
awaiter_frame_.closure =
|
|
Closure::RawCast(Get_FutureListener_callback(listener));
|
|
awaiter_frame_.next = result_future_.ptr();
|
|
|
|
ComputeNextFrameFromAwaiterLink();
|
|
|
|
if (ShouldComputeIfAsyncErrorIsHandled() && !result_future_.IsNull() &&
|
|
result_future_.ptr() != awaiter_frame_.next.ptr()) {
|
|
// We have unwound through closure rather than followed result future, this
|
|
// can be caused by unwinding through `await` or code like
|
|
// `fut.whenComplete(c.complete)`. If the current future does not
|
|
// catch the error then the error will be forwarded into result_future_.
|
|
// Check if result_future_ handles it and set
|
|
// encountered_async_catch_error_ respectively.
|
|
if ((state & k_FutureListener_stateCatchError) == 0 &&
|
|
WillFutureHandleError(result_future_)) {
|
|
MarkAsHandlingAsyncError();
|
|
}
|
|
}
|
|
|
|
// If the Future has catchError callback attached through either
|
|
// `Future.catchError` or `Future.then(..., onError: ...)` then we should
|
|
// treat this listener as a catch all exception handler. However we should
|
|
// ignore the case when these callbacks are simply forwarding errors into a
|
|
// suspended async function, because it will be represented by its own async
|
|
// frame.
|
|
//
|
|
// However if we fail to unwind this frame (e.g. because there is some
|
|
// Zone wrapping callbacks and obstructing unwinding) then we conservatively
|
|
// treat this error handler as handling all errors to prevent user
|
|
// unfriendly situations where debugger stops on handled exceptions.
|
|
if ((state & k_FutureListener_stateCatchError) != 0 &&
|
|
((state & k_FutureListener_maskAwait) == 0 ||
|
|
!awaiter_frame_.next.IsSuspendState())) {
|
|
MarkAsHandlingAsyncError();
|
|
}
|
|
}
|
|
|
|
void AsyncAwareStackUnwinder::UnwindFrameToStreamController() {
|
|
controller_ = awaiter_frame_.next.ptr();
|
|
|
|
// Clear the frame.
|
|
awaiter_frame_.closure = Closure::null();
|
|
awaiter_frame_.next = Object::null();
|
|
|
|
const auto state =
|
|
Smi::Value(Smi::RawCast(Get_StreamController__state(controller_)));
|
|
|
|
if ((state & k_StreamController__STATE_SUBSCRIPTION_MASK) !=
|
|
k_StreamController__STATE_SUBSCRIBED) {
|
|
return;
|
|
}
|
|
|
|
subscription_ = Get_StreamController__varData(controller_);
|
|
if ((state & k_StreamController__STATE_ADDSTREAM) != 0) {
|
|
subscription_ = Get_StreamControllerAddStreamState__varData(subscription_);
|
|
}
|
|
|
|
closure_ ^= Get_BufferingStreamSubscription__onData(subscription_);
|
|
|
|
const auto subscription_state = Smi::Value(
|
|
Smi::RawCast(Get_BufferingStreamSubscription__state(subscription_)));
|
|
|
|
const auto has_error_handler =
|
|
((subscription_state &
|
|
k_BufferingStreamSubscription__STATE_HAS_ERROR_HANDLER) != 0);
|
|
|
|
// If this is not the "_StreamIterator._onData" tear-off, we return the
|
|
// callback we found.
|
|
function_ = closure_.function();
|
|
if (function_.IsImplicitClosureFunction()) {
|
|
// Handle `await for` case. In this case onData is calling
|
|
// _StreamIterator._onData which then notifies awaiter by completing
|
|
// _StreamIterator.moveNextFuture.
|
|
if (function_.Owner() == _StreamIterator().ptr()) {
|
|
// All implicit closure functions (tear-offs) have the "this" receiver
|
|
// captured in the context.
|
|
stream_iterator_ = closure_.GetImplicitClosureReceiver();
|
|
|
|
if (stream_iterator_.GetClassId() != _StreamIterator().id()) {
|
|
UNREACHABLE();
|
|
}
|
|
|
|
// If `_hasValue` is true then the `StreamIterator._stateData` field
|
|
// contains the iterator's value. In that case we cannot unwind anymore.
|
|
//
|
|
// Notice: With correct async* semantics this may never be true: the
|
|
// async* generator should only be invoked to produce a value if there's
|
|
// an in-progress `await streamIterator.moveNext()` call. Once such call
|
|
// has finished the async* generator should be paused/yielded until the
|
|
// next such call - and being paused/yielded means it should not appear
|
|
// in stack traces.
|
|
//
|
|
// See dartbug.com/48695.
|
|
if (Get_StreamIterator__hasValue(stream_iterator_) ==
|
|
Object::bool_true().ptr()) {
|
|
if (has_error_handler) {
|
|
MarkAsHandlingAsyncError();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If we have an await'er for `await streamIterator.moveNext()` we
|
|
// continue unwinding there.
|
|
//
|
|
// Notice: With correct async* semantics this may always contain a Future
|
|
// See also comment above as well as dartbug.com/48695.
|
|
object_ = Get_StreamIterator__stateData(stream_iterator_);
|
|
if (object_.GetClassId() == _Future().id()) {
|
|
awaiter_frame_.next = object_.ptr();
|
|
} else {
|
|
if (has_error_handler) {
|
|
MarkAsHandlingAsyncError();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Handle `yield*` case. Here one stream controller will be forwarding
|
|
// to another one. If the destination controller is
|
|
// _AsyncStarStreamController, then we should make sure to reflect
|
|
// its asyncStarBody in the stack trace.
|
|
if (function_.Owner() == _StreamController().ptr()) {
|
|
// Get the controller to which we are forwarding and check if it is
|
|
// in the ADD_STREAM state.
|
|
object_ = closure_.GetImplicitClosureReceiver();
|
|
const auto state =
|
|
Smi::Value(Smi::RawCast(Get_StreamController__state(object_)));
|
|
if ((state & k_StreamController__STATE_ADDSTREAM) != 0) {
|
|
// Get to the addStreamFuture - if this is yield* internals we
|
|
// will be able to get original _AsyncStarStreamController from
|
|
// handler attached to that future.
|
|
object_ = Get_StreamController__varData(object_);
|
|
object_ = Get_AddStreamState_addStreamFuture(object_);
|
|
object_ = Get_Future__resultOrListeners(object_);
|
|
if (object_.GetClassId() == _FutureListener().id()) {
|
|
const auto state =
|
|
Smi::Value(Smi::RawCast(Get_FutureListener_state(object_)));
|
|
if (state == k_FutureListener_stateThen) {
|
|
auto& handler = Closure::Handle(
|
|
Closure::RawCast(Get_FutureListener_callback(object_)));
|
|
FollowAwaiterLinks(&handler, &object_);
|
|
if (object_.GetClassId() == _AsyncStarStreamController().id()) {
|
|
awaiter_frame_.closure = Closure::RawCast(
|
|
Get_AsyncStarStreamController_asyncStarBody(object_));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
awaiter_frame_.closure = closure_.ptr();
|
|
|
|
bool found_awaiter_link_in_sibling_handler = false;
|
|
|
|
if (!function_.HasAwaiterLink()) {
|
|
// If we don't have awaiter-link in the `onData` handler, try checking
|
|
// if either onError or onDone have an awaiter link.
|
|
closure_ ^= Get_BufferingStreamSubscription__onError(subscription_);
|
|
function_ = closure_.function();
|
|
found_awaiter_link_in_sibling_handler = function_.HasAwaiterLink();
|
|
}
|
|
|
|
if (!function_.HasAwaiterLink()) {
|
|
closure_ ^= Get_BufferingStreamSubscription__onDone(subscription_);
|
|
function_ = closure_.function();
|
|
found_awaiter_link_in_sibling_handler = function_.HasAwaiterLink();
|
|
}
|
|
|
|
if (has_error_handler || found_awaiter_link_in_sibling_handler) {
|
|
FollowAwaiterLinks(&closure_, &object_);
|
|
}
|
|
|
|
if (has_error_handler && object_.GetClassId() != _Future().id() &&
|
|
object_.GetClassId() != _SyncStreamController().id()) {
|
|
MarkAsHandlingAsyncError();
|
|
}
|
|
|
|
if (found_awaiter_link_in_sibling_handler) {
|
|
if (object_.GetClassId() == _AsyncStarStreamController().id() ||
|
|
object_.GetClassId() == _SyncStreamController().id()) {
|
|
// We can continue unwinding from here.
|
|
awaiter_frame_.closure = closure_.ptr();
|
|
} else {
|
|
awaiter_frame_.next = object_.ptr();
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool StackTraceUtils::IsPossibleAwaiterLink(const Class& cls) {
|
|
if (cls.library() != Library::AsyncLibrary()) {
|
|
return false;
|
|
}
|
|
|
|
String& class_name = String::Handle();
|
|
const auto is_class = [&](const String& name) {
|
|
class_name = cls.Name();
|
|
return String::EqualsIgnoringPrivateKey(class_name, name);
|
|
};
|
|
|
|
return is_class(Symbols::_AsyncStarStreamController()) ||
|
|
is_class(Symbols::_SyncStreamController()) ||
|
|
is_class(Symbols::_StreamController()) ||
|
|
is_class(Symbols::_Completer()) ||
|
|
is_class(Symbols::_AsyncCompleter()) ||
|
|
is_class(Symbols::_SyncCompleter()) || is_class(Symbols::_Future());
|
|
}
|
|
|
|
bool StackTraceUtils::IsNeededForAsyncAwareUnwinding(const Function& function) {
|
|
// If this is a closure function which specifies an awaiter-link then
|
|
// we need to retain both function and the corresponding code.
|
|
if (function.HasAwaiterLink()) {
|
|
return true;
|
|
}
|
|
|
|
if (function.recognized_kind() ==
|
|
MethodRecognizer::kFutureListenerHandleValue) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void StackTraceUtils::CollectFrames(
|
|
Thread* thread,
|
|
int skip_frames,
|
|
const std::function<void(const StackTraceUtils::Frame&)>& handle_frame,
|
|
bool* has_async_catch_error /* = null */) {
|
|
AsyncAwareStackUnwinder it(thread, has_async_catch_error);
|
|
it.Unwind(skip_frames, handle_frame);
|
|
}
|
|
|
|
bool StackTraceUtils::GetSuspendState(const Closure& closure,
|
|
Object* suspend_state) {
|
|
if (TryGetAwaiterLink(closure, suspend_state)) {
|
|
return suspend_state->IsSuspendState();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace dart
|