Add backtrace command, and tests

Author: kastiglione

lldb/source/Plugins/Language/Swift/SwiftFormatters.cpp

@@ -820,16 +820,6 @@ class TaskSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
                    "could not get info for async task {0:x}: {1}", task_ptr,
                    fmt_consume(std::move(err)));
         } else {
-
-          // Print a backtrace of the Task to stdout.
-          ExecutionContext exe_ctx{m_backend.GetExecutionContextRef()};
-          auto tt = std::make_shared<ThreadTask>(
-              3000, task_info->resumeAsyncContext, exe_ctx);
-          StreamString ss;
-          tt->GetStatus(ss, 0, 100, 0, false, true);
-          auto desc = ss.GetString();
-          printf("%.*s\n", (int)desc.size(), desc.data());
-
           m_task_info = *task_info;
           for (auto child :
                {m_is_child_task_sp, m_is_future_sp, m_is_group_child_task_sp,

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

@@ -401,6 +401,7 @@ class TargetReflectionContext : public ReflectionContextInterface {
     result.hasIsRunning = task_info.HasIsRunning;
     result.isRunning = task_info.IsRunning;
     result.isEnqueued = task_info.IsEnqueued;
+    result.id = task_info.Id;
     result.resumeAsyncContext = task_info.ResumeAsyncContext;
     return result;
   }

lldb/source/Plugins/LanguageRuntime/Swift/ReflectionContextInterface.h

@@ -164,6 +164,7 @@ class ReflectionContextInterface {
     bool hasIsRunning = false;
     bool isRunning = false;
     bool isEnqueued = false;
+    uint64_t id = 0;
     lldb::addr_t resumeAsyncContext = LLDB_INVALID_ADDRESS;
   };
   // The default limits are copied from swift-inspect.

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

@@ -16,6 +16,7 @@
 #include "SwiftMetadataCache.h"
 
 #include "Plugins/ExpressionParser/Swift/SwiftPersistentExpressionState.h"
+#include "Plugins/LanguageRuntime/Swift/SwiftTask.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "Plugins/TypeSystem/Swift/SwiftDemangle.h"
@@ -47,6 +48,7 @@
 #include "lldb/ValueObject/ValueObjectCast.h"
 #include "lldb/ValueObject/ValueObjectConstResult.h"
 #include "lldb/ValueObject/ValueObjectVariable.h"
+#include "llvm/Support/FormatAdapters.h"
 
 #include "lldb/lldb-enumerations.h"
 #include "swift/AST/ASTMangler.h"
@@ -2083,6 +2085,84 @@ class CommandObjectSwift_RefCount : public CommandObjectRaw {
   }
 };
 
+class CommandObjectLanguageSwiftTaskBacktrace final
+    : public CommandObjectParsed {
+public:
+  CommandObjectLanguageSwiftTaskBacktrace(CommandInterpreter &interpreter)
+      : CommandObjectParsed(interpreter, "backtrace",
+                            "Show the backtrace of Swift tasks. See `thread "
+                            "backtrace` for customizing backtrace output.",
+                            "language swift task backtrace <variable-name>") {
+    AddSimpleArgumentList(eArgTypeVarName);
+  }
+
+private:
+  void DoExecute(Args &command, CommandReturnObject &result) override {
+    if (!m_exe_ctx.GetFramePtr()) {
+      result.AppendError("no active frame selected");
+      return;
+    }
+
+    if (command[0].ref().empty()) {
+      result.AppendError("no task variable");
+      return;
+    }
+
+    StackFrame &frame = m_exe_ctx.GetFrameRef();
+    uint32_t path_options =
+        StackFrame::eExpressionPathOptionsAllowDirectIVarAccess;
+    VariableSP var_sp;
+    Status status;
+    ValueObjectSP valobj_sp = frame.GetValueForVariableExpressionPath(
+        command[0].c_str(), eDynamicDontRunTarget, path_options, var_sp,
+        status);
+    if (!valobj_sp)
+      return;
+
+    ValueObjectSP task_obj_sp = valobj_sp->GetChildMemberWithName("_task");
+    if (!task_obj_sp)
+      return;
+    uint64_t task_ptr = task_obj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+    if (task_ptr == LLDB_INVALID_ADDRESS)
+      return;
+    auto *runtime = SwiftLanguageRuntime::Get(m_exe_ctx.GetProcessSP());
+    if (!runtime)
+      return;
+    ThreadSafeReflectionContext reflection_ctx =
+        runtime->GetReflectionContext();
+    llvm::Expected<ReflectionContextInterface::AsyncTaskInfo> task_info =
+        reflection_ctx->asyncTaskInfo(task_ptr);
+    if (auto err = task_info.takeError()) {
+      LLDB_LOG(GetLog(LLDBLog::DataFormatters | LLDBLog::Types),
+               "could not get info for async task {0:x}: {1}", task_ptr,
+               fmt_consume(std::move(err)));
+      return;
+    }
+
+    auto thread_task = ThreadTask::Create(
+        task_info->id, task_info->resumeAsyncContext, m_exe_ctx);
+    if (auto error = thread_task.takeError()) {
+      result.AppendError(toString(std::move(error)));
+      return;
+    }
+    thread_task.get()->GetStatus(result.GetOutputStream(), 0, UINT32_MAX, 0,
+                                 false, false);
+    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
+  }
+};
+
+class CommandObjectLanguageSwiftTask final : public CommandObjectMultiword {
+public:
+  CommandObjectLanguageSwiftTask(CommandInterpreter &interpreter)
+      : CommandObjectMultiword(
+            interpreter, "task", "Commands for inspecting Swift Tasks.",
+            "language swift task <subcommand> [<subcommand-options>]") {
+    LoadSubCommand("backtrace",
+                   CommandObjectSP(new CommandObjectLanguageSwiftTaskBacktrace(
+                       interpreter)));
+  }
+};
+
 class CommandObjectMultiwordSwift : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordSwift(CommandInterpreter &interpreter)
@@ -2094,6 +2174,8 @@ class CommandObjectMultiwordSwift : public CommandObjectMultiword {
                                    interpreter)));
     LoadSubCommand("refcount", CommandObjectSP(new CommandObjectSwift_RefCount(
                                    interpreter)));
