[lldb][AArch64] Add UnwindPlan for Linux sigreturn

[DavidSpickett]

Summary

This adds a specific unwind plan for AArch64 Linux sigreturn frames.
Previously we assumed that the fp would be valid here but it is not.

https://github.com/torvalds/linux/blob/master/arch/arm64/kernel/vdso/sigreturn.S

On Ubuntu Bionic it happened to point to an old frame info which meant
you got what looked like a correct backtrace. On Focal, the info is
completely invalid. (probably due to some code shuffling in libc)

This adds an UnwindPlan that knows that the sp in a sigreturn frame
points to an rt_sigframe from which we can offset to get saved
sp and pc values to backtrace correctly.

Based on LibUnwind's change: https://reviews.llvm.org/D90898

A new test is added that sets all compares the frames from the initial
signal catch to the handler break. Ensuring that the stack/frame pointer,
function name and register values match.
(this test is AArch64 Linux specific because it's the only one
with a specific unwind plan for this situation)

Fixes https://bugs.llvm.org/show_bug.cgi?id=52165

[DavidSpickett]

lldb/source/Symbol/AArch64UnwindInfo.cpp

40 ↗

(On Diff #380668)

This comment comes from the libunwind change.

58 ↗

(On Diff #380668)

If this means "at all instructions within that function" this could be yes, but no one seems to read this field anyway.

[omjavaid]

This look great. Thanks for doing the legit fix.

@mgorny This is something you might wanna implement/test on BSD.

[labath]

I don't think this is a scalable way to fix this, and should get more discussion. Jason what do you make of this?

[labath]

I'm sorry for terse response. I wanted to ensure this gets more attention, but I wasn't able to look at this straight away. Let me try to elaborate.

We generally try to avoid platform-specific code in the core libraries. The unwind code is one of the biggest offenders here, but I'd still want to avoid making it worse, particularly if there is a fairly simple way to avoid that. And I think there might be one. We already involve the Platform class in the unwinding logic (see Platform::GetTrapHandlerSymbolNames). Since it already knows about their names, it doesn't seem far-fetched to have it provide a way to unwind out of them (if necessary). Creating a new Platform entry point to provide the unwind plan (or somehow refactoring the GetTrapHandlerSymbolNames so that it can also provide an unwind plan) would enable us to put this code into PlatformLinux, which (although not ideal) seems much better than smacking it into the middle of the Symbol library. It also seems consistent with the intent in one of the comments in the code you modify.

lldb/source/Symbol/AArch64UnwindInfo.cpp

58 ↗

(On Diff #380668)

The way I read it is "all locations within the range of this unwind plan" as given by UnwindPlan::GetAddressRange. compiler-generated unwind plans might cover the entire function, but only be valid (correct) at call sites.

lldb/source/Target/RegisterContextUnwind.cpp

895–896

this comment

[DavidSpickett]

Creating a new Platform entry point to provide the unwind plan (or somehow refactoring the GetTrapHandlerSymbolNames so that it can also provide an unwind plan)

Makes sense, I'll try that.

[DavidSpickett]

lldb/source/Symbol/AArch64UnwindInfo.cpp

58 ↗

(On Diff #380668)

So this would be valid at all instructions because at any point in __kernel_rt_sigreturn the stack pointer is the same.

[DavidSpickett]

Set ValidAtAllInstructions.

Move building unwind plan into PlatformLinux and add a platform method
to lookup unwind plans for signal handlers. I'm still checking architecture
in PlatformLinux but it does move the code out of Symbol.

The only per arch thing on lldb's side is Architecture plugins but they're
not meant to know about operating system. So it seems like a reasonable
compromise to put it in PlatformLinux.

[DavidSpickett]

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

258

PlatformLinux lists 3 handlers:

• _sigtramp
• __kernel_rt_sigreturn
• __restore_rt

I think the first 2 are the same for AArch64 due to this line in the kernel:
VDSO_sigtramp = __kernel_rt_sigreturn;

The third is for real time signals which I'm only just learning about. So I'll see what that's about but probably not relevant for this change.

[DavidSpickett]

Set SP not FP based on the sigcontext.

Before, the SP of the frame before sigcontext would be incorrect.
(noticed while testing alt signal stacks)

This was already done in the libunwind change but I got them mixed up.

I'll come up with some addition to the tests to check this.

[labath]

Thanks for doing this. Just a couple of comments inline.

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

288

I have a feeling that this eRegisterKind enum should correspond with the register numbers used in the unwind plan. It'd be great if it did, as then you could replace arm64_dwarf::{pc,sp} with LLDB_REGNUM_GENERIC_{PC,SP}, and avoid including the arm64 header. Though if it does work as I remember, then I guess the question is how does this work in the first place.

303–305

If you passed in a llvm::Triple, you could replace this with triple.isAArch64().

And one could imagine that e.g. the environment field of the triple could be important in determining the precise unwind plan.

lldb/source/Target/RegisterContextUnwind.cpp

895–896

I guess we should also update this comment now. Maybe:

On some platforms the unwind information for signal handlers is not present or correct. Give the platform plugins a chance to provide substitute plan. Otherwise, use eh_frame.

?

[labath]

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

295

Ah now I see that it worked because of this. Maybe you could try dropping this line and replace the dwarf numbers with generic regnums?

[DavidSpickett]

Turns out comparing thread.get_thread_frames() doesn't work because
you end up getting references to the same frames. Instead save the info
we want to compare.

One obvious reason this tactic should have failed is that the libc raise
frame will have a different ID between the two backtraces. This is why I've
ignored ID in the comparion.

Doing this showed me that sp and fp should be set, so I've got fp from
the sigcontext also.

[DavidSpickett]

Thanks for doing this. Just a couple of comments inline.

Will respond to these shortly.

[labath]

Since the signal context contains a copy of all registers, maybe you should be setting all of them. The other registers will not be used for unwinding, but they will enable to user to inspect the registers in the stack frames above the signal handler.
One way to demonstrate (and test) this would be to have a bit of inline asm, which sets all registers to known values, and then raises a signal (SIGILL is probably the easiest to raise from asm). Then lldb breaks on the signal handler, goes up the stack, and observes the registers.

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

295

Except of course, if you end up setting all of the registers.

[DavidSpickett]

Use generic register names and don't set type to DWARF.

Pass triple instead of machine and use isAArch64.

[DavidSpickett]

Update comment.

[DavidSpickett]

One way to demonstrate (and test) this would be to have a bit of inline asm, which sets all registers to known values, and then raises a signal (SIGILL is probably the easiest to raise from asm).

I will give that a go, probably as a separate test case.

[DavidSpickett]

• Set locations for all general purpose registers
• Set register type to DWARF due to that
• Add a new test that sets known register values and compares them between signal catch and handler
• Remove changes to handle abort test (though I could do those as a separate thing later)

One thing remains, the sigcontext can include floating point and SVE
registers. We'd need to read some memory to determine if it does:
https://github.com/torvalds/linux/blob/master/arch/arm64/include/uapi/asm/sigcontext.h#L39

Which I can do by passing the target and generating the plan based on
what's present.

For now let me know if the test case makes sense. Maybe this is ok
to go in as is and I can follow up with the other registers?

[DavidSpickett]

I'll at least make the floating point/SVE changes children of this review since it'll add some complexity.

[DavidSpickett]

lldb/test/API/linux/aarch64/unwind_signal/main.c

24

In my testing the kernel didn't go out of its way to change all the register values but it always changed a few so the test fails consistently if the unwind plan doesn't set the locations.

[labath]

In D112069#3120951, @DavidSpickett wrote:

• Set locations for all general purpose registers
• Set register type to DWARF due to that
• Add a new test that sets known register values and compares them between signal catch and handler
• Remove changes to handle abort test (though I could do those as a separate thing later)

One thing remains, the sigcontext can include floating point and SVE
registers. We'd need to read some memory to determine if it does:
https://github.com/torvalds/linux/blob/master/arch/arm64/include/uapi/asm/sigcontext.h#L39

Which I can do by passing the target and generating the plan based on
what's present.

For now let me know if the test case makes sense. Maybe this is ok
to go in as is and I can follow up with the other registers?

Yes, this is definitely fine. Thanks for taking your time to do that.

Dynamically generating unwind plans based on the contents of memory kinda goes against the concept of unwind plans, which were meant to be static (and cacheable) descriptions of how to unwind from a given point (PC) in a program. I guess the most "pure" solution would be to encode this logic into the dwarf expressions for the relevant registers. I think this should be doable (dwarf expressions being turing-complete and all), but the resulting expressions would probably be horrendous.

Overall, I'm not too worried about not being able to recover non-gpr registers so (unless you really want to work on this) I think that can stay unimplemented. (I'd also be fine with not recovering gpr registers either, though it's obviously better if they are -- the reason this came up was because I was looking at ways to simplify the eRegisterKind business).

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

322

Change to eRegisterKindDWARF and remove the SetRegisterKind call below.

lldb/test/API/linux/aarch64/unwind_signal/TestUnwindSignal.py

82–83

I don't think this is bad, but you could just hardcode the expectations into the python file. Then you could skip this step and continue straight to the final breakpoint.

lldb/test/API/linux/aarch64/unwind_signal/main.c

24

One could also have a similar block (but with different values) in the signal handler, which would guarantee that all registers are being read from the stack.

[DavidSpickett]

• Set x registers to a different pattern in the signal handler
• Don't save frames before and after, just check for the right pattern when unwinding out of the handler to sigill()
• Set register kind when we first make the unwind plan

[DavidSpickett]

Thanks for the help, really helped get a high quality fix!

lldb/include/lldb/Target/Platform.h

public:
   /// not populate it.  Subclasses should add the names of the asynchronous
   /// signal handler routines as needed.  For most Unix platforms, add
   /// _sigtramp.
   ///
   /// \return
   ///     A list of symbol names.  The list may be empty.
   virtual const std::vector<ConstString> &GetTrapHandlerSymbolNames();
 
+  /// Try to get a specific unwind plan for a named trap handler.
+  /// The default is not to have specific unwind plans for trap handlers.
+  ///
+  /// \param[in] triple
+  ///     Triple of the current target.
+  ///
+  /// \param[in] name
+  ///     Name of the trap handler function.
+  ///
+  /// \return
+  ///     A specific unwind plan for that trap handler, or an empty
+  ///     shared pointer. The latter means there is no specific plan,
+  ///     unwind as normal.
+  virtual lldb::UnwindPlanSP
+  GetTrapHandlerUnwindPlan(const llvm::Triple &triple, ConstString name) {
+    return {};
+  }
+
   /// Find a support executable that may not live within in the standard
   /// locations related to LLDB.
   ///
   /// Executable might exist within the Platform SDK directories, or in
   /// standard tool directories within the current IDE that is running LLDB.
   ///
   /// \param[in] basename
   ///     The basename of the executable to locate in the current

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

public:
   bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;
 
   uint32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) override;
 
   bool CanDebugProcess() override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
+  lldb::UnwindPlanSP GetTrapHandlerUnwindPlan(const llvm::Triple &triple,
+                                              ConstString name) override;
+
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 };
 
 } // namespace platform_linux
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_LINUX_PLATFORMLINUX_H

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

 //===-- PlatformLinux.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PlatformLinux.h"
 #include "lldb/Host/Config.h"
 
 #include <cstdio>
 #if LLDB_ENABLE_POSIX
 #include <sys/utsname.h>
 #endif
 
+#include "Utility/ARM64_DWARF_Registers.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 

 }
 
 void PlatformLinux::CalculateTrapHandlerSymbolNames() {
   m_trap_handlers.push_back(ConstString("_sigtramp"));
   m_trap_handlers.push_back(ConstString("__kernel_rt_sigreturn"));
   m_trap_handlers.push_back(ConstString("__restore_rt"));
 }
 
