Merge pull request #9107 from felipepiovezan/felipe/unwinding_q_funclets_rebranch

[lldb][swift] Fix unwinding of Q funclets

Author: felipepiovezan

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

@@ -2582,6 +2582,39 @@ lldb::addr_t SwiftLanguageRuntime::GetAsyncContext(RegisterContext *regctx) {
   return LLDB_INVALID_ADDRESS;
 }
 
+/// Creates an expression accessing *(fp - 8) or **(fp - 8) if
+/// `with_double_deref` is true. This is only valid for x86_64 or aarch64.
+llvm::ArrayRef<uint8_t>
+GetAsyncRegFromFramePointerDWARFExpr(llvm::Triple::ArchType triple,
+                                     bool with_double_deref) {
+  assert(triple == llvm::Triple::x86_64 || triple == llvm::Triple::aarch64);
+
+  // These expressions must have static storage, due to how UnwindPlan::Row
+  // works.
+  static const uint8_t g_cfa_dwarf_expression_x86_64[] = {
+      llvm::dwarf::DW_OP_breg6, // DW_OP_breg6, register 6 == rbp
+      0x78,                     //    sleb128 -8 (ptrsize)
+      llvm::dwarf::DW_OP_deref,
+      llvm::dwarf::DW_OP_deref,
+  };
+  static const uint8_t g_cfa_dwarf_expression_arm64[] = {
+      llvm::dwarf::DW_OP_breg29, // DW_OP_breg29, register 29 == fp
+      0x78,                      //    sleb128 -8 (ptrsize)
+      llvm::dwarf::DW_OP_deref,
+      llvm::dwarf::DW_OP_deref,
+  };
+
+  const uint8_t *expr = triple == llvm::Triple::x86_64
+                            ? g_cfa_dwarf_expression_x86_64
+                            : g_cfa_dwarf_expression_arm64;
+  auto size = triple == llvm::Triple::x86_64
+                  ? sizeof(g_cfa_dwarf_expression_x86_64)
+                  : sizeof(g_cfa_dwarf_expression_arm64);
+  if (with_double_deref)
+    return llvm::ArrayRef<uint8_t>(expr, size);
+  return llvm::ArrayRef<uint8_t>(expr, size - 1);
+}
+
 // Examine the register state and detect the transition from a real
 // stack frame to an AsyncContext frame, or a frame in the middle of
 // the AsyncContext chain, and return an UnwindPlan for these situations.
@@ -2671,64 +2704,28 @@ SwiftLanguageRuntime::GetRuntimeUnwindPlan(ProcessSP process_sp,
   const int32_t ptr_size = 8;
   row->SetOffset(0);
 
-  // A DWARF Expression to set the CFA.
-  //      pushes the frame pointer register - 8
-  //      dereference
-
-  // FIXME: Row::RegisterLocation::RestoreType doesn't have a
-  // deref(reg-value + offset) yet, shortcut around it with
-  // a dwarf expression for now.
-  // The CFA of an async frame is the address of it's associated AsyncContext.
-  // In an async frame currently on the stack, this address is stored right
-  // before the saved frame pointer on the stack.
-  static const uint8_t g_cfa_dwarf_expression_x86_64[] = {
-      llvm::dwarf::DW_OP_breg6, // DW_OP_breg6, register 6 == rbp
-      0x78,                     //    sleb128 -8 (ptrsize)
-      llvm::dwarf::DW_OP_deref,
-  };
-  static const uint8_t g_cfa_dwarf_expression_arm64[] = {
-      llvm::dwarf::DW_OP_breg29, // DW_OP_breg29, register 29 == fp
-      0x78,                      //    sleb128 -8 (ptrsize)
-      llvm::dwarf::DW_OP_deref,
-  };
-
-  constexpr unsigned expr_size = sizeof(g_cfa_dwarf_expression_arm64);
-
-  static_assert(sizeof(g_cfa_dwarf_expression_x86_64) ==
-                    sizeof(g_cfa_dwarf_expression_arm64),
-                "Code relies on DWARF  expressions being the same size");
-
-  const uint8_t *expr = nullptr;
-  if (arch.GetMachine() == llvm::Triple::x86_64)
-    expr = g_cfa_dwarf_expression_x86_64;
-  else if (arch.GetMachine() == llvm::Triple::aarch64)
-    expr = g_cfa_dwarf_expression_arm64;
-  else
-    llvm_unreachable("Unsupported architecture");
-
   if (in_prologue) {
     if (indirect_context)
       row->GetCFAValue().SetIsRegisterDereferenced(regnums->async_ctx_regnum);
     else
       row->GetCFAValue().SetIsRegisterPlusOffset(regnums->async_ctx_regnum, 0);
   } else {
-    row->GetCFAValue().SetIsDWARFExpression(expr, expr_size);
+    // In indirect funclets, dereferencing (fp-8) once produces the CFA of the
+    // frame above. Dereferencing twice will produce the current frame's CFA.
+    bool with_double_deref = indirect_context;
+    llvm::ArrayRef<uint8_t> expr = GetAsyncRegFromFramePointerDWARFExpr(
+        arch.GetMachine(), with_double_deref);
+    row->GetCFAValue().SetIsDWARFExpression(expr.data(), expr.size());
   }
 
   if (indirect_context) {
     if (in_prologue) {
       row->SetRegisterLocationToSame(regnums->async_ctx_regnum, false);
     } else {
-      // In a "resume" coroutine, the passed context argument needs to be
-      // dereferenced once to get the context. This is reflected in the debug
-      // info so we need to account for it and report am async register value
-      // that needs to be dereferenced to get to the context.
-      // Note that the size passed for the DWARF expression is the size of the
-      // array minus one. This skips the last deref for this use.
-      assert(expr[expr_size - 1] == llvm::dwarf::DW_OP_deref &&
-             "Should skip a deref");
-      row->SetRegisterLocationToIsDWARFExpression(regnums->async_ctx_regnum,
-                                                  expr, expr_size - 1, false);
+      llvm::ArrayRef<uint8_t> expr = GetAsyncRegFromFramePointerDWARFExpr(
+          arch.GetMachine(), false /*with_double_deref*/);
+      row->SetRegisterLocationToIsDWARFExpression(
+          regnums->async_ctx_regnum, expr.data(), expr.size(), false);
     }
   } else {
     // In the first part of a split async function, the context is passed

lldb/test/API/lang/swift/async/frame/variables_multiple_frames/TestSwiftAsyncFrameVarMultipleFrames.py

@@ -69,6 +69,15 @@ def test(self):
         self.check_pcs(async_frames, process, target)
         self.check_variables(async_frames, ["111", "222", "333", "444", "555"])
 
+        # Now stop at the Q funclet right after the await to ASYNC___1
+        target.DeleteAllBreakpoints()
+        target.BreakpointCreateByName("$s1a12ASYNC___2___SiyYaFTQ0_")
+        process.Continue()
+        async_frames = process.GetSelectedThread().frames
+        self.check_cfas(async_frames, process)
+        self.check_pcs(async_frames, process, target)
+        self.check_variables(async_frames, ["222", "333", "444", "555"])
+
         target.DeleteAllBreakpoints()
         target.BreakpointCreateBySourceRegex("breakpoint3", source_file)
         process.Continue()