[vm] Cleanup more async-related code

This change continues cleanup of async implementation in the VM.

TEST=ci

Issue: #48378
Change-Id: Icdaeab18bcdc0d6974bc45841b630822cd1ac114
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/251441
Reviewed-by: Martin Kustermann <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -698,22 +698,14 @@ Fragment StreamingFlowGraphBuilder::BuildFunctionBody(
   return body;
 }
 
-Fragment StreamingFlowGraphBuilder::BuildEveryTimePrologue(
+Fragment StreamingFlowGraphBuilder::BuildRegularFunctionPrologue(
     const Function& dart_function,
     TokenPosition token_position,
-    intptr_t type_parameters_offset) {
+    LocalVariable* first_parameter) {
   Fragment F;
   F += CheckStackOverflowInPrologue(dart_function);
   F += DebugStepCheckInPrologue(dart_function, token_position);
   F += B->InitConstantParameters();
-  return F;
-}
-
-Fragment StreamingFlowGraphBuilder::BuildFirstTimePrologue(
-    const Function& dart_function,
-    LocalVariable* first_parameter,
-    intptr_t type_parameters_offset) {
-  Fragment F;
   F += SetupCapturedParameters(dart_function);
   F += ShortcutForUserDefinedEquals(dart_function, first_parameter);
   return F;
@@ -747,8 +739,7 @@ Fragment StreamingFlowGraphBuilder::ClearRawParameters(
 UncheckedEntryPointStyle StreamingFlowGraphBuilder::ChooseEntryPointStyle(
     const Function& dart_function,
     const Fragment& implicit_type_checks,
-    const Fragment& first_time_prologue,
-    const Fragment& every_time_prologue,
+    const Fragment& regular_function_prologue,
     const Fragment& type_args_handling) {
   ASSERT(!dart_function.IsImplicitClosureFunction());
   if (!dart_function.MayHaveUncheckedEntryPoint() ||
@@ -761,17 +752,21 @@ UncheckedEntryPointStyle StreamingFlowGraphBuilder::ChooseEntryPointStyle(
   //
   // 1. There is a non-empty PrologueBuilder-prologue.
   //
-  // 2. There is a non-empty "first-time" prologue.
+  // 2. The regular function prologue has more than two instructions
+  //    (DebugStepCheck and CheckStackOverflow).
   //
-  // 3. The "every-time" prologue has more than two instructions (DebugStepCheck
-  //    and CheckStackOverflow).
-  //
-  // TODO(#34162): For regular closures we can often avoid the
-  // PrologueBuilder-prologue on non-dynamic invocations.
   if (!PrologueBuilder::HasEmptyPrologue(dart_function) ||
-      !type_args_handling.is_empty() || !first_time_prologue.is_empty() ||
-      !(every_time_prologue.entry == every_time_prologue.current ||
-        every_time_prologue.current->previous() == every_time_prologue.entry)) {
+      !type_args_handling.is_empty()) {
+    return UncheckedEntryPointStyle::kSharedWithVariable;
+  }
+  Instruction* instr = regular_function_prologue.entry;
+  if (instr != nullptr && instr->IsCheckStackOverflow()) {
+    instr = instr->next();
+  }
+  if (instr != nullptr && instr->IsDebugStepCheck()) {
+    instr = instr->next();
+  }
+  if (instr != nullptr) {
     return UncheckedEntryPointStyle::kSharedWithVariable;
   }
 
@@ -782,15 +777,11 @@ FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
     bool is_constructor) {
   const Function& dart_function = parsed_function()->function();
 
-  intptr_t type_parameters_offset = 0;
   LocalVariable* first_parameter = nullptr;
   TokenPosition token_position = TokenPosition::kNoSource;
   {
     AlternativeReadingScope alt(&reader_);
     FunctionNodeHelper function_node_helper(this);
-    function_node_helper.ReadUntilExcluding(
-        FunctionNodeHelper::kTypeParameters);
-    type_parameters_offset = ReaderOffset();
     function_node_helper.ReadUntilExcluding(
         FunctionNodeHelper::kPositionalParameters);
     intptr_t list_length = ReadListLength();  // read number of positionals.
@@ -811,15 +802,8 @@ FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
   BlockEntryInstr* instruction_cursor =
       flow_graph_builder_->BuildPrologue(normal_entry, &prologue_info);
 
-  // The 'every_time_prologue' runs first and is run when resuming from yield
-  // points.
-  const Fragment every_time_prologue = BuildEveryTimePrologue(
-      dart_function, token_position, type_parameters_offset);
-
-  // The 'first_time_prologue' run after 'every_time_prologue' and is *not* run
-  // when resuming from yield points.
-  const Fragment first_time_prologue = BuildFirstTimePrologue(
-      dart_function, first_parameter, type_parameters_offset);
+  const Fragment regular_prologue = BuildRegularFunctionPrologue(
+      dart_function, token_position, first_parameter);
 
   // TODO(#34162): We can remove the default type handling (and
   // shorten the prologue type handling sequence) for non-dynamic invocations of
@@ -847,39 +831,36 @@ FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
       InitSuspendableFunction(dart_function) +
       BuildFunctionBody(dart_function, first_parameter, is_constructor);
 
-  auto extra_entry_point_style = ChooseEntryPointStyle(
-      dart_function, implicit_type_checks, first_time_prologue,
-      every_time_prologue, type_args_handling);
+  auto extra_entry_point_style =
+      ChooseEntryPointStyle(dart_function, implicit_type_checks,
+                            regular_prologue, type_args_handling);
 
   Fragment function(instruction_cursor);
   FunctionEntryInstr* extra_entry = nullptr;
   switch (extra_entry_point_style) {
     case UncheckedEntryPointStyle::kNone: {
-      function += every_time_prologue + first_time_prologue +
-                  type_args_handling + implicit_type_checks +
+      function += regular_prologue + type_args_handling + implicit_type_checks +
                   explicit_type_checks + body;
       break;
     }
     case UncheckedEntryPointStyle::kSeparate: {
       ASSERT(instruction_cursor == normal_entry);
-      ASSERT(first_time_prologue.is_empty());
       ASSERT(type_args_handling.is_empty());
 
-      const Fragment prologue_copy = BuildEveryTimePrologue(
-          dart_function, token_position, type_parameters_offset);
+      const Fragment prologue_copy = BuildRegularFunctionPrologue(
+          dart_function, token_position, first_parameter);
 
       extra_entry = B->BuildSeparateUncheckedEntryPoint(
           normal_entry,
-          /*normal_prologue=*/every_time_prologue + implicit_type_checks,
+          /*normal_prologue=*/regular_prologue + implicit_type_checks,
           /*extra_prologue=*/prologue_copy,
           /*shared_prologue=*/explicit_type_checks,
           /*body=*/body);
       break;
     }
     case UncheckedEntryPointStyle::kSharedWithVariable: {
       Fragment prologue(normal_entry, instruction_cursor);
-      prologue += every_time_prologue;
-      prologue += first_time_prologue;
+      prologue += regular_prologue;
       prologue += type_args_handling;
       prologue += explicit_type_checks;
       extra_entry = B->BuildSharedUncheckedEntryPoint(

runtime/vm/compiler/frontend/kernel_binary_flowgraph.h

@@ -82,16 +82,12 @@ class StreamingFlowGraphBuilder : public KernelReaderHelper {
                              bool constructor);
 
   // Pieces of the prologue. They are all agnostic to the current Kernel offset.
-  Fragment BuildEveryTimePrologue(const Function& dart_function,
-                                  TokenPosition token_position,
-                                  intptr_t type_parameters_offset);
-  Fragment BuildFirstTimePrologue(const Function& dart_function,
-                                  LocalVariable* first_parameter,
-                                  intptr_t type_parameters_offset);
+  Fragment BuildRegularFunctionPrologue(const Function& dart_function,
+                                        TokenPosition token_position,
+                                        LocalVariable* first_parameter);
   Fragment ClearRawParameters(const Function& dart_function);
   Fragment DebugStepCheckInPrologue(const Function& dart_function,
                                     TokenPosition position);
-  Fragment SetAsyncStackTrace(const Function& dart_function);
   Fragment CheckStackOverflowInPrologue(const Function& dart_function);
   Fragment SetupCapturedParameters(const Function& dart_function);
   Fragment InitSuspendableFunction(const Function& dart_function);
@@ -102,8 +98,7 @@ class StreamingFlowGraphBuilder : public KernelReaderHelper {
   static UncheckedEntryPointStyle ChooseEntryPointStyle(
       const Function& dart_function,
       const Fragment& implicit_type_checks,
-      const Fragment& first_time_prologue,
-      const Fragment& every_time_prologue,
+      const Fragment& regular_function_prologue,
       const Fragment& type_args_handling);
 
   void loop_depth_inc();

runtime/vm/compiler/frontend/scope_builder.cc

@@ -148,7 +148,6 @@ ScopeBuildingResult* ScopeBuilder::BuildScopes() {
       helper_.ReadUntilFunctionNode();
       function_node_helper.ReadUntilExcluding(
           FunctionNodeHelper::kPositionalParameters);
-      current_function_async_marker_ = function_node_helper.async_marker_;
       // NOTE: FunctionNode is read further below the if.
 
       intptr_t pos = 0;
@@ -368,7 +367,6 @@ ScopeBuildingResult* ScopeBuilder::BuildScopes() {
       scope_->InsertParameterAt(pos++, parsed_function_->receiver_var());
 
       // Create all positional and named parameters.
-      current_function_async_marker_ = FunctionNodeHelper::kSync;
       AddPositionalAndNamedParameters(
           pos, kTypeCheckEverythingNotCheckedInNonDynamicallyInvokedMethod,
           attrs);
@@ -393,7 +391,6 @@ ScopeBuildingResult* ScopeBuilder::BuildScopes() {
       // Callbacks and calls with handles need try/catch variables.
       if ((function.FfiCallbackTarget() != Function::null() ||
            function.FfiCSignatureContainsHandles())) {
-        current_function_async_marker_ = FunctionNodeHelper::kSync;
         ++depth_.try_;
         AddTryVariables();
         --depth_.try_;
@@ -1462,13 +1459,10 @@ void ScopeBuilder::HandleLocalFunction(intptr_t parent_kernel_offset) {
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
 
   LocalScope* saved_function_scope = current_function_scope_;
-  FunctionNodeHelper::AsyncMarker saved_function_async_marker =
-      current_function_async_marker_;
   DepthState saved_depth_state = depth_;
   depth_ = DepthState(depth_.function_ + 1);
   EnterScope(parent_kernel_offset);
   current_function_scope_ = scope_;
-  current_function_async_marker_ = function_node_helper.async_marker_;
   if (depth_.function_ == 1) {
     FunctionScope function_scope = {offset, scope_};
     result_->function_scopes.Add(function_scope);
@@ -1516,7 +1510,6 @@ void ScopeBuilder::HandleLocalFunction(intptr_t parent_kernel_offset) {
   ExitScope(function_node_helper.position_, function_node_helper.end_position_);
   depth_ = saved_depth_state;
   current_function_scope_ = saved_function_scope;
-  current_function_async_marker_ = saved_function_async_marker;
 }
 
 void ScopeBuilder::EnterScope(intptr_t kernel_offset) {

runtime/vm/compiler/frontend/scope_builder.h

@@ -154,7 +154,6 @@ class ScopeBuilder {
   TranslationHelper translation_helper_;
   Zone* zone_;
 
-  FunctionNodeHelper::AsyncMarker current_function_async_marker_;
   LocalScope* current_function_scope_;
   LocalScope* scope_;
   DepthState depth_;

runtime/vm/compiler/recognized_methods_list.h

@@ -97,9 +97,9 @@ namespace dart {
     0xc40903ac)                                                                \
   V(_SuspendState, _clone, SuspendState_clone, 0xae1a40a0)                     \
   V(_SuspendState, _createAsyncCallbacks, SuspendState_createAsyncCallbacks,   \
-    0x68be1bf3)                                                                \
+    0x967521b1)                                                                \
   V(_SuspendState, _createAsyncStarCallback,                                   \
-    SuspendState_createAsyncStarCallback, 0xfa7537e4)                          \
+    SuspendState_createAsyncStarCallback, 0xa50f923c)                          \
   V(_SuspendState, _resume, SuspendState_resume, 0x5d7a8489)                   \
   V(_IntegerImplementation, toDouble, IntegerToDouble, 0x97728b46)             \
   V(_Double, _add, DoubleAdd, 0xea666327)                                      \

runtime/vm/debugger.cc

@@ -306,7 +306,7 @@ ActivationFrame::ActivationFrame(const Closure& async_activation,
       pc_desc_(PcDescriptors::ZoneHandle()) {
   // Extract the function and the code from the asynchronous activation.
   function_ = async_activation.function();
-  if (caller_closure_finder->IsCompactAsyncCallback(function_)) {
+  if (caller_closure_finder->IsAsyncCallback(function_)) {
     const auto& suspend_state = SuspendState::Handle(
         caller_closure_finder->GetSuspendStateFromAsyncCallback(
             async_activation));
@@ -2944,16 +2944,6 @@ Breakpoint* Debugger::SetBreakpointAtActivation(const Instance& closure,
   return bpt_location->AddPerClosure(this, closure, for_over_await);
 }
 
-Breakpoint* Debugger::SetBreakpointAtAsyncOp(const Function& async_op) {
-  const Script& script = Script::Handle(async_op.script());
-  BreakpointLocation* bpt_location =
-      SetBreakpoint(script, async_op.token_pos(), async_op.end_token_pos(), -1,
-                    -1 /* no line/col */, async_op);
-  auto bpt = bpt_location->AddSingleShot(this);
-  bpt->set_is_synthetic_async(true);
-  return bpt;
-}
-
 Breakpoint* Debugger::BreakpointAtActivation(const Instance& closure) {
   if (!closure.IsClosure()) {
     return NULL;
@@ -4422,7 +4412,7 @@ void Debugger::MaybeAsyncStepInto(const Closure& async_op) {
 void Debugger::AsyncStepInto(const Closure& async_op) {
   Zone* zone = Thread::Current()->zone();
   CallerClosureFinder caller_closure_finder(zone);
-  if (caller_closure_finder.IsCompactAsyncCallback(
+  if (caller_closure_finder.IsAsyncCallback(
           Function::Handle(zone, async_op.function()))) {
     const auto& suspend_state = SuspendState::Handle(
         zone, caller_closure_finder.GetSuspendStateFromAsyncCallback(async_op));

runtime/vm/debugger.h

@@ -719,10 +719,6 @@ class Debugger {
                                      intptr_t line_number,
                                      intptr_t column_number);
 
-  // Sets synthetic breakpoint at async_op to step over the synthetic part of
-  // the stack trace.
-  Breakpoint* SetBreakpointAtAsyncOp(const Function& async_op);
-
   BreakpointLocation* BreakpointLocationAtLineCol(const String& script_url,
                                                   intptr_t line_number,
                                                   intptr_t column_number);

runtime/vm/object.h

@@ -6996,13 +6996,6 @@ class Context : public Object {
   static const intptr_t kBytesPerElement = kCompressedWordSize;
   static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
 
-  static const intptr_t kAwaitJumpVarIndex = 0;
-  static const intptr_t kAsyncFutureIndex = 1;
-  static const intptr_t kControllerIndex = 1;
-  // Expected context index of chained futures in recognized async functions.
-  // These are used to unwind async stacks.
-  static const intptr_t kIsSyncIndex = 2;
-
   struct ArrayTraits {
     static intptr_t elements_start_offset() { return sizeof(UntaggedContext); }
     static constexpr intptr_t kElementSize = kBytesPerElement;

runtime/vm/stack_trace.cc

@@ -133,13 +133,6 @@ ClosurePtr CallerClosureFinder::GetCallerInFutureImpl(const Object& future) {
   return GetCallerInFutureListener(listener);
 }
 
-ClosurePtr CallerClosureFinder::FindCallerInAsyncGenClosure(
-    const Context& receiver_context) {
-  // Get the async* _AsyncStarStreamController.
-  context_entry_ = receiver_context.At(Context::kControllerIndex);
-  return FindCallerInAsyncStarStreamController(context_entry_);
-}
-
 ClosurePtr CallerClosureFinder::FindCallerInAsyncStarStreamController(
     const Object& async_star_stream_controller) {
   ASSERT(async_star_stream_controller.IsInstance());
@@ -246,7 +239,7 @@ ClosurePtr CallerClosureFinder::FindCallerFromSuspendState(
   }
 }
 
-bool CallerClosureFinder::IsCompactAsyncCallback(const Function& function) {
+bool CallerClosureFinder::IsAsyncCallback(const Function& function) {
   parent_function_ = function.parent_function();
   auto kind = parent_function_.recognized_kind();
   return (kind == MethodRecognizer::kSuspendState_createAsyncCallbacks) ||
@@ -255,7 +248,7 @@ bool CallerClosureFinder::IsCompactAsyncCallback(const Function& function) {
 
 SuspendStatePtr CallerClosureFinder::GetSuspendStateFromAsyncCallback(
     const Closure& closure) {
-  ASSERT(IsCompactAsyncCallback(Function::Handle(closure.function())));
+  ASSERT(IsAsyncCallback(Function::Handle(closure.function())));
   // Async/async* handler only captures the receiver (SuspendState).
   receiver_context_ = closure.context();
   RELEASE_ASSERT(receiver_context_.num_variables() == 1);
@@ -266,7 +259,7 @@ ClosurePtr CallerClosureFinder::FindCaller(const Closure& receiver_closure) {
   receiver_function_ = receiver_closure.function();
   receiver_context_ = receiver_closure.context();
 
-  if (IsCompactAsyncCallback(receiver_function_)) {
+  if (IsAsyncCallback(receiver_function_)) {
     suspend_state_ = GetSuspendStateFromAsyncCallback(receiver_closure);
     return FindCallerFromSuspendState(suspend_state_);
   }
@@ -302,12 +295,6 @@ ClosurePtr CallerClosureFinder::FindCaller(const Closure& receiver_closure) {
   return Closure::null();
 }
 
-ObjectPtr CallerClosureFinder::GetAsyncFuture(const Closure& receiver_closure) {
-  // Closure -> Context -> _Future.
-  receiver_context_ = receiver_closure.context();
-  return receiver_context_.At(Context::kAsyncFutureIndex);
-}
-
 ObjectPtr CallerClosureFinder::GetFutureFutureListener(const Object& future) {
   ASSERT(future.GetClassId() == future_impl_class.id());
   auto& listener = Object::Handle(
@@ -462,7 +449,7 @@ void StackTraceUtils::UnwindAwaiterChain(
     if (function.IsNull()) {
       continue;
     }
-    if (caller_closure_finder->IsCompactAsyncCallback(function)) {
+    if (caller_closure_finder->IsAsyncCallback(function)) {
       suspend_state =
           caller_closure_finder->GetSuspendStateFromAsyncCallback(closure);
       const uword pc = suspend_state.pc();

runtime/vm/stack_trace.h

@@ -27,10 +27,6 @@ class CallerClosureFinder {
   // Returns closure found either via the `result` Future, or the `callback`.
   ClosurePtr GetCallerInFutureListener(const Object& future_listener);
 
-  // Find caller closure from an async* function receiver context.
-  // Returns either the `onData` or the Future awaiter.
-  ClosurePtr FindCallerInAsyncGenClosure(const Context& receiver_context);
-
   // Find caller closure from an _AsyncStarStreamController instance
   // corresponding to async* function.
   // Returns either the `onData` or the Future awaiter.
@@ -47,15 +43,12 @@ class CallerClosureFinder {
 
   // Returns true if given closure function is a Future callback
   // corresponding to an async/async* function or async* body callback.
-  bool IsCompactAsyncCallback(const Function& function);
+  bool IsAsyncCallback(const Function& function);
 
   // Returns SuspendState from the given callback which corresponds
   // to an async/async* function.
   SuspendStatePtr GetSuspendStateFromAsyncCallback(const Closure& closure);
 
-  // Finds the awaited Future from an async function receiver closure.
-  ObjectPtr GetAsyncFuture(const Closure& receiver_closure);
-
   // Get sdk/lib/async/future_impl.dart:_FutureListener.state.
   intptr_t GetFutureListenerState(const Object& future_listener);