Support __kernel_rt_sigreturn in frame initialization

[JosephTremoulet]

Summary

Add __kernel_rt_sigreturn to the list of trap handlers for Linux (it's
used as such on aarch64 at least).

Skip decrement-and-recompute for trap handlers in
InitializeNonZerothFrame, as signal dispatch may point the child frame's
return address to the start of the return trampoline.

[JosephTremoulet]

FYI, I sent mail about this to lldb-dev.. I'll copy the contents here for the benefit of anybody who didn't see it there but could use the context:

Hi,

I'm trying to use lldb in a project where I need to report stack traces from signal handlers, and need to do so on aarch64 Linux. Even for "synchronous" signal handling, I'm hitting a couple issues preventing this from working "out of the box":
1 - The platform signal handler trampoline function on the stack is __kernel_rt_sigreturn, not sigtramp. I'm wondering if it's ok to just add __kernel_rt_sigreturn to the list of trap handler symbol names in PlatformLinux, or if I need to include it in "UserSpecifiedTrapHandlerFunctionNames", or something else
2 - When the user handler is invoked, its return address is set to the very first byte of __kernel_rt_sigreturn, which throws off unwinding because we assume that frame must really be at a call in the preceding function. I asked about this on IRC, where Jan Kratochvil mentioned that the decrement shouldn't happen for frames with S in the eh_frame's augmentation. I've verified that __kernel_rt_sigreturn indeed has the S. I'm not sure where I'd find official documentation about that, but the DWARF Standards Committee's wiki[1] does link to Ian Lance Taylor's blog[2] which says "The character ‘S’ in the augmentation string means that this CIE represents a stack frame for the invocation of a signal handler. When unwinding the stack, signal stack frames are handled slightly differently: the instruction pointer is assumed to be before the next instruction to execute rather than after it." So I'm interested in encoding that knowledge in LLDB, but not sure architecturally whether it would be more appropriate to dig into the eh_frame record earlier, or to just have this be a property of symbols flagged as trap handlers, or something else.

I'd very much appreciate any feedback on this. I've put up a patch[3] on Phab with a testcase that demonstrates the issue (on aarch64 linux) and an implementation of the low-churn "communicate this in the trap handler symbol list" approach.

Thanks,
-Joseph

[1] - http://wiki.dwarfstd.org/index.php?title=Exception_Handling
[2] - https://www.airs.com/blog/archives/460
[3] - https://reviews.llvm.org/D63667

[jasonmolenda]

This looks good. Over in RegisterContextLLDB::GetFullUnwindPlanForFrame there's a behaves_like_zeroth_frame bool with similar setup -- in that case, it's trying to decide what type of UnwindPlan to pick for the frame, either one that is synchronous ("valid only at call sites / throwable locations") or asynchronous ("valid at every instruction"). For a behaves_like_zeroth_frame it needs to pick an asynchronous unwind plan. You may want to look at that too.

I didn't know about the S augmentation letter in eh_frame. See DWARFCallFrameInfo::ParseCIE / DWARFCallFrameInfo::FDEToUnwindPlan, that's where those are parsed. Each function with eh_frame has an FDE, and the FDE will refer to a CIE with basic setup information. Usually multiple FDE entries point to a single CIE, with the CIE specifying the things that are common among them all (usually things like the initial unwind state on function entry and such). We could add the flag to the UnwindPlan object. This would basically be telling us the same thing that IsTrapHandlerSymbol() is telling us, right, but I'm not sure the order of operations would make it easy to use - we pick out an unwind plan (which might be eh_frame based) too late, if I remember the codeflow right. It'd be a good change to capture that information from the eh_frame though, even if we don't see a clear way to use it right now.

We're going to pick up a FuncUnwinders object (an object with all the unwind plans for a given function) pretty early I bet, but we don't want to force a parse of eh_frame when we're creating that object if we can avoid it - parsing the eh_frame section of a binary the first time (and creating an index into it) is relatively slow, so we try to put it off if we can.

fwiw, and I think you've got this figured out already, with asynchronous signals we want to say (1) don't decrement the pc value when doing symbol lookups, (2) all registers can be retrieved (normally only callee-spilled aka non-volatile registers can be retrieved mid-stack), (3) we need to pick an asynchronous unwind plan because we may not be at a throwable / function call location like we normally are mid-stack.

[JosephTremoulet]

• Fix typos
• Convey 'S' eh_frame augmentation to UnwindPlan

[JosephTremoulet]

I've updated this with code to recognize the 'S' in the eh_frame augmentation and record it in a new bool member of UnwindPlan, m_plan_is_for_signal_trap. I haven't hooked up any consumers of the new bit; as you say, with the current code flow we don't parse the eh_frame info until after we've decided whether the current frame is a trap handler frame or not.

I took a look at behaves_like_zeroth_frame. In my case, we're not getting to the point of consulting it, because before checking it, if we are processing a trap handler frame or if AlwaysRelyOnEHInfo returns true (both of which are true in my case), we use the EH Frame unwind plan if it is valid at the current address, and that valid at current address check is already passing. I'm somewhat reluctant to fiddle with the behaves_like_zeroth_frame bit speculatively. Note that with this change, it will get set for the next frame above __kernel_rt_sigreturn (because the current test checks if the next-lower frame is an eTrapHandler frame), which I think is where we want the async processing.

