[lldb] Introduce backtracing of Swift Tasks

Author: kastiglione

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

@@ -14,6 +14,7 @@
 #include "Plugins/Language/Swift/SwiftStringIndex.h"
 #include "Plugins/LanguageRuntime/Swift/ReflectionContextInterface.h"
 #include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
+#include "Plugins/LanguageRuntime/Swift/SwiftTask.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
@@ -23,6 +24,7 @@
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/ValueObject/ValueObject.h"
 #include "lldb/lldb-enumerations.h"
@@ -818,6 +820,16 @@ 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/CMakeLists.txt

@@ -6,6 +6,7 @@ add_lldb_library(lldbPluginSwiftLanguageRuntime PLUGIN
   SwiftLanguageRuntimeNames.cpp
   SwiftLanguageRuntimeRemoteAST.cpp
   SwiftMetadataCache.cpp
+  SwiftTask.cpp
 
   LINK_LIBS
     swiftAST

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.resumeAsyncContext = task_info.ResumeAsyncContext;
     return result;
   }
 

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

@@ -15,6 +15,7 @@
 
 #include <mutex>
 
+#include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 #include "swift/ABI/ObjectFile.h"
 #include "swift/Remote/RemoteAddress.h"
@@ -163,6 +164,7 @@ class ReflectionContextInterface {
     bool hasIsRunning = false;
     bool isRunning = false;
     bool isEnqueued = false;
+    lldb::addr_t resumeAsyncContext = LLDB_INVALID_ADDRESS;
   };
   // The default limits are copied from swift-inspect.
   virtual llvm::Expected<AsyncTaskInfo>

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

