[lldb][swift] Fix unwinding of Q funclets

Consider the following async call sequence:

AsyncFunc0_Y called by AsyncFunc1_Q called by AsyncFunc2_Q.

That is, when AsyncFunc0_Y returns, it will return to AsyncFunc1_Q.

Imagine this backtrace:

Frame 0: AsyncFunc1_Q
Frame 1: AsyncFunc2_Q

That is, AsyncFunc0_Y already finished and we are stopped at AsyncFunc1_Q.

One job of the unwinder for a frame is to produce the registers of the
**parent** frame.
For the top frame (AsyncFunc1_Q), we need to produce the x22 register of
AsyncFunc2_Q. This is the value of x22 at the start of AsyncFunc1_Q (we pretend
this register was setup as part of some imaginary function call AsyncFunc2_Q ->
AsyncFunc1_Q).

We use the following async ABI guarantee:
A) Register x22 is saved at (fp - 8) during the prologue of funclets.

As such, the following dwarf expression is used:
  *(fp - 8)

Prior to this patch, that dereference was missing.

The other job of the unwinder for a frame is to produce the CFA of that same
frame.
For the top frame (AsyncFunc1_Q) we use the following ABI guarantees:

B) Its register x22 initially points to the async context of AsyncFunc0 ("Q"
funclets are "indirect")
C) Dereferencing the first field of an async context produces the async context
of the continuation funclet.

Combining A), B), and C), the CFA of the top frame (i.e. the async context of
AsyncFunc1) can be obtained with the expression:
  **(fp - 8)
Before this patch, the unwinder was missing one dereference.

Author: felipepiovezan

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

@@ -2586,7 +2586,7 @@ lldb::addr_t SwiftLanguageRuntime::GetAsyncContext(RegisterContext *regctx) {
 /// operation. This is only valid for x86_64 or aarch64.
 llvm::ArrayRef<uint8_t>
 GetAsyncRegFromFramePointerDWARFExpr(llvm::Triple::ArchType triple,
-                                     bool with_deref) {
+                                     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
@@ -2595,11 +2595,13 @@ GetAsyncRegFromFramePointerDWARFExpr(llvm::Triple::ArchType triple,
       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
@@ -2608,7 +2610,7 @@ GetAsyncRegFromFramePointerDWARFExpr(llvm::Triple::ArchType triple,
   auto size = triple == llvm::Triple::x86_64
                   ? sizeof(g_cfa_dwarf_expression_x86_64)
                   : sizeof(g_cfa_dwarf_expression_arm64);
-  if (with_deref)
+  if (with_double_deref)
     return llvm::ArrayRef<uint8_t>(expr, size);
   return llvm::ArrayRef<uint8_t>(expr, size - 1);
 }
@@ -2708,21 +2710,23 @@ SwiftLanguageRuntime::GetRuntimeUnwindPlan(ProcessSP process_sp,
     else
       row->GetCFAValue().SetIsRegisterPlusOffset(regnums->async_ctx_regnum, 0);
   } else {
+    // 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(), true /*with_deref*/);
+        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.
+      // In indirect contexts, the frame above needs to think their x22 is what
+      // _our_ x22 is at the start of this function. This can be done by
+      // dereferencing ($fp-8) once, a location guaranteed by the ABI.
       llvm::ArrayRef<uint8_t> expr = GetAsyncRegFromFramePointerDWARFExpr(
-          arch.GetMachine(), false /*with_deref*/);
+          arch.GetMachine(), false /*with_double_deref*/);
       row->SetRegisterLocationToIsDWARFExpression(
           regnums->async_ctx_regnum, expr.data(), expr.size(), false);
     }

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()