+static lldb::UnwindPlanSP GetAArch64TrapHanlderUnwindPlan(ConstString name) {
+  UnwindPlanSP unwind_plan_sp;
+  if (name != "__kernel_rt_sigreturn")
+    return unwind_plan_sp;
+
+  UnwindPlan::RowSP row = std::make_shared<UnwindPlan::Row>();
+  row->SetOffset(0);
+
+  // In the signal trampoline frame, sp points to an rt_sigframe[1], which is:
+  //  - 128-byte siginfo struct
+  //  - ucontext struct:
+  //     - 8-byte long (uc_flags)
+  //     - 8-byte pointer (uc_link)
+  //     - 24-byte stack_t
+  //     - 128-byte signal set
+  //     - 8 bytes of padding because sigcontext has 16-byte alignment
+  //     - sigcontext/mcontext_t
+  // [1]
+  // https://github.com/torvalds/linux/blob/master/arch/arm64/kernel/signal.c
+  int32_t offset = 128 + 8 + 8 + 24 + 128 + 8;
+  // Then sigcontext[2] is:
+  // - 8 byte fault address
+  // - 31 8 byte registers
+  // - 8 byte sp
+  // - 8 byte pc
+  // [2]
+  // https://github.com/torvalds/linux/blob/master/arch/arm64/include/uapi/asm/sigcontext.h
+
+  // Skip fault address
+  offset += 8;
+  row->GetCFAValue().SetIsRegisterPlusOffset(arm64_dwarf::sp, offset);
+
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x0, 0 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x1, 1 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x2, 2 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x3, 3 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x4, 4 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x5, 5 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x6, 6 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x7, 7 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x8, 8 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x9, 9 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x10, 10 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x11, 11 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x12, 12 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x13, 13 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x14, 14 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x15, 15 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x16, 16 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x17, 17 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x18, 18 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x19, 19 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x20, 20 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x21, 21 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x22, 22 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x23, 23 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x24, 24 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x25, 25 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x26, 26 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x27, 27 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x28, 28 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::fp, 29 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::x30, 30 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::sp, 31 * 8, false);
+  row->SetRegisterLocationToAtCFAPlusOffset(arm64_dwarf::pc, 32 * 8, false);
+
+  // The sigcontext may also contain floating point and SVE registers.
+  // However this would require a dynamic unwind plan so they are not included
+  // here.
+
+  unwind_plan_sp = std::make_shared<UnwindPlan>(eRegisterKindDWARF);
+  unwind_plan_sp->AppendRow(row);
+  unwind_plan_sp->SetSourceName("AArch64 Linux sigcontext");
+  unwind_plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
+  // Because sp is the same throughout the function
+  unwind_plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolYes);
+
+  return unwind_plan_sp;
+}
+
+lldb::UnwindPlanSP
+PlatformLinux::GetTrapHandlerUnwindPlan(const llvm::Triple &triple,
+                                        ConstString name) {
+  if (triple.isAArch64())
+    return GetAArch64TrapHanlderUnwindPlan(name);
+
+  return {};
+}
+
 MmapArgList PlatformLinux::GetMmapArgumentList(const ArchSpec &arch,
                                                addr_t addr, addr_t length,
                                                unsigned prot, unsigned flags,
                                                addr_t fd, addr_t offset) {
   uint64_t flags_platform = 0;
   uint64_t map_anon = arch.IsMIPS() ? 0x800 : MAP_ANON;
 
   if (flags & eMmapFlagsPrivate)
     flags_platform |= MAP_PRIVATE;
   if (flags & eMmapFlagsAnon)
     flags_platform |= map_anon;
 
   MmapArgList args({addr, length, prot, flags_platform, fd, offset});
   return args;
 }
 