@@ -0,0 +1,53 @@
+#include "SwiftTask.h"
+#include "SwiftLanguageRuntime.h"
+#include "lldb/Target/Process.h"
+
+using namespace llvm;
+using namespace lldb;
+
+lldb_private::ThreadTask::ThreadTask(tid_t tid, addr_t async_ctx,
+                                     ExecutionContext &exe_ctx)
+    : Thread(exe_ctx.GetProcessRef(), tid, true),
+      m_concrete_reg_ctx_sp(exe_ctx.GetFrameSP()->GetRegisterContext()) {
+  m_async_ctx = async_ctx;
+  auto ptr_size = exe_ctx.GetTargetRef().GetArchitecture().GetAddressByteSize();
+  // A simplified description of AsyncContext. See swift/Task/ABI.h
+  // struct AsyncContext {
+  //   AsyncContext *Parent;                    // offset 0
+  //   TaskContinuationFunction *ResumeParent;  // offset 8
+  // };
+  auto resume_offset = ptr_size; // offsetof(AsyncContext, ResumeParent)
+  auto resume_ptr = async_ctx + resume_offset;
+  Status status;
+  m_pc = exe_ctx.GetProcessRef().ReadPointerFromMemory(resume_ptr, status);
+}
+
+RegisterContextSP lldb_private::ThreadTask::GetRegisterContext() {
+  if (!m_async_reg_ctx_sp)
+    m_async_reg_ctx_sp = std::make_shared<RegisterContextTask>(
+        *this, m_concrete_reg_ctx_sp, m_pc, m_async_ctx);
+  return m_async_reg_ctx_sp;
+}
+
+lldb_private::RegisterContextTask::RegisterContextTask(
+    Thread &thread, RegisterContextSP reg_info_sp, addr_t pc, addr_t async_ctx)
+    : RegisterContext(thread, 0), m_reg_info_sp(reg_info_sp),
+      m_async_ctx(async_ctx), m_pc(pc) {
+  auto &target = thread.GetProcess()->GetTarget();
+  auto triple = target.GetArchitecture().GetTriple();
+  if (auto regnums = GetAsyncUnwindRegisterNumbers(triple.getArch()))
+    m_async_ctx_regnum = regnums->async_ctx_regnum;
+}
+
+bool lldb_private::RegisterContextTask::ReadRegister(
+    const RegisterInfo *reg_info, RegisterValue &reg_value) {
+  if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC) {
+    reg_value = m_pc;
+    return true;
+  }
+  if (reg_info->kinds[eRegisterKindLLDB] == m_async_ctx_regnum) {
+    reg_value = m_async_ctx;
+    return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,93 @@
+
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/lldb-forward.h"
+
+namespace lldb_private {
+
+using namespace lldb;
+
+/// Provides a subset of Thread operations for Swift Tasks.
+///
+/// Currently, this supports backtraces of Tasks, and selecting frames in the
+/// backtrace. Async frames make available the variables that are stored in the
+/// Task's "async context" (instead of the stack).
+///
+/// See `Task<Success, Failure>` and `UnsafeCurrentTask`
+class ThreadTask : public Thread {
+public:
+  ThreadTask(tid_t tid, addr_t async_ctx, ExecutionContext &exe_ctx);
+
+  /// Returns a Task specific register context (RegisterContextTask).
+  RegisterContextSP GetRegisterContext() override;
+
+  ~ThreadTask() override { DestroyThread(); }
+
+  // No-op overrides.
+  void RefreshStateAfterStop() override {}
+  lldb::RegisterContextSP
+  CreateRegisterContextForFrame(StackFrame *frame) override {
+    return {};
+  }
+  bool CalculateStopInfo() override { return false; }
+
+private:
+  /// A register context that is the source of `RegisterInfo` data.
+  RegisterContextSP m_concrete_reg_ctx_sp;
+  /// Lazily initialized `RegisterContextTask`.
+  RegisterContextSP m_async_reg_ctx_sp;
+  /// The Task's async context.
+  addr_t m_async_ctx = LLDB_INVALID_ADDRESS;
+  /// The address of the async context's resume function.
+  addr_t m_pc = LLDB_INVALID_ADDRESS;
+};
+
+/// A Swift Task specific register context. Supporting class for `ThreadTask`,
+/// see its documentation for details.
+class RegisterContextTask : public RegisterContext {
+public:
+  RegisterContextTask(Thread &thread, RegisterContextSP reg_info_sp, addr_t pc,
+                      addr_t async_ctx);
+
+  /// RegisterContextTask supports readonly from only two (necessary)
+  /// registers. Namely, the pc and the async context registers.
+  bool ReadRegister(const RegisterInfo *reg_info,
+                    RegisterValue &reg_value) override;
+
+  // Pass through overrides.
+  size_t GetRegisterCount() override {
+    return m_reg_info_sp->GetRegisterCount();
+  }
+  const RegisterInfo *GetRegisterInfoAtIndex(size_t idx) override {
+    return m_reg_info_sp->GetRegisterInfoAtIndex(idx);
+  }
+  size_t GetRegisterSetCount() override {
+    return m_reg_info_sp->GetRegisterSetCount();
+  }
+  const RegisterSet *GetRegisterSet(size_t reg_set) override {
+    return m_reg_info_sp->GetRegisterSet(reg_set);
+  }
+  lldb::ByteOrder GetByteOrder() override {
+    return m_reg_info_sp->GetByteOrder();
+  }
+
+  // No-op overrides.
+  void InvalidateAllRegisters() override {}
+  bool WriteRegister(const RegisterInfo *reg_info,
+                     const RegisterValue &reg_value) override {
+    return false;
+  }
+
+private:
+  /// A register context that is the source of `RegisterInfo` data.
+  RegisterContextSP m_reg_info_sp;
+  /// The architecture specific regnum (LLDB) which holds the async context.
+  uint32_t m_async_ctx_regnum = LLDB_INVALID_REGNUM;
+  /// The Task's async context.
+  RegisterValue m_async_ctx;
+  /// The address of the async context's resume function.
+  RegisterValue m_pc;
+};
+
+} // namespace lldb_private