Ugh - for x86_64, the signal trampoline has DWARF unwind info

Author: peadar

dwarfproc.cc

@@ -43,19 +43,26 @@ StackFrame::scopeIP(Process &proc) const
     // the process's register state - this is the currently executing
     // instruction, so accurately reflects the position in the top stack frame.
     //
-    // The other is for signal trampolines - In this case, the return address
+    // Next, signal trampolines - For the trampoline itself, the return address
     // has been synthesized to be the entrypoint of a function (eg,
     // __restore_rt) to handle return from the signal handler, and will be the
     // first instruction in the function - there's no previous call instruction
     // to point at, so we use it directly.
+    //
+    // Finally, for the function that was running when the signal was invoked -
+    // The signal was invoked asynchronously, so again, we have no call
+    // instruction to walk back into.
     auto raw = rawIP();
     if (raw == 0)
        return { proc, raw };
     if (mechanism == UnwindMechanism::MACHINEREGS
           || mechanism == UnwindMechanism::TRAMPOLINE)
        return { proc, raw };
+
     if (isSignalTrampoline)
        return { proc, raw };
+    if (unwoundFromTrampoline)
+       return { proc, raw };
     ProcessLocation location(proc, raw);
 
     const auto *lcie = location.cie();
@@ -498,7 +505,9 @@ StackFrame::StackFrame(UnwindMechanism mechanism, const Elf::CoreRegisters &regs
     , cfa(0)
     , mechanism(mechanism)
     , isSignalTrampoline(false)
-{}
+    , unwoundFromTrampoline(false)
+{
+}
 
 std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
     ProcessLocation location = scopeIP(p);
@@ -518,8 +527,6 @@ std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
 
     using namespace Dwarf;
 
-
-
     DWARFReader r(cfi->io, fde->instructions, fde->end);
 
     auto iter = location.dwarf()->callFrameForAddr.find(objaddr);

libpstack/proc.h

@@ -132,12 +132,20 @@ class ProcessLocation {
 
 class StackFrame {
 public:
-    Elf::Addr rawIP() const;
+    [[nodiscard]] Elf::Addr rawIP() const;
     ProcessLocation scopeIP(Process &) const;
     Elf::CoreRegisters regs;
     Elf::Addr cfa;
     UnwindMechanism mechanism;
+
+    // This frame is a signal trampoline, eg, at a function like
+    // __kernel_rt_sigreturn
     bool isSignalTrampoline;
+
+    // This frame was unwound from a signal trampoline - implying didn't call
+    // the function above it on the stack.
+    bool unwoundFromTrampoline;
+
     StackFrame(UnwindMechanism mechanism, const Elf::CoreRegisters &regs);
     StackFrame &operator = (const StackFrame &) = default;
     StackFrame(const StackFrame &) = default;

process.cc

@@ -988,6 +988,9 @@ ThreadStack::unwind(Process &p, Elf::CoreRegisters &regs)
                     break;
                 auto &newRegs = *maybeNewRegs;
                 stack.emplace_back(UnwindMechanism::DWARF, newRegs);
+                if (prev.isSignalTrampoline) {
+                   stack.back().unwoundFromTrampoline = true;
+                }
 #ifdef __aarch64__
                 auto &cur = stack.back();
                 if (newRegs.pc == trampoline)
@@ -1023,7 +1026,8 @@ ThreadStack::unwind(Process &p, Elf::CoreRegisters &regs)
                 // register rather than a pushd return address
 
                 if (prev.mechanism == UnwindMechanism::MACHINEREGS
-                      || prev.mechanism == UnwindMechanism::TRAMPOLINE) {
+                      || prev.mechanism == UnwindMechanism::TRAMPOLINE
+                      || prev.unwoundFromTrampoline ) {
                     ProcessLocation badip = { p, IP(prev.regs) };
                     if (!badip.inObject() || (badip.codeloc->phdr().p_flags & PF_X) == 0) {
                         auto newRegs = prev.regs; // start with a copy of prev frames regs.