lldb/source/Target/RegisterContextUnwind.cpp

if (object_file_unwind) {
       if (object_file_unwind->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
         return unwind_plan_sp;
       else
         unwind_plan_sp.reset();
     }
 
     return arch_default_unwind_plan_sp;
   }
 
-  // If we're in _sigtramp(), unwinding past this frame requires special
-  // knowledge.  On Mac OS X this knowledge is properly encoded in the eh_frame
-  // section, so prefer that if available. On other platforms we may need to
-  // provide a platform-specific UnwindPlan which encodes the details of how to
-  // unwind out of sigtramp.
   if (m_frame_type == eTrapHandlerFrame && process) {
     m_fast_unwind_plan_sp.reset();
+
+    // On some platforms the unwind information for signal handlers is not
+    // present or correct. Give the platform plugins a chance to provide
+    // substitute plan. Otherwise, use eh_frame.
+    if (m_sym_ctx_valid) {
+      lldb::PlatformSP platform = process->GetTarget().GetPlatform();
+      unwind_plan_sp = platform->GetTrapHandlerUnwindPlan(
+          process->GetTarget().GetArchitecture().GetTriple(),
+          GetSymbolOrFunctionName(m_sym_ctx));
+
+      if (unwind_plan_sp)
+        return unwind_plan_sp;
+    }
+
     unwind_plan_sp =
         func_unwinders_sp->GetEHFrameUnwindPlan(process->GetTarget());
     if (!unwind_plan_sp)
       unwind_plan_sp =
           func_unwinders_sp->GetObjectFileUnwindPlan(process->GetTarget());
     if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress(m_current_pc) &&
         unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes) {
       return unwind_plan_sp;

lldb/test/API/functionalities/signal/handle-abrt/TestHandleAbort.py

 
 class HandleAbortTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows  # signals do not exist on Windows
-    # Fails on Ubuntu Focal
-    @skipIf(archs=["aarch64"], oslist=["linux"])
     @expectedFailureNetBSD
     def test_inferior_handle_sigabrt(self):
         """Inferior calls abort() and handles the resultant SIGABRT.
            Stopped at a breakpoint in the handler, verify that the backtrace
            includes the function that called abort()."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 

lldb/test/API/linux/aarch64/unwind_signal/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/linux/aarch64/unwind_signal/TestUnwindSignal.py

-"""Test that we can unwind out of a SIGABRT handler"""
-
-
+"""Test that we can unwind out of a signal handler.
+   Which for AArch64 Linux requires a specific unwind plan."""
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class HandleAbortTestCase(TestBase):
+class UnwindSignalTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
-    @skipIfWindows  # signals do not exist on Windows
-    # Fails on Ubuntu Focal
-    @skipIf(archs=["aarch64"], oslist=["linux"])
-    @expectedFailureNetBSD
-    def test_inferior_handle_sigabrt(self):
-        """Inferior calls abort() and handles the resultant SIGABRT.
-           Stopped at a breakpoint in the handler, verify that the backtrace
-           includes the function that called abort()."""
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
+    def test_unwind_signal(self):
+        """Inferior calls sigill() and handles the resultant SIGILL.
+           Stopped at a breakpoint in the handler, check that we can unwind
+           back to sigill() and get the expected register contents there."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
-        # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
-        # launch
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetState(), lldb.eStateStopped)
-        signo = process.GetUnixSignals().GetSignalNumberFromName("SIGABRT")
+        signo = process.GetUnixSignals().GetSignalNumberFromName("SIGILL")
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread and thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There should be data in the event.")
         self.assertEqual(thread.GetStopReasonDataAtIndex(0),
-                         signo, "The stop signal should be SIGABRT")
+                         signo, "The stop signal should be SIGILL")
 