I see that we also do this "subtract 1 from the pc" thing in StackFrame::GetSymbolContext, and I believe this is why even with my change here I'm seeing the wrong function name in backtraces (e.g., in the new test, it shows "abort_caller -> [function that happened to precede __kernel_rt_sigreturn] -> handler" rather than "abort_caller -> kernel_rt_sigreturn -> handler"). I'm not sure how best to address that, since the base StackFrame and RegisterContext classes don't have this notion of "frame type" / "trap handler frame" that the "-LLDB" subclasses have -- seems like we'd need to have GetFrameInfoAtIndex have another out parameter to specify frame type, and UnwindLLDB's implementation could then pull it from the RegisterContextLLDB -- would that be a good change? I don't actually need that for my current use case, the "wrong" name in the backtrace is fine...

Thanks for the notes on the asynchronous cases. I'd certainly be interested in getting those to work, though I haven't sorted out from where the unwinder can find the above-trap frame's register values (happy for pointers here!). I think I'm running into what this comment from GetFullUnwindPlanForFrame describes:

// 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.

I'd like to get the synchronous case support working as a first step regardless.

[JosephTremoulet]

• fix copy pasta

[jankratochvil]

Shouldn't you add also symbol __restore_rt (Fedora 30 x86_64)?

(gdb) bt
#0  handler (sig=6) at sigtest2.c:7
#1  <signal handler called>
#2  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
#3  0x00007ffff7dea895 in __GI_abort () at abort.c:79
#4  0x000000000040118e in abort_caller () at sigtest2.c:12
#5  0x00000000004011c2 in main () at sigtest2.c:23
(gdb) frame 1
#1  <signal handler called>
(gdb) disas
Dump of assembler code for function __restore_rt:
=> 0x00007ffff7dfff00 <+0>:	mov    $0xf,%rax
   0x00007ffff7dfff07 <+7>:	syscall 
   0x00007ffff7dfff09 <+9>:	nopl   0x0(%rax)
End of assembler dump.

[JosephTremoulet]

• Include __restore_rt

[JosephTremoulet]

In D63667#1561365, @jankratochvil wrote:

Shouldn't you add also symbol __restore_rt (Fedora 30 x86_64)?

Thanks, yes, looks like I should. Updated.

[jankratochvil]

When I compare the backtrace from GDB and LLDB (on x86_64, I haven't tried aarch64 as x86_64 is much faster=easier to handle):

    frame #2: 0x0000000000401195 sigtest2`handler(sig=6) at sigtest2.c:9:5
#2  0x0000000000401195 in handler (sig=6) at sigtest2.c:9

    frame #3: 0x00007f5fd888ef00 libc.so.6`.annobin_sigaction.c + 16
#3  <signal handler called> => 0x00007f5fd888ef00 <+0>: mov    $0xf,%rax

    frame #4: 0x00007f5fd888ee75 libc.so.6`__GI_raise at internal-signals.h:84:10
#4  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50 $1 = 0x7f5fd888ee75

    frame #5: 0x00007f5fd888ee5e libc.so.6`__GI_raise(sig=2) at raise.c:48
Missing in GDB

    frame #6: 0x00007f5fd8879895 libc.so.6`__GI_abort at abort.c:79:7
#5  0x00007f5fd8879895 in __GI_abort () at abort.c:79

That LLDB frame #5 is a bit bogus:

(lldb) down
frame #5: 0x00007f5fd888ee5e libc.so.6`__GI_raise(sig=2) at raise.c:48
   45  	
   46  	  int ret = INLINE_SYSCALL (tgkill, 3, pid, tid, sig);
   47  	
-> 48  	  __libc_signal_restore_set (&set);
   49  	
   50  	  return ret;
   51  	}
(lldb) disas
libc.so.6`__GI_raise:
...
    0x7f5fd888ee5b <+299>: movl   %eax, %r8d
    0x7f5fd888ee5e <+302>: movl   $0x8, %r10d
    0x7f5fd888ee64 <+308>: xorl   %edx, %edx
    0x7f5fd888ee66 <+310>: movq   %r9, %rsi
    0x7f5fd888ee69 <+313>: movl   $0x2, %edi
    0x7f5fd888ee6e <+318>: movl   $0xe, %eax
    0x7f5fd888ee73 <+323>: syscall 
->  0x7f5fd888ee75 <+325>: movq   0x108(%rsp), %rax
    0x7f5fd888ee7d <+333>: xorq   %fs:0x28, %rax

That 0x00007f5fd888ee5e is not even shown by disas, also it is no point of a return from any call.

[JosephTremoulet]

That LLDB frame #5 is a bit bogus

Thanks for taking a look at this. I'm trying to reproduce what you're seeing and failing. This is what I see, in a fedora:latest docker container on an Ubuntu host on an x86_64 machine, with my patch applied to lldb:

$ gcc -g -O0 -o sigtest main.c
$ lldb ./sigtest
(lldb) target create "./sigtest"
Current executable set to './sigtest' (x86_64).
(lldb) breakpoint set -f main.c -l 6
Breakpoint 1: where = sigtest`handler + 11 at main.c:7:5, address = 0x0000000000401171
(lldb) run
Process 149148 launched: '/home/josepht/scratch/sigtest' (x86_64)
Process 149148 stopped
* thread #1, name = 'sigtest', stop reason = signal SIGABRT
    frame #0: 0x00007ffff7e38e75 libc.so.6`__GI_raise + 325
