Apply code review advice

Author: kastiglione

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

@@ -5,44 +5,51 @@
 using namespace llvm;
 using namespace lldb;
 
-lldb_private::ThreadTask::ThreadTask(tid_t tid, addr_t async_ctx,
-                                     ExecutionContext &exe_ctx)
+namespace 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_reg_info_sp(exe_ctx.GetFrameSP()->GetRegisterContext()) {
   m_async_ctx = async_ctx;
-  auto ptr_size = exe_ctx.GetTargetRef().GetArchitecture().GetAddressByteSize();
+  uint32_t 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;
+  uint32_t resume_offset = ptr_size; // offsetof(AsyncContext, ResumeParent)
+  uint32_t resume_ptr = async_ctx + resume_offset;
   Status status;
-  m_pc = exe_ctx.GetProcessRef().ReadPointerFromMemory(resume_ptr, status);
+  m_resume_fn =
+      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);
+        *this, m_reg_info_sp, m_resume_fn, 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)
+RegisterContextTask::RegisterContextTask(Thread &thread,
+                                         RegisterContextSP reg_info_sp,
+                                         addr_t resume_fn, addr_t async_ctx)
     : RegisterContext(thread, 0), m_reg_info_sp(reg_info_sp),
-      m_async_ctx(async_ctx), m_pc(pc) {
+      m_async_ctx(async_ctx), m_resume_fn(resume_fn) {
   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) {
+bool RegisterContextTask::ReadRegister(const RegisterInfo *reg_info,
+                                       RegisterValue &reg_value) {
+  if (!reg_info)
+    return false;
+
   if (reg_info->kinds[eRegisterKindGeneric] == LLDB_REGNUM_GENERIC_PC) {
-    reg_value = m_pc;
+    reg_value = m_resume_fn;
     return true;
   }
   if (reg_info->kinds[eRegisterKindLLDB] == m_async_ctx_regnum) {
@@ -51,3 +58,5 @@ bool lldb_private::RegisterContextTask::ReadRegister(
   }
   return false;
 }
+
+} // namespace lldb_private

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

@@ -34,21 +34,21 @@ class ThreadTask : public Thread {
 
 private:
   /// A register context that is the source of `RegisterInfo` data.
-  RegisterContextSP m_concrete_reg_ctx_sp;
+  RegisterContextSP m_reg_info_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;
+  addr_t m_resume_fn = 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(Thread &thread, RegisterContextSP reg_info_sp,
+                      addr_t resume_fn, addr_t async_ctx);
 
   /// RegisterContextTask supports readonly from only two (necessary)
   /// registers. Namely, the pc and the async context registers.
@@ -87,7 +87,7 @@ class RegisterContextTask : public RegisterContext {
   /// The Task's async context.
   RegisterValue m_async_ctx;
   /// The address of the async context's resume function.
-  RegisterValue m_pc;
+  RegisterValue m_resume_fn;
 };
 
 } // namespace lldb_private