-        # Continue to breakpoint in abort handler
+        # Continue to breakpoint in sigill handler
         bkpt = target.FindBreakpointByID(
             lldbutil.run_break_set_by_source_regexp(self, "Set a breakpoint here"))
         threads = lldbutil.continue_to_breakpoint(process, bkpt)
         self.assertEqual(len(threads), 1, "Expected single thread")
         thread = threads[0]
 
         # Expect breakpoint in 'handler'
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual(frame.GetDisplayFunctionName(), "handler", "Unexpected break?")
 
-        # Expect that unwinding should find 'abort_caller'
-        foundFoo = False
-        for frame in thread:
-            if frame.GetDisplayFunctionName() == "abort_caller":
-                foundFoo = True
+        # Expect that unwinding should find 'sigill'
+        found_caller = False
+        for frame in thread.get_thread_frames():
+            if frame.GetDisplayFunctionName() == "sigill":
+                # We should have ascending values in the x registers
+                regs = frame.GetRegisters().GetValueAtIndex(0)
+                err = lldb.SBError()
+
+                for i in range(31):
+                  name = 'x{}'.format(i)
+                  value = regs.GetChildMemberWithName(name).GetValueAsUnsigned(err)
+                  self.assertTrue(err.Success(), "Failed to get register {}: {}".format(
+                                      name, err))
+                  self.assertEqual(value, i, "Unexpected value for register {}".format(
+                                      name))
+
+                found_caller = True
+                break
 