libc.so.6`__GI_raise:
->  0x7ffff7e38e75 <+325>: movq   0x108(%rsp), %rax
    0x7ffff7e38e7d <+333>: xorq   %fs:0x28, %rax
    0x7ffff7e38e86 <+342>: jne    0x7ffff7e38eac            ; <+380>
    0x7ffff7e38e88 <+344>: movl   %r8d, %eax
(lldb) continue
Process 149148 resuming
Process 149148 stopped
* thread #1, name = 'sigtest', stop reason = breakpoint 1.1
    frame #0: 0x0000000000401171 sigtest`handler(sig=6) at main.c:7:5
   4   
   5    void handler(int sig)
   6    {
-> 7        printf("Set a breakpoint here.\n");
   8        exit(0);
   9    }
   10  
(lldb) bt
* thread #1, name = 'sigtest', stop reason = breakpoint 1.1
  * frame #0: 0x0000000000401171 sigtest`handler(sig=6) at main.c:7:5
    frame #1: 0x00007ffff7e38f00 libc.so.6`.annobin_sigaction.c + 16
    frame #2: 0x00007ffff7e38e75 libc.so.6`__GI_raise + 325
    frame #3: 0x00007ffff7e23895 libc.so.6`__GI_abort + 295
    frame #4: 0x000000000040118e sigtest`abort_caller at main.c:12:5
    frame #5: 0x00000000004011c2 sigtest`main at main.c:23:5
    frame #6: 0x00007ffff7e24f33 libc.so.6`__libc_start_main + 243
    frame #7: 0x00000000004010ae sigtest`_start + 46
