Vyacheslav Egorov
df6fd34f75
This CL adds @pragma('vm:awaiter-link') in various places in
Stream implementation to facilitate unwinding and expands
async unwinding logic with more information about
Stream internals.
At the same time be more conservative when checking if an
exception thrown from async method handled: failing to unwind
the stack fully creates situations when we incorrectly report
caught exceptions as uncaught, which frustrates users.
To distinguish stream subscriptions with and without error
handlers we add a state bit. Otherwise, it looks like all
subscriptions have error handlers because if no error
handler is installed we eagerly install error handler forwarding
the error to `Zone.handleUncaughtError`.
Fixes https://github.com/dart-lang/sdk/issues/53334
Fixes https://github.com/dart-lang/sdk/issues/54788
Fixes https://github.com/dart-lang/sdk/issues/47985
TEST=runtime/vm/dart/awaiter_stacks/stream_methods_test.dart,pkg/vm_service/test/pause_on_unhandled_async_exceptions6_test.dart,pkg/vm_service/test/pause_on_unhandled_async_exceptions7_test.dart
CoreLibraryReviewExempt: No behavioral change. Async changes reviewed by lrhn@
Cq-Include-Trybots: luci.dart.try:vm-aot-android-release-arm64c-try,vm-aot-android-release-arm_x64-try,vm-aot-dwarf-linux-product-x64-try,vm-aot-obfuscate-linux-release-x64-try,vm-aot-optimization-level-linux-release-x64-try
Change-Id: Ic51f926867092dd0adbe801b753f57c357c7ace2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/322720
Reviewed-by: Alexander Markov <alexmarkov@google.com>
Reviewed-by: Lasse Nielsen <lrn@google.com>
Reviewed-by: Ben Konyi <bkonyi@google.com>
Commit-Queue: Slava Egorov <vegorov@google.com>
685 lines
26 KiB
C++
685 lines
26 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;
|
|
// - _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)
|
|
: zone_(thread->zone()),
|
|
sync_frames_(thread, StackFrameIterator::kNoCrossThreadIteration),
|
|
sync_frame_(nullptr),
|
|
awaiter_frame_{Closure::Handle(zone_), Object::Handle(zone_)},
|
|
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_)),
|
|
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_)) {}
|
|
|
|
void Unwind(intptr_t skip_frames,
|
|
std::function<void(const StackTraceUtils::Frame&)> handle_frame);
|
|
|
|
bool encountered_async_catch_error() const {
|
|
return encountered_async_catch_error_;
|
|
}
|
|
|
|
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;
|
|
|
|
#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(_FutureListener, callback) \
|
|
V(_FutureListener, result) \
|
|
V(_FutureListener, state) \
|
|
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_ = false;
|
|
|
|
Closure& closure_;
|
|
Code& code_;
|
|
Context& context_;
|
|
Function& function_;
|
|
Function& parent_function_;
|
|
Object& object_;
|
|
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 {
|
|
awaiter_frame_.closure = Closure::null();
|
|
awaiter_frame_.next = Object::null();
|
|
}
|
|
}
|
|
|
|
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)) {
|
|
awaiter_frame_.next = Get_FutureListener_result(listener);
|
|
} else {
|
|
awaiter_frame_.next = Object::null();
|
|
}
|
|
awaiter_frame_.closure =
|
|
Closure::RawCast(Get_FutureListener_callback(listener));
|
|
|
|
ComputeNextFrameFromAwaiterLink();
|
|
|
|
// 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())) {
|
|
encountered_async_catch_error_ = true;
|
|
}
|
|
}
|
|
|
|
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) {
|
|
encountered_async_catch_error_ = true;
|
|
}
|
|
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) {
|
|
encountered_async_catch_error_ = true;
|
|
}
|
|
}
|
|
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()) {
|
|
encountered_async_catch_error_ = true;
|
|
}
|
|
|
|
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);
|
|
it.Unwind(skip_frames, handle_frame);
|
|
if (has_async_catch_error != nullptr) {
|
|
*has_async_catch_error = it.encountered_async_catch_error();
|
|
}
|
|
}
|
|
|
|
bool StackTraceUtils::GetSuspendState(const Closure& closure,
|
|
Object* suspend_state) {
|
|
if (TryGetAwaiterLink(closure, suspend_state)) {
|
|
return suspend_state->IsSuspendState();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace dart
|