[lldb][swift] Add swift_task_switch StepThroughPlan in Language plugin

The symbol for swift_task_switch is marked as a trampoline, which triggers a
generic handling of it through DynamicLoaderDarwin. This makes sense, as it is
usually just a symbol stub that we jump through to get to the real task_switch:

```
...
 0x1000031bc <+112>: b      0x100003d20    ; symbol stub for: swift_task_switch
...

testt.out`swift_task_switch:
swift_task_switch
->  0x100003d20 <+0>: adrp   x16, 1
    0x100003d24 <+4>: ldr    x16, [x16, #0x10]
    0x100003d28 <+8>: br     x16  ; <<< real task_switch_addr
```

DynamicLoaderDarwin will take the thread all the way to the target of the
`br x16` instruction, which is the real task switch.

However, once that's done, there are no thread plans taking the thread
to the target funclet we're switching to. Recall that a task_switch is a
request to run a given funclet inside _some_ executor/thread. It's like
a function call, but with scheduling in the middle.

This commit adds a new step through task_switch thread plan inside
SwiftLanguageRuntime; it is a simplified version of the (now removed)
ThreadPlanStepInAsync: a breakpoint is created to the target funclet,
and we compare async contexts to make sure the breakpoint was hit on the
right task.

Note: we could remove the handling inside DynamicLoaderDarwin with some
kind of "if (symbol == swift_task_switch) don't do anything". The new
thread plan would work even on the stub.

Author: felipepiovezan

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeNames.cpp

@@ -290,6 +290,113 @@ static ThunkAction GetThunkAction(ThunkKind kind) {
   }
 }
 
+/// A thread plan to run to a specific address on a specific async context.
+class ThreadPlanRunToAddressOnAsyncCtx : public ThreadPlan {
+public:
+  /// Creates a thread plan to run to destination_addr of an async function
+  /// whose context is async_ctx.
+  ThreadPlanRunToAddressOnAsyncCtx(Thread &thread, addr_t destination_addr,
+                                   addr_t async_ctx)
+      : ThreadPlan(eKindGeneric, "run-to-funclet", thread, eVoteNoOpinion,
+                   eVoteNoOpinion),
+        m_destination_addr(destination_addr), m_expected_async_ctx(async_ctx) {
+    auto &target = thread.GetProcess()->GetTarget();
+    m_funclet_bp = target.CreateBreakpoint(destination_addr, true, false);
+    m_funclet_bp->SetBreakpointKind("async-run-to-funclet");
+  }
+
+  bool ValidatePlan(Stream *error) override {
+    if (m_funclet_bp->HasResolvedLocations())
+      return true;
+
+    // If we failed to resolve any locations, this plan is invalid.
+    m_funclet_bp->GetTarget().RemoveBreakpointByID(m_funclet_bp->GetID());
+    return false;
+  }
+
+  void GetDescription(Stream *s, lldb::DescriptionLevel level) override {
+    s->PutCString("ThreadPlanRunToAddressOnAsyncCtx to address = ");
+    s->PutHex64(m_destination_addr);
+    s->PutCString(" with async ctx = ");
+    s->PutHex64(m_expected_async_ctx);
+  }
+
+  /// This plan explains the stop if the current async context is the async
+  /// context this plan was created with.
+  bool DoPlanExplainsStop(Event *event) override {
+    if (!HasTID())
+      return false;
+    return GetCurrentAsyncContext() == m_expected_async_ctx;
+  }
+
+  /// If this plan explained the stop, it always stops: its sole purpose is to
+  /// run to the breakpoint it set on the right async function invocation.
+  bool ShouldStop(Event *event) override {
+    SetPlanComplete();
+    return true;
+  }
+
+  /// If this plan said ShouldStop, then its job is complete.
+  bool MischiefManaged() override {
+    return IsPlanComplete();
+  }
+
+  bool WillStop() override { return false; }
+  lldb::StateType GetPlanRunState() override { return eStateRunning; }
+  bool StopOthers() override { return false; }
+  void DidPop() override {
+    m_funclet_bp->GetTarget().RemoveBreakpointByID(m_funclet_bp->GetID());
+  }
+
+private:
+  addr_t GetCurrentAsyncContext() {
+    auto frame_sp = GetThread().GetStackFrameAtIndex(0);
+    return frame_sp->GetStackID().GetCallFrameAddress();
+  }
+
+  addr_t m_destination_addr;
+  addr_t m_expected_async_ctx;
+  BreakpointSP m_funclet_bp;
+};
+
+/// Given a thread that is stopped at the start of swift_task_switch, create a
+/// thread plan that runs to the address of the resume function.
+static ThreadPlanSP CreateRunThroughTaskSwitchThreadPlan(Thread &thread) {
+  // The signature for `swift_task_switch` is as follows:
+  //   SWIFT_CC(swiftasync)
+  //   void swift_task_switch(
+  //     SWIFT_ASYNC_CONTEXT AsyncContext *resumeContext,
+  //     TaskContinuationFunction *resumeFunction,
+  //     ExecutorRef newExecutor);
+  //
+  // The async context given as the first argument is not passed using the
+  // calling convention's first register, it's passed in the platform's async
+  // context register. This means the `resumeFunction` parameter uses the
+  // first ABI register (ex: x86-64: rdi, arm64: x0).
+  RegisterContextSP reg_ctx =
+      thread.GetStackFrameAtIndex(0)->GetRegisterContext();
+  constexpr unsigned resume_fn_regnum = LLDB_REGNUM_GENERIC_ARG1;
+  unsigned resume_fn_reg = reg_ctx->ConvertRegisterKindToRegisterNumber(
+      RegisterKind::eRegisterKindGeneric, resume_fn_regnum);
+  uint64_t resume_fn_ptr = reg_ctx->ReadRegisterAsUnsigned(resume_fn_reg, 0);
+  if (!resume_fn_ptr)
+    return {};
+
+  auto arch = reg_ctx->CalculateTarget()->GetArchitecture();
+  std::optional<AsyncUnwindRegisterNumbers> async_regs =
+      GetAsyncUnwindRegisterNumbers(arch.GetMachine());
+  if (!async_regs)
+    return {};
+  unsigned async_reg_number = reg_ctx->ConvertRegisterKindToRegisterNumber(
+      async_regs->GetRegisterKind(), async_regs->async_ctx_regnum);
+  uint64_t async_ctx = reg_ctx->ReadRegisterAsUnsigned(async_reg_number, 0);
+  if (!async_ctx)
+    return {};
+
+  return std::make_shared<ThreadPlanRunToAddressOnAsyncCtx>(
+      thread, resume_fn_ptr, async_ctx);
+}
+
 static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop_others) {
   // Here are the trampolines we have at present.
@@ -319,7 +426,11 @@ static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
   if (symbol_addr != cur_addr)
     return nullptr;
 
-  const char *symbol_name = symbol->GetMangled().GetMangledName().AsCString();
+  Mangled &mangled_symbol_name = symbol->GetMangled();
+  const char *symbol_name = mangled_symbol_name.GetMangledName().AsCString();
+
+  if (mangled_symbol_name.GetDemangledName() == "swift_task_switch")
+    return CreateRunThroughTaskSwitchThreadPlan(thread);
 
   ThunkKind thunk_kind = GetThunkKind(symbol);
   ThunkAction thunk_action = GetThunkAction(thunk_kind);

lldb/test/API/lang/swift/async/stepping/step_over/Makefile

@@ -0,0 +1,3 @@
+SWIFT_SOURCES := main.swift
+SWIFTFLAGS_EXTRAS := -parse-as-library
+include Makefile.rules

lldb/test/API/lang/swift/async/stepping/step_over/TestSwiftAsyncStepOver.py

@@ -0,0 +1,35 @@
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbtest as lldbtest
+import lldbsuite.test.lldbutil as lldbutil
+
+
+@skipIfAsan  # rdar://138777205
+class TestCase(lldbtest.TestBase):
+
+    def check_is_in_line(self, thread, linenum):
+        frame = thread.frames[0]
+        line_entry = frame.GetLineEntry()
+        self.assertEqual(linenum, line_entry.GetLine())
+
+    @swiftTest
+    @skipIf(oslist=["windows", "linux"])
+    def test(self):
+        """Test conditions for async step-over."""
+        self.build()
+
+        source_file = lldb.SBFileSpec("main.swift")
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, "BREAK HERE", source_file
+        )
+
+        expected_line_nums = [4]  # print(x)
+        expected_line_nums += [5, 6, 7, 5, 6, 7, 5]  # two runs over the loop
+        expected_line_nums += [8, 9]  # if line + if block
+        # FIXME: IRGen is producing incorrected line numbers. rdar://139826231
+        expected_line_nums[-1] = 11
+        for expected_line_num in expected_line_nums:
+            thread.StepOver()
+            stop_reason = thread.GetStopReason()
+            self.assertStopReason(stop_reason, lldb.eStopReasonPlanComplete)
+            self.check_is_in_line(thread, expected_line_num)

lldb/test/API/lang/swift/async/stepping/step_over/main.swift

@@ -0,0 +1,16 @@
+@main enum entry {
+  static func main() async {
+    let x = await f() // BREAK HERE
+    print(x)
+    for i in 1...2 {
+      await f()
+    }
+    if (await f() == 30) {
+      print("here!")
+    }
+  }
+}
+
+func f() async -> Int {
+  return 30
+}