(lldb) frame select 2
frame #2: 0x00007ffff7e38e75 libc.so.6`__GI_raise + 325
libc.so.6`__GI_raise:
->  0x7ffff7e38e75 <+325>: movq   0x108(%rsp), %rax
    0x7ffff7e38e7d <+333>: xorq   %fs:0x28, %rax
    0x7ffff7e38e86 <+342>: jne    0x7ffff7e38eac            ; <+380>
    0x7ffff7e38e88 <+344>: movl   %r8d, %eax
(lldb) frame select 3
frame #3: 0x00007ffff7e23895 libc.so.6`__GI_abort + 295
libc.so.6`__GI_abort:
->  0x7ffff7e23895 <+295>: movq   %fs:0x10, %rdx
    0x7ffff7e2389e <+304>: cmpq   %rdx, 0x19f493(%rip)      ; lock + 8
    0x7ffff7e238a5 <+311>: je     0x7ffff7e238ed            ; <+383>
    0x7ffff7e238a7 <+313>: movl   $0x1, %esi

My frame 2 seems to correspond to your frame 4, and then my frame 3 seems to correspond to your frame 6, without the bogus frame in between. Do I have the wrong repro steps or something?

Thanks,
-Joseph

[JosephTremoulet]

ping @jasonmolenda -- do the updates look like what you had in mind when you said " It'd be a good change to capture that information from the eh_frame though, even if we don't see a clear way to use it right now"?

Also /cc @clayborg (thanks for the reply on the Dev alias!). I think your suggestion to communicate the info to a new behaves_like_zero flag on lldb_private::StackFrame (presumably communicated via GetFrameInfoAtIndex) would help for then fixing StackFrame::GetSymbolContext to find the right symbol for these frames. I'm inclined to think that would make the most sense as a follow-up change, but lmk if you have thoughts.

I'm also curious what else needs to happen to be ready to merge this. I've tested on Ubuntu and Darwin and now Fedora, but not sure what other platforms might have similar holes that this test would then immediately fail on. If I add the changes to connect the 'S' in the augmentation all the way to StackFrame::GetSymbolContext, then at least I could make sure the test log in the error case would include the name of the function missing from the trap handler symbol list, but I don't know if that's sufficiently motivating to roll that into this PR or if it's preferable to keep it small... happy for feedback.

[jasonmolenda]

In D63667#1558027, @JosephTremoulet wrote:

I've updated this with code to recognize the 'S' in the eh_frame augmentation and record it in a new bool member of UnwindPlan, m_plan_is_for_signal_trap. I haven't hooked up any consumers of the new bit; as you say, with the current code flow we don't parse the eh_frame info until after we've decided whether the current frame is a trap handler frame or not.

I took a look at behaves_like_zeroth_frame. In my case, we're not getting to the point of consulting it, because before checking it, if we are processing a trap handler frame or if AlwaysRelyOnEHInfo returns true (both of which are true in my case), we use the EH Frame unwind plan if it is valid at the current address, and that valid at current address check is already passing. I'm somewhat reluctant to fiddle with the behaves_like_zeroth_frame bit speculatively. Note that with this change, it will get set for the next frame above __kernel_rt_sigreturn (because the current test checks if the next-lower frame is an eTrapHandler frame), which I think is where we want the async processing.

Just just to check, we've got a backtrace like

#0 trap_handler_function_in_my_program
#1 __kernel_rt_sigreturn
#2 function_that_was_interrupted_asynchonrously
#3 main

The eh_frame for #1 has the S bit, and we've hard-coded the name of the function as a known asynchronous signal handler. When we're choosing an unwind plan for frame #2, or symbolicating the address, we need to treat this as a "behaves like zeroth frame" function - it could be on the first instruction, so backing the pc up by one would put us in the wrong function scope.

I see that we also do this "subtract 1 from the pc" thing in StackFrame::GetSymbolContext, and I believe this is why even with my change here I'm seeing the wrong function name in backtraces (e.g., in the new test, it shows "abort_caller -> [function that happened to precede __kernel_rt_sigreturn] -> handler" rather than "abort_caller -> kernel_rt_sigreturn -> handler"). I'm not sure how best to address that, since the base StackFrame and RegisterContext classes don't have this notion of "frame type" / "trap handler frame" that the "-LLDB" subclasses have -- seems like we'd need to have GetFrameInfoAtIndex have another out parameter to specify frame type, and UnwindLLDB's implementation could then pull it from the RegisterContextLLDB -- would that be a good change? I don't actually need that for my current use case, the "wrong" name in the backtrace is fine...

I think Unwind::GetFrameInfoAtIndex can take a new output argument, bool behaves_like_zeroth_frame. It would be set to true if idx == 0 or if m_frames[idx - 1].IsTrapHandlerFrame() is true.

StackFrame.h would pick up a new ivar m_behaves_like_zeroth_frame and accessor method BehavesLikeZerothFrame().

StackFrameList::GetFramesUpTo will fetch the value via unwinder->GetFrameInfoAtIndex() and pass it as an argument to the StackFrame::StackFrame ctor.

Then in StackFrame::GetSymbolContext we can use the m_behaves_like_zeroth_frame to fix the symbol lookup logic.

I'm not wedded to the behaves_like_zeroth_frame nomenclature. But I think this approach makes sense.

Thanks for the notes on the asynchronous cases. I'd certainly be interested in getting those to work, though I haven't sorted out from where the unwinder can find the above-trap frame's register values (happy for pointers here!). I think I'm running into what this comment from GetFullUnwindPlanForFrame describes:

// 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.

I'd like to get the synchronous case support working as a first step regardless.

[jasonmolenda]

Ah, regarding the S bit, looks good to me. I think I misunderstood the original problem you were working on. On Darwin systems, we have our friend sigtramp. When an async interrupt is received, the kernel saves the register context to stack and then calls sigtramp which does some instructions and then calls the trap handler function. Backing up the pc by 1 for __sigtramp is fine, because it did a normal CALL instruction to the trap handler.

I'm guessing on this Linux system, you've got a trap receiver function on the stack that is on its first instruction or something? So backing up the pc value for *that* frame is the problem you're solving.

Then there's the issue of backing up the pc by 1 for the frame that was asynchronously interrupted - a separate issue altogether.

Anyway this looks fine to me.

[JosephTremoulet]

I'm guessing on this Linux system, you've got a trap receiver function on the stack that is on its first instruction or something? So backing up the pc value for *that* frame is the problem you're solving.
...
Just just to check, we've got a backtrace like...

Yes, it's just like you describe.

I think Unwind::GetFrameInfoAtIndex can take a new output argument, bool behaves_like_zeroth_frame. It would be set to true if idx == 0 or if m_frames[idx - 1].IsTrapHandlerFrame() is true.
StackFrame.h would pick up a new ivar m_behaves_like_zeroth_frame and accessor method BehavesLikeZerothFrame().
StackFrameList::GetFramesUpTo will fetch the value via unwinder->GetFrameInfoAtIndex() and pass it as an argument to the StackFrame::StackFrame ctor.
Then in StackFrame::GetSymbolContext we can use the m_behaves_like_zeroth_frame to fix the symbol lookup logic.
I'm not wedded to the behaves_like_zeroth_frame nomenclature. But I think this approach makes sense.

Makes sense to me too, thanks for the pointers. I think I'll upload that as a separate patch to keep the reviews incremental, but maybe commit them back-to-back since the second would improve any diagnostics if the first fails on other platforms.

Anyway this looks fine to me.

Is that a green light to commit the change (modulo figuring out the issue that Jan reported which I'm not able to reproduce), or does that mean LGTY but I should get sign-off from someone else as well? (Sorry if I'm being dense, just haven't committed changes to lldb before and want to make sure I understand the workflow, and noticed you didn't mark the Phab review as "accepted", wondering if that's significant)

Thanks!

[jasonmolenda]

Sorry yes, I should have marked this as approved. I don't have a linux machine handy so I haven't looked into the problem Jan reports with the change -- fwiw if you turn on unwind logging ('log enable lldb unwind' before you backtrace at a stop), it will tell you which unwind rule it is using to find the caller's return pc value as it goes up the stack. It's a little tricky to read at first, but once you get the hang of it you can usually spot the problem quickly and understand why lldb is behaving the way it is. But just looking at the source changes you're making, I'm fine with this.

[jankratochvil]

In D63667#1586427, @JosephTremoulet wrote:

without the bogus frame in between. Do I have the wrong repro steps or something?

You did not have DWARF for glibc installed: dnf debuginfo-install glibc

Then in fact your test was better as only real frames matter for this patch. There is some LLDB bug/incompatibility decoding inline function from (GCC-produced) DWARF but that is unrelated to this patch.

[JosephTremoulet]

In D63667#1594718, @jankratochvil wrote:

You did not have DWARF for glibc installed: dnf debuginfo-install glibc

Then in fact your test was better as only real frames matter for this patch. There is some LLDB bug/incompatibility decoding inline function from (GCC-produced) DWARF but that is unrelated to this patch.

Ah, that makes sense. Thanks for following up.

lldb/trunk/include/lldb/Symbol/UnwindPlan.h

 public:
   typedef std::shared_ptr<Row> RowSP;
 
   UnwindPlan(lldb::RegisterKind reg_kind)
       : m_row_list(), m_plan_valid_address_range(), m_register_kind(reg_kind),
         m_return_addr_register(LLDB_INVALID_REGNUM), m_source_name(),
         m_plan_is_sourced_from_compiler(eLazyBoolCalculate),
         m_plan_is_valid_at_all_instruction_locations(eLazyBoolCalculate),
+        m_plan_is_for_signal_trap(eLazyBoolCalculate),
         m_lsda_address(), m_personality_func_addr() {}
 
   // Performs a deep copy of the plan, including all the rows (expensive).
   UnwindPlan(const UnwindPlan &rhs)
       : m_plan_valid_address_range(rhs.m_plan_valid_address_range),
         m_register_kind(rhs.m_register_kind),
         m_return_addr_register(rhs.m_return_addr_register),
         m_source_name(rhs.m_source_name),
public:
 
   // Is this UnwindPlan valid at all instructions?  If not, then it is assumed
   // valid at call sites, e.g. for exception handling.
   void SetUnwindPlanValidAtAllInstructions(
       lldb_private::LazyBool valid_at_all_insn) {
     m_plan_is_valid_at_all_instruction_locations = valid_at_all_insn;
   }
 
+  // Is this UnwindPlan for a signal trap frame?  If so, then its saved pc
+  // may have been set manually by the signal dispatch code and therefore
+  // not follow a call to the child frame.
+  lldb_private::LazyBool GetUnwindPlanForSignalTrap() const {
+    return m_plan_is_for_signal_trap;
+  }
+
+  void SetUnwindPlanForSignalTrap(lldb_private::LazyBool is_for_signal_trap) {
+    m_plan_is_for_signal_trap = is_for_signal_trap;
+  }
+
   int GetRowCount() const;
 
   void Clear() {
     m_row_list.clear();
     m_plan_valid_address_range.Clear();
     m_register_kind = lldb::eRegisterKindDWARF;
     m_source_name.Clear();
     m_plan_is_sourced_from_compiler = eLazyBoolCalculate;
     m_plan_is_valid_at_all_instruction_locations = eLazyBoolCalculate;
+    m_plan_is_for_signal_trap = eLazyBoolCalculate;
     m_lsda_address.Clear();
     m_personality_func_addr.Clear();
   }
 
   const RegisterInfo *GetRegisterInfo(Thread *thread, uint32_t reg_num) const;
 
   Address GetLSDAAddress() const { return m_lsda_address; }
 
private:
   // translated to lldb native reg nums at unwind time
   uint32_t m_return_addr_register; // The register that has the return address
                                    // for the caller frame
                                    // e.g. the lr on arm
   lldb_private::ConstString
       m_source_name; // for logging, where this UnwindPlan originated from
   lldb_private::LazyBool m_plan_is_sourced_from_compiler;
   lldb_private::LazyBool m_plan_is_valid_at_all_instruction_locations;
+  lldb_private::LazyBool m_plan_is_for_signal_trap;
 
   Address m_lsda_address; // Where the language specific data area exists in the
                           // module - used
                           // in exception handling.
   Address m_personality_func_addr; // The address of a pointer to the
                                    // personality function - used in
                                    // exception handling.
 };                                 // class UnwindPlan
 
 } // namespace lldb_private
 
 #endif // liblldb_UnwindPlan_h

lldb/trunk/packages/Python/lldbsuite/test/functionalities/signal/handle-abrt/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/functionalities/signal/handle-abrt/TestHandleAbort.py

+"""Test that we can unwind out of a SIGABRT handler"""
+
+from __future__ import print_function
+
+
+import os
+import re
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class HandleAbortTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipIfWindows  # signals do not exist on Windows
+    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")
+
+        # 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")
+
+        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")
+
+        # Continue to breakpoint in abort 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
+
+        self.assertTrue(foundFoo, "Unwinding did not find func that called abort")
+
+        # Continue until we exit.
+        process.Continue()
+        self.assertEqual(process.GetState(), lldb.eStateExited)
+        self.assertEqual(process.GetExitStatus(), 0)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/signal/handle-abrt/main.c

+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void handler(int sig)
+{
+    printf("Set a breakpoint here.\n");
+    exit(0);
+}
+
+void abort_caller() {
+    abort();
+}
+
+int main()
+{
+    if (signal(SIGABRT, handler) == SIG_ERR)
+    {
+        perror("signal");
+        return 1;
+    }
+
+    abort_caller();
+    return 2;
+}

lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

bool ABIMacOSX_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm-apple-ios default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
 
   return true;
 }
 
 // cf. "ARMv6 Function Calling Conventions"
 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
 // and "ARMv7 Function Calling Conventions"
 // https://developer.apple.com/library/ios/documentation/Xcode/Conceptual/iPhoneOSABIReference/Articles/ARMv7FunctionCallingConventions.html

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

bool ABIMacOSX_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm64-apple-darwin default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 // AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
 // registers x19 through x28 and sp are callee preserved. v8-v15 are non-
 // volatile (and specifically only the lower 8 bytes of these regs), the rest
 // of the fp/SIMD registers are volatile.
 

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

bool ABIMacOSX_i386::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("i386 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 bool ABIMacOSX_i386::RegisterIsVolatile(const RegisterInfo *reg_info) {
   return !RegisterIsCalleeSaved(reg_info);
 }
 
 // v.

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

bool ABISysV_arm::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
 
   return true;
 }
 
 // cf. "ARMv6 Function Calling Conventions"
 
 // ARMv7 on GNU/Linux general purpose reg rules:
 //    r0-r3 not preserved  (used for argument passing)

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

bool ABISysV_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.AppendRow(row);
   unwind_plan.SetReturnAddressRegister(lr_reg_num);
 
   // All other registers are the same.
 
   unwind_plan.SetSourceName("arm64 at-func-entry default");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
 
   return true;
 }
 
 bool ABISysV_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   unwind_plan.Clear();
   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
 
   uint32_t fp_reg_num = arm64_dwarf::fp;
   uint32_t pc_reg_num = arm64_dwarf::pc;
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
   const int32_t ptr_size = 8;
 
   row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
   row->SetOffset(0);
 
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("arm64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
 
   return true;
 }
 
 // AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
 // registers x19 through x28 and sp are callee preserved. v8-v15 are non-
 // volatile (and specifically only the lower 8 bytes of these regs), the rest
 // of the fp/SIMD registers are volatile.

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

bool ABISysV_hexagon::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, -8, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -4, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("hexagon default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 /*
     Register    Usage         Saved By
 
     R0  - R5    parameters(a)     -
     R6  - R15   Scratch(b)        Caller

lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

bool ABISysV_i386::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("i386 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 // According to "Register Usage" in reference document (specified on top of
 // this source file) ebx, ebp, esi, edi and esp registers are preserved i.e.
 // non-volatile i.e. callee-saved on i386
 bool ABISysV_i386::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
   if (!reg_info)

lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

bool ABISysV_mips::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
 
   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("mips default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 bool ABISysV_mips::RegisterIsVolatile(const RegisterInfo *reg_info) {
   return !RegisterIsCalleeSaved(reg_info);
 }
 
 bool ABISysV_mips::IsSoftFloat(uint32_t fp_flags) const {

lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

bool ABISysV_mips64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
 
   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("mips64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 bool ABISysV_mips64::RegisterIsVolatile(const RegisterInfo *reg_info) {
   return !RegisterIsCalleeSaved(reg_info);
 }
 
 bool ABISysV_mips64::IsSoftFloat(uint32_t fp_flag) const {

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

bool ABISysV_ppc::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
 
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("ppc default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(dwarf_lr);
   return true;
 }
 
 bool ABISysV_ppc::RegisterIsVolatile(const RegisterInfo *reg_info) {
   return !RegisterIsCalleeSaved(reg_info);
 }
 

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

bool ABISysV_ppc64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
   row->SetRegisterLocationToAtCFAPlusOffset(cr_reg_num, ptr_size, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("ppc64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(pc_reg_num);
   return true;
 }
 
 bool ABISysV_ppc64::RegisterIsVolatile(const RegisterInfo *reg_info) {
   return !RegisterIsCalleeSaved(reg_info);
 }
 

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

bool ABISysV_x86_64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
   row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
   row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
   row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("x86_64 default unwind plan");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   return true;
 }
 
 bool ABISysV_x86_64::RegisterIsVolatile(const RegisterInfo *reg_info) {
   return !RegisterIsCalleeSaved(reg_info);
 }
 
 // See "Register Usage" in the

lldb/trunk/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

bool EmulateInstructionARM::CreateFunctionEntryUnwind(UnwindPlan &unwind_plan) {
 
   // Our previous Call Frame Address is the stack pointer
   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_sp, 0);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("EmulateInstructionARM");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(dwarf_lr);
   return true;
 }

lldb/trunk/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

bool EmulateInstructionARM64::CreateFunctionEntryUnwind(
 
   // Our previous Call Frame Address is the stack pointer
   row->GetCFAValue().SetIsRegisterPlusOffset(gpr_sp_arm64, 0);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("EmulateInstructionARM64");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(gpr_lr_arm64);
   return true;
 }
 
 uint32_t EmulateInstructionARM64::GetFramePointerRegisterNumber() const {
   if (m_arch.GetTriple().isAndroid())
     return LLDB_INVALID_REGNUM; // Don't use frame pointer on android
 

lldb/trunk/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

bool EmulateInstructionMIPS::CreateFunctionEntryUnwind(
   row->SetRegisterLocationToRegister(dwarf_pc_mips, dwarf_ra_mips, can_replace);
 
   unwind_plan.AppendRow(row);
 
   // All other registers are the same.
   unwind_plan.SetSourceName("EmulateInstructionMIPS");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(dwarf_ra_mips);
 
   return true;
 }
 
 bool EmulateInstructionMIPS::nonvolatile_reg_p(uint32_t regnum) {
   switch (regnum) {
   case dwarf_r16_mips:

lldb/trunk/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

row->SetRegisterLocationToRegister(dwarf_pc_mips64, dwarf_ra_mips64,
                                      can_replace);
 
   unwind_plan.AppendRow(row);
 
   // All other registers are the same.
   unwind_plan.SetSourceName("EmulateInstructionMIPS64");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(dwarf_ra_mips64);
 
   return true;
 }
 
 bool EmulateInstructionMIPS64::nonvolatile_reg_p(uint64_t regnum) {
   switch (regnum) {
   case dwarf_r16_mips64:

lldb/trunk/source/Plugins/Instruction/PPC64/EmulateInstructionPPC64.cpp

bool EmulateInstructionPPC64::CreateFunctionEntryUnwind(
 
   // Our previous Call Frame Address is the stack pointer
   row->GetCFAValue().SetIsRegisterPlusOffset(gpr_r1_ppc64le, 0);
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("EmulateInstructionPPC64");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetReturnAddressRegister(gpr_lr_ppc64le);
   return true;
 }
 
 EmulateInstructionPPC64::Opcode *
 EmulateInstructionPPC64::GetOpcodeForInstruction(uint32_t opcode) {
   static EmulateInstructionPPC64::Opcode g_opcodes[] = {
       {0xfc0007ff, 0x7c0002a6, &EmulateInstructionPPC64::EmulateMFSPR,

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

if (error.Success()) {
     // we delete the process?  Does our caller do that?
   }
 
   return process_sp;
 }
 
 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"));
 }
 
 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;

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

UnwindLogMsg("with pc value of 0x%" PRIx64
                  pc);
   }
 
   AddressRange addr_range;
   if (!m_sym_ctx.GetAddressRange(resolve_scope, 0, false, addr_range)) {
     m_sym_ctx_valid = false;
   }
 
-  bool decr_pc_and_recompute_addr_range = false;
+  bool decr_pc_and_recompute_addr_range;
 
-  // If the symbol lookup failed...
-  if (!m_sym_ctx_valid)
+  if (!m_sym_ctx_valid) {
+    // Always decrement and recompute if the symbol lookup failed
     decr_pc_and_recompute_addr_range = true;
-
-  // Or if we're in the middle of the stack (and not "above" an asynchronous
-  // event like sigtramp), and our "current" pc is the start of a function...
-  if (GetNextFrame()->m_frame_type != eTrapHandlerFrame &&
-      GetNextFrame()->m_frame_type != eDebuggerFrame &&
-      (!m_sym_ctx_valid ||
-       (addr_range.GetBaseAddress().IsValid() &&
-        addr_range.GetBaseAddress().GetSection() == m_current_pc.GetSection() &&
-        addr_range.GetBaseAddress().GetOffset() == m_current_pc.GetOffset()))) {
+  } else if (GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
+             GetNextFrame()->m_frame_type == eDebuggerFrame) {
+    // Don't decrement if we're "above" an asynchronous event like
+    // sigtramp.
+    decr_pc_and_recompute_addr_range = false;
+  } else if (!addr_range.GetBaseAddress().IsValid() ||
+             addr_range.GetBaseAddress().GetSection() != m_current_pc.GetSection() ||
+             addr_range.GetBaseAddress().GetOffset() != m_current_pc.GetOffset()) {
+    // If our "current" pc isn't the start of a function, no need
+    // to decrement and recompute.
+    decr_pc_and_recompute_addr_range = false;
+  } else if (IsTrapHandlerSymbol(process, m_sym_ctx)) {
+    // Signal dispatch may set the return address of the handler it calls to
+    // point to the first byte of a return trampoline (like __kernel_rt_sigreturn),
+    // so do not decrement and recompute if the symbol we already found is a trap
+    // handler.
+    decr_pc_and_recompute_addr_range = false;
+  } else {
+    // Decrement to find the function containing the call.
     decr_pc_and_recompute_addr_range = true;
   }
 
   // We need to back up the pc by 1 byte and re-search for the Symbol to handle
   // the case where the "saved pc" value is pointing to the next function, e.g.
   // if a function ends with a CALL instruction.
   // FIXME this may need to be an architectural-dependent behavior; if so we'll
   // need to add a member function

lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

SymbolFileBreakpad::GetUnwindPlan(const Address &address,
   LineIterator It(*m_obj_file, Record::StackCFI, entry->data), End(*m_obj_file);
   llvm::Optional<StackCFIRecord> init_record = StackCFIRecord::parse(*It);
   assert(init_record.hasValue());
   assert(init_record->Size.hasValue());
 
   auto plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindLLDB);
   plan_sp->SetSourceName("breakpad STACK CFI");
   plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
   plan_sp->SetSourcedFromCompiler(eLazyBoolYes);
   plan_sp->SetPlanValidAddressRange(
       AddressRange(base + init_record->Address, *init_record->Size,
                    m_obj_file->GetModule()->GetSectionList()));
 
   auto row_sp = std::make_shared<UnwindPlan::Row>();
   row_sp->SetOffset(0);
   if (!ParseUnwindRow(init_record->UnwindRules, resolver, *row_sp))

lldb/trunk/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

while (current_func_text_offset < size) {
 
     m_cur_insn = m_cur_insn + insn_len;
     current_func_text_offset += insn_len;
   }
 
   unwind_plan.SetSourceName("assembly insn profiling");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolYes);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
 
   return true;
 }
 
 bool x86AssemblyInspectionEngine::AugmentUnwindPlanFromCallSite(
     uint8_t *data, size_t size, AddressRange &func_range,
     UnwindPlan &unwind_plan, RegisterContextSP &reg_ctx) {
   Address addr_start = func_range.GetBaseAddress();

lldb/trunk/source/Symbol/ArmUnwindInfo.cpp

if (!have_location_for_pc) {
     else
       row->SetRegisterLocationToRegister(dwarf_pc, dwarf_lr, false);
   }
 
   unwind_plan.AppendRow(row);
   unwind_plan.SetSourceName("ARM.exidx unwind info");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
 
   return true;
 }
 
 const uint8_t *
 ArmUnwindInfo::GetExceptionHandlingTableEntry(const Address &addr) {
   auto it = std::upper_bound(m_exidx_entries.begin(), m_exidx_entries.end(),

lldb/trunk/source/Symbol/CompactUnwindInfo.cpp

 
 bool CompactUnwindInfo::CreateUnwindPlan_x86_64(Target &target,
                                                 FunctionInfo &function_info,
                                                 UnwindPlan &unwind_plan,
                                                 Address pc_or_function_start) {
   unwind_plan.SetSourceName("compact unwind info");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
 
   unwind_plan.SetLSDAAddress(function_info.lsda_address);
   unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int wordsize = 8;

 
 bool CompactUnwindInfo::CreateUnwindPlan_i386(Target &target,
                                               FunctionInfo &function_info,
                                               UnwindPlan &unwind_plan,
                                               Address pc_or_function_start) {
   unwind_plan.SetSourceName("compact unwind info");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
 
   unwind_plan.SetLSDAAddress(function_info.lsda_address);
   unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int wordsize = 4;

 
 bool CompactUnwindInfo::CreateUnwindPlan_arm64(Target &target,
                                                FunctionInfo &function_info,
                                                UnwindPlan &unwind_plan,
                                                Address pc_or_function_start) {
   unwind_plan.SetSourceName("compact unwind info");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
 
   unwind_plan.SetLSDAAddress(function_info.lsda_address);
   unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int wordsize = 8;

 
 bool CompactUnwindInfo::CreateUnwindPlan_armv7(Target &target,
                                                FunctionInfo &function_info,
                                                UnwindPlan &unwind_plan,
                                                Address pc_or_function_start) {
   unwind_plan.SetSourceName("compact unwind info");
   unwind_plan.SetSourcedFromCompiler(eLazyBoolYes);
   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
   unwind_plan.SetRegisterKind(eRegisterKindEHFrame);
 
   unwind_plan.SetLSDAAddress(function_info.lsda_address);
   unwind_plan.SetPersonalityFunctionPtr(function_info.personality_ptr_address);
 
   UnwindPlan::RowSP row(new UnwindPlan::Row);
 
   const int wordsize = 4;

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 #include <list>
+#include <cstring>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // GetDwarfEHPtr
 //
 // Used for calls when the value type is specified by a DWARF EH Frame pointer
 // encoding.
if (aug_data_len != 0 && cie->lsda_addr_encoding != DW_EH_PE_omit) {
         // There is more in the augmentation region than we know how to process;
         // don't read anything.
         lsda_data_file_address = LLDB_INVALID_ADDRESS;
       }
       offset = saved_offset;
     }
     offset += aug_data_len;
   }
+  unwind_plan.SetUnwindPlanForSignalTrap(
+    strchr(cie->augmentation, 'S') ? eLazyBoolYes : eLazyBoolNo);
+
   Address lsda_data;
   Address personality_function_ptr;
 
   if (lsda_data_file_address != LLDB_INVALID_ADDRESS &&
       cie->personality_loc != LLDB_INVALID_ADDRESS) {
     m_objfile.GetModule()->ResolveFileAddress(lsda_data_file_address,
                                               lsda_data);
     m_objfile.GetModule()->ResolveFileAddress(cie->personality_loc,