+    LoadSubCommand("task", CommandObjectSP(new CommandObjectLanguageSwiftTask(
+                               interpreter)));
   }
 
   virtual ~CommandObjectMultiwordSwift() {}

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

@@ -1,35 +1,47 @@
 #include "SwiftTask.h"
 #include "SwiftLanguageRuntime.h"
 #include "lldb/Target/Process.h"
+#include "lldb/lldb-enumerations.h"
+#include "llvm/Support/Error.h"
 
 using namespace llvm;
 using namespace lldb;
 
 namespace lldb_private {
 
-ThreadTask::ThreadTask(tid_t tid, addr_t async_ctx, ExecutionContext &exe_ctx)
+ThreadTask::ThreadTask(tid_t tid, addr_t async_ctx, addr_t resume_fn,
+                       ExecutionContext &exe_ctx)
     : Thread(exe_ctx.GetProcessRef(), tid, true),
-      m_reg_info_sp(exe_ctx.GetFrameSP()->GetRegisterContext()) {
-  m_async_ctx = async_ctx;
-  uint32_t ptr_size =
-      exe_ctx.GetTargetRef().GetArchitecture().GetAddressByteSize();
+      m_reg_info_sp(exe_ctx.GetFrameSP()->GetRegisterContext()),
+      m_async_ctx(async_ctx), m_resume_fn(resume_fn) {}
+
+RegisterContextSP lldb_private::ThreadTask::GetRegisterContext() {
+  if (!m_async_reg_ctx_sp)
+    m_async_reg_ctx_sp = std::make_shared<RegisterContextTask>(
+        *this, m_reg_info_sp, m_resume_fn, m_async_ctx);
+  return m_async_reg_ctx_sp;
+}
+
+llvm::Expected<std::shared_ptr<ThreadTask>>
+ThreadTask::Create(tid_t tid, addr_t async_ctx, ExecutionContext &exe_ctx) {
+  auto &process = exe_ctx.GetProcessRef();
+  auto &target = exe_ctx.GetTargetRef();
+
   // A simplified description of AsyncContext. See swift/Task/ABI.h
   // struct AsyncContext {
   //   AsyncContext *Parent;                    // offset 0
   //   TaskContinuationFunction *ResumeParent;  // offset 8
   // };
-  uint32_t resume_offset = ptr_size; // offsetof(AsyncContext, ResumeParent)
-  uint32_t resume_ptr = async_ctx + resume_offset;
+  // The resume function is stored at `offsetof(AsyncContext, ResumeParent)`,
+  // which is the async context's base address plus the size of a pointer.
+  uint32_t ptr_size = target.GetArchitecture().GetAddressByteSize();
+  addr_t resume_ptr = async_ctx + ptr_size;
   Status status;
-  m_resume_fn =
-      exe_ctx.GetProcessRef().ReadPointerFromMemory(resume_ptr, status);
-}
+  addr_t resume_fn = process.ReadPointerFromMemory(resume_ptr, status);
+  if (status.Fail() || resume_fn == LLDB_INVALID_ADDRESS)
+    return createStringError("failed to read task's resume function");
 
-RegisterContextSP lldb_private::ThreadTask::GetRegisterContext() {
-  if (!m_async_reg_ctx_sp)
-    m_async_reg_ctx_sp = std::make_shared<RegisterContextTask>(
-        *this, m_reg_info_sp, m_resume_fn, m_async_ctx);
-  return m_async_reg_ctx_sp;
+  return std::make_shared<ThreadTask>(tid, async_ctx, resume_fn, exe_ctx);
 }
 
 RegisterContextTask::RegisterContextTask(Thread &thread,

lldb/source/Plugins/LanguageRuntime/Swift/SwiftTask.h

@@ -15,9 +15,13 @@ using namespace lldb;
 /// Task's "async context" (instead of the stack).
 ///
 /// See `Task<Success, Failure>` and `UnsafeCurrentTask`
-class ThreadTask : public Thread {
+class ThreadTask final : public Thread {
 public:
-  ThreadTask(tid_t tid, addr_t async_ctx, ExecutionContext &exe_ctx);
+  ThreadTask(tid_t tid, addr_t async_ctx, addr_t resume_fn,
+             ExecutionContext &exe_ctx);
+
+  static llvm::Expected<std::shared_ptr<ThreadTask>>
+  Create(tid_t tid, addr_t async_ctx, ExecutionContext &exe_ctx);
 
   /// Returns a Task specific register context (RegisterContextTask).
   RegisterContextSP GetRegisterContext() override;
@@ -45,7 +49,7 @@ class ThreadTask : public Thread {
 
 /// A Swift Task specific register context. Supporting class for `ThreadTask`,
 /// see its documentation for details.
-class RegisterContextTask : public RegisterContext {
+class RegisterContextTask final : public RegisterContext {
 public:
   RegisterContextTask(Thread &thread, RegisterContextSP reg_info_sp,
                       addr_t resume_fn, addr_t async_ctx);

lldb/test/API/lang/swift/async/tasks/Makefile

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

lldb/test/API/lang/swift/async/tasks/TestSwiftTaskBacktrace.py

@@ -0,0 +1,21 @@
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import TestBase
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class TestCase(TestBase):
+    def test(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(
+            self, "break here", lldb.SBFileSpec("main.swift")
+        )
+        self.expect(
+            "language swift task backtrace task",
+            substrs=[
+                ".sleep(",
+                "`second() at main.swift:6",
+                "`first() at main.swift:2",
+                "`closure #1 in static Main.main() at main.swift:12",
+            ],
+        )

lldb/test/API/lang/swift/async/tasks/main.swift

@@ -0,0 +1,17 @@
+func first() async {
+    await second()
+}
+
+func second() async {
+    try? await Task.sleep(for: .seconds(10))
+}
+
+@main struct Main {
+    static func main() async {
+        let task = Task {
+            await first()
+        }
+        try? await Task.sleep(for: .seconds(0.01))
+        print("break here")
+    }
+}