-        self.assertTrue(foundFoo, "Unwinding did not find func that called abort")
+        self.assertTrue(found_caller, "Unwinding did not find func that caused the SIGILL")
 
         # Continue until we exit.
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), 0)

lldb/test/API/linux/aarch64/unwind_signal/main.c

+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void handler(int sig) {
+  // The kernel only changes a few registers so set them all to something other
+  // than the values in sigill() so that we can't fall back to real registers
+  // and still pass the test.
+#define SETREG(N) "mov x" N ", #" N "+1\n\t"
+  asm volatile(
+      /* clang-format off */
+      /* x0 is used for a parameter */
+                   SETREG("1")  SETREG("2")  SETREG("3")
+      SETREG("4")  SETREG("5")  SETREG("6")  SETREG("7")
+      SETREG("8")  SETREG("9")  SETREG("10") SETREG("11")
+      SETREG("12") SETREG("13") SETREG("14") SETREG("15")
+      SETREG("16") SETREG("17") SETREG("18") SETREG("19")
+      SETREG("20") SETREG("21") SETREG("22") SETREG("23")
+      SETREG("24") SETREG("25") SETREG("26") SETREG("27")
+      SETREG("28") // fp/x29 needed for unwiding
+      SETREG("30") // 31 is xzr/sp
+      /* clang-format on */
+      ::
+          : /* skipped x0 */ "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8",
+            "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18",
+            "x19", "x20", "x21", "x22", "x23", "x24", "x25", "x26", "x27",
+            "x28",
+            /* skipped fp/x29 */ "x30");
+  printf("Set a breakpoint here.\n");
+  exit(0);
+}
+
+static void sigill() {
+  // Set all general registers to known values to check
+  // that the signal unwind plan sets their locations correctly.
+#define SETREG(N) "mov x" N ", #" N "\n\t"
+  asm volatile(
+      /* clang-format off */
+      SETREG("0")  SETREG("1")  SETREG("2")  SETREG("3")
+      SETREG("4")  SETREG("5")  SETREG("6")  SETREG("7")
+      SETREG("8")  SETREG("9")  SETREG("10") SETREG("11")
+      SETREG("12") SETREG("13") SETREG("14") SETREG("15")
+      SETREG("16") SETREG("17") SETREG("18") SETREG("19")
+      SETREG("20") SETREG("21") SETREG("22") SETREG("23")
+      SETREG("24") SETREG("25") SETREG("26") SETREG("27")
+      SETREG("28") SETREG("29") SETREG("30") /* 31 is xzr/sp */
+      /* clang-format on */
+      ".inst   0x00000000\n\t" // udf #0 (old binutils don't support udf)
+      ::
+          : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10",
+            "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19",
+            "x20", "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28",
+            "x29", "x30");
+}
+
+int main() {
+  if (signal(SIGILL, handler) == SIG_ERR) {
+    perror("signal");
+    return 1;
+  }
+
+  sigill();
+  return 2;
+}