Report inferior SIGSEGV as a signal instead of an exception on linux

[labath]

Summary

Previously, we reported inferior receiving SIGSEGV (or SIGILL, SIGFPE, SIGBUS) as an "exception"
to LLDB, presumably to match OSX behaviour. Beside the fact that we were basically lying to the
user, this was also causing problems with inferiors which handle SIGSEGV by themselves, since
LLDB was unable to reinject this signal back into the inferior.

This commit changes LLGS to report SIGSEGV as a signal. This has necessitated some changes in the
test-suite, which had previously used eStopReasonException to locate threads that crashed. Now it
uses platform-specific logic, which in the case of linux searches for eStopReasonSignaled with
signal=SIGSEGV.

I have also added the ability to set the description of StopInfoUnixSignal using the description
field of the gdb-remote packet. The linux stub uses this to display additional information about
the segfault (invalid address, address access protected, etc.).

[labath]

test/functionalities/signal/handle-segv/TestHandleSegv.py

16 ↗

(On Diff #26583)

This test fails on osx, but I think that's expected as segfaults are treated differently there. I have skipped it on darwin.

I am not sure about freebsd. I expect the test will fail, but I don't know if that is supposed to happen or not. I expect segv and mmap should behave the same way as on linux, in which case this should be XFAILed.

[clayborg]

Looks good.

[ovyalov]

LGTM

test/functionalities/inferior-crashing/TestInferiorCrashing.py

146 ↗

(On Diff #26583)

Please consider using assertEqual instead of if->fail

test/functionalities/signal/handle-segv/main.c

27 ↗

(On Diff #26583)

Please add constant for 47.

lldb/trunk/include/lldb/Target/StopInfo.h

public:
     // This creates a StopInfo for the thread where the should_stop is already set, and won't be recalculated.
     static lldb::StopInfoSP
     CreateStopReasonWithBreakpointSiteID (Thread &thread, lldb::break_id_t break_id, bool should_stop);
 
     static lldb::StopInfoSP
     CreateStopReasonWithWatchpointID (Thread &thread, lldb::break_id_t watch_id);
 
     static lldb::StopInfoSP
-    CreateStopReasonWithSignal (Thread &thread, int signo);
+    CreateStopReasonWithSignal (Thread &thread, int signo, const char *description = nullptr);
 
     static lldb::StopInfoSP
     CreateStopReasonToTrace (Thread &thread);
 
     static lldb::StopInfoSP
     CreateStopReasonWithPlan (lldb::ThreadPlanSP &plan,
                               lldb::ValueObjectSP return_valobj_sp,
                               lldb::ClangExpressionVariableSP expression_variable_sp);

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
                 // An inferior thread has stopped because of a SIGSTOP we have sent it.
                 // Generally, these are not important stops and we don't want to report them as
                 // they are just used to stop other threads when one thread (the one with the
                 // *real* stop reason) hits a breakpoint (watchpoint, etc...). However, in the
                 // case of an asynchronous Interrupt(), this *is* the real stop reason, so we
                 // leave the signal intact if this is the thread that was chosen as the
                 // triggering thread.
                 if (m_pending_notification_up && m_pending_notification_up->triggering_tid == pid)
-                    linux_thread_sp->SetStoppedBySignal(SIGSTOP);
+                    linux_thread_sp->SetStoppedBySignal(SIGSTOP, info);
                 else
                     linux_thread_sp->SetStoppedBySignal(0);
 
                 SetCurrentThreadID (thread_sp->GetID ());
                 ThreadDidStop (thread_sp->GetID (), true);
             }
             else
             {
NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, GetUnixSignals ().GetSignalAsCString (signo));
 
     // This thread is stopped.
     ThreadDidStop (pid, false);
 
-    switch (signo)
-    {
-    case SIGSEGV:
-    case SIGILL:
-    case SIGFPE:
-    case SIGBUS:
-        if (thread_sp)
-            std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetCrashedWithException (*info);
-        break;
-    default:
-        // This is just a pre-signal-delivery notification of the incoming signal.
-        if (thread_sp)
-            std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (signo);
-
-        break;
-    }
+        std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal(signo, info);
 
     // Send a stop to the debugger after we get all other threads to stop.
     StopRunningThreads (pid);
 }
 
 namespace {
 
 struct EmulatorBaton

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

private:
         // ---------------------------------------------------------------------
         void
         SetRunning ();
 
         void
         SetStepping ();
 
         void
-        SetStoppedBySignal (uint32_t signo);
+        SetStoppedBySignal(uint32_t signo, const siginfo_t *info = nullptr);
 
         /// Return true if the thread is stopped.
         /// If stopped by a signal, indicate the signo in the signo argument.
         /// Otherwise, return LLDB_INVALID_SIGNAL_NUMBER.
         bool
         IsStopped (int *signo);
 
         void

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.cpp

NativeThreadLinux::GetStopReason (ThreadStopInfo &stop_info, std::string& description)
     case eStateStopped:
     case eStateCrashed:
     case eStateExited:
     case eStateSuspended:
     case eStateUnloaded:
         if (log)
             LogThreadStopInfo (*log, m_stop_info, "m_stop_info in thread:");
         stop_info = m_stop_info;
-        switch (m_stop_info.reason)
-        {
-            case StopReason::eStopReasonException:
-            case StopReason::eStopReasonBreakpoint:
-            case StopReason::eStopReasonWatchpoint:
-                description = m_stop_description;
-            default:
-                break;
-        }
         if (log)
             LogThreadStopInfo (*log, stop_info, "returned stop_info:");
 
         return true;
 
     case eStateInvalid:
     case eStateConnected:
     case eStateAttaching:
NativeThreadLinux::SetStepping ()
     const StateType new_state = StateType::eStateStepping;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonNone;
 }
 
 void
-NativeThreadLinux::SetStoppedBySignal (uint32_t signo)
+NativeThreadLinux::SetStoppedBySignal(uint32_t signo, const siginfo_t *info)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf ("NativeThreadLinux::%s called with signal 0x%02" PRIx32, __FUNCTION__, signo);
 
     const StateType new_state = StateType::eStateStopped;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonSignal;
     m_stop_info.details.signal.signo = signo;
+
+    m_stop_description.clear();
+    switch (signo)
+    {
+    case SIGSEGV:
+    case SIGBUS:
+    case SIGFPE:
+    case SIGILL:
+        if (! info)
+            break;
+        const auto reason = GetCrashReason(*info);
+        m_stop_description = GetCrashReasonString(reason, reinterpret_cast<uintptr_t>(info->si_addr));
+        break;
+    }
 }
 
 bool
 NativeThreadLinux::IsStopped (int *signo)
 {
     if (!StateIsStoppedState (m_state, false))
         return false;
 
NativeThreadLinux::SetStoppedByTrace ()
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonTrace;
     m_stop_info.details.signal.signo = SIGTRAP;
 }
 
 void
-NativeThreadLinux::SetCrashedWithException (const siginfo_t& info)
-{
-    const StateType new_state = StateType::eStateCrashed;
-    MaybeLogStateChange (new_state);
-    m_state = new_state;
-
-    m_stop_info.reason = StopReason::eStopReasonException;
-    m_stop_info.details.signal.signo = info.si_signo;
-
-    const auto reason = GetCrashReason (info);
-    m_stop_description = GetCrashReasonString (reason, reinterpret_cast<uintptr_t>(info.si_addr));
-}
-
-void
 NativeThreadLinux::SetSuspended ()
 {
     const StateType new_state = StateType::eStateSuspended;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     // FIXME what makes sense here? Do we need a suspended StopReason?
     m_stop_info.reason = StopReason::eStopReasonNone;

lldb/trunk/source/Plugins/Process/POSIX/CrashReason.cpp

GetCrashReasonString (CrashReason reason, lldb::addr_t fault_addr)
 
     switch (reason)
     {
     default:
         assert(false && "invalid CrashReason");
         break;
 
     case CrashReason::eInvalidAddress:
-        str = "invalid address";
+        str = "signal SIGSEGV: invalid address";
         AppendFaultAddr (str, fault_addr);
         break;
     case CrashReason::ePrivilegedAddress:
-        str = "address access protected";
+        str = "signal SIGSEGV: address access protected";
         AppendFaultAddr (str, fault_addr);
         break;
     case CrashReason::eIllegalOpcode:
-        str = "illegal instruction";
+        str = "signal SIGILL: illegal instruction";
         break;
     case CrashReason::eIllegalOperand:
-        str = "illegal instruction operand";
+        str = "signal SIGILL: illegal instruction operand";
         break;
     case CrashReason::eIllegalAddressingMode:
-        str = "illegal addressing mode";
+        str = "signal SIGILL: illegal addressing mode";
         break;
     case CrashReason::eIllegalTrap:
-        str = "illegal trap";
+        str = "signal SIGILL: illegal trap";
         break;
     case CrashReason::ePrivilegedOpcode:
-        str = "privileged instruction";
+        str = "signal SIGILL: privileged instruction";
         break;
     case CrashReason::ePrivilegedRegister:
-        str = "privileged register";
+        str = "signal SIGILL: privileged register";
         break;
     case CrashReason::eCoprocessorError:
-        str = "coprocessor error";
+        str = "signal SIGILL: coprocessor error";
         break;
     case CrashReason::eInternalStackError:
-        str = "internal stack error";
+        str = "signal SIGILL: internal stack error";
         break;
     case CrashReason::eIllegalAlignment:
-        str = "illegal alignment";
+        str = "signal SIGBUS: illegal alignment";
         break;
     case CrashReason::eIllegalAddress:
-        str = "illegal address";
+        str = "signal SIGBUS: illegal address";
         break;
     case CrashReason::eHardwareError:
-        str = "hardware error";
+        str = "signal SIGBUS: hardware error";
         break;
     case CrashReason::eIntegerDivideByZero:
-        str = "integer divide by zero";
+        str = "signal SIGFPE: integer divide by zero";
         break;
     case CrashReason::eIntegerOverflow:
-        str = "integer overflow";
+        str = "signal SIGFPE: integer overflow";
         break;
     case CrashReason::eFloatDivideByZero:
-        str = "floating point divide by zero";
+        str = "signal SIGFPE: floating point divide by zero";
         break;
     case CrashReason::eFloatOverflow:
-        str = "floating point overflow";
+        str = "signal SIGFPE: floating point overflow";
         break;
     case CrashReason::eFloatUnderflow:
-        str = "floating point underflow";
+        str = "signal SIGFPE: floating point underflow";
         break;
     case CrashReason::eFloatInexactResult:
-        str = "inexact floating point result";
+        str = "signal SIGFPE: inexact floating point result";
         break;
     case CrashReason::eFloatInvalidOperation:
-        str = "invalid floating point operation";
+        str = "signal SIGFPE: invalid floating point operation";
         break;
     case CrashReason::eFloatSubscriptRange:
-        str = "invalid floating point subscript range";
+        str = "signal SIGFPE: invalid floating point subscript range";
         break;
     }
 
     return str;
 }
 
 const char *
 CrashReasonAsString (CrashReason reason)

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

case 'S':
                             else
                             {
                                 // If we were stepping then assume the stop was the result of the trace.  If we were
                                 // not stepping then report the SIGTRAP.
                                 // FIXME: We are still missing the case where we single step over a trap instruction.
                                 if (thread_sp->GetTemporaryResumeState() == eStateStepping)
                                     thread_sp->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp));
                                 else
-                                    thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal(*thread_sp, signo));
+                                    thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal(*thread_sp, signo, description.c_str()));
                             }
                         }
                         if (!handled)
-                            thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo));
+                            thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo, description.c_str()));
                     }
 
                     if (!description.empty())
                     {
                         lldb::StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
                         if (stop_info_sp)
                         {
                             const char *stop_info_desc = stop_info_sp->GetDescription();

lldb/trunk/source/Target/StopInfo.cpp

 //----------------------------------------------------------------------
 // StopInfoUnixSignal
 //----------------------------------------------------------------------
 
 class StopInfoUnixSignal : public StopInfo
 {
 public:
 
-    StopInfoUnixSignal (Thread &thread, int signo) :
+    StopInfoUnixSignal (Thread &thread, int signo, const char *description) :
         StopInfo (thread, signo)
     {
+        SetDescription (description);
     }
     
     virtual ~StopInfoUnixSignal ()
     {
     }
 
 
     virtual StopReason

 
 StopInfoSP
 StopInfo::CreateStopReasonWithWatchpointID (Thread &thread, break_id_t watch_id)
 {
     return StopInfoSP (new StopInfoWatchpoint (thread, watch_id));
 }
 
 StopInfoSP
-StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo)
+StopInfo::CreateStopReasonWithSignal (Thread &thread, int signo, const char *description)
 {
-    return StopInfoSP (new StopInfoUnixSignal (thread, signo));
+    return StopInfoSP (new StopInfoUnixSignal (thread, signo, description));
 }
 
 StopInfoSP
 StopInfo::CreateStopReasonToTrace (Thread &thread)
 {
     return StopInfoSP (new StopInfoTrace (thread));
 }
 

lldb/trunk/test/functionalities/inferior-changed/TestInferiorChanged.py

class ChangedInferiorTestCase(TestBase):
 
     def inferior_crashing(self):
         """Inferior crashes upon launching; lldb should catch the event and stop."""
         self.exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
 
-        if self.platformIsDarwin():
-            stop_reason = 'stop reason = EXC_BAD_ACCESS'
-        else:
-            stop_reason = 'stop reason = invalid address'
-
-        # The stop reason of the thread should be a bad access exception.
-        self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
-            substrs = ['stopped',
-                       stop_reason])
+        # We should have one crashing thread
+        self.assertEquals(
+                len(lldbutil.get_crashed_threads(self, self.dbg.GetSelectedTarget().GetProcess())),
+                1,
+                STOPPED_DUE_TO_EXC_BAD_ACCESS)
 
         # And it should report the correct line number.
-        self.expect("thread backtrace all",
-            substrs = [stop_reason,
-                       'main.c:%d' % self.line1])
+        self.expect("thread backtrace all", substrs = ['main.c:%d' % self.line1])
 
     def inferior_not_crashing(self):
         """Test lldb reloads the inferior after it was changed during the session."""
         self.runCmd("process kill")
         # Prod the lldb-platform that we have a newly built inferior ready.
         if lldb.lldbtest_remote_sandbox:
             self.runCmd("file " + self.exe, CURRENT_EXECUTABLE_SET)
         self.runCmd("run", RUN_FAILED)
         self.runCmd("process status")
 
-        if self.platformIsDarwin():
-            stop_reason = 'EXC_BAD_ACCESS'
-        else:
-            stop_reason = 'invalid address'
-
-        if stop_reason in self.res.GetOutput():
-            self.fail("Inferior changed, but lldb did not perform a reload")
+        self.assertNotEquals(
+                len(lldbutil.get_crashed_threads(self, self.dbg.GetSelectedTarget().GetProcess())),
+                1,
+                "Inferior changed, but lldb did not perform a reload")
 
         # Break inside the main.
         lldbutil.run_break_set_by_file_and_line (self, "main2.c", self.line2, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_FAILED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,

lldb/trunk/test/functionalities/inferior-crashing/TestInferiorCrashing.py

class CrashingInferiorTestCase(TestBase):
 
     @skipUnlessDarwin
     def test_inferior_crashing_expr_step_and_expr_dsym(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDsym()
         self.inferior_crashing_expr_step_expr()
 
     @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
-    @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
+    @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.
     def test_inferior_crashing_expr_step_and_expr_dwarf(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDwarf()
         self.inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
-        if self.platformIsDarwin():
-            stop_reason = 'stop reason = EXC_BAD_ACCESS'
-        else:
-            stop_reason = 'stop reason = invalid address'
-
-        # The stop reason of the thread should be a bad access exception.
-        self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
-            substrs = ['stopped',
-                       stop_reason])
-
-        return stop_reason
+        # We should have one crashing thread
+        self.assertEquals(
+                len(lldbutil.get_crashed_threads(self, self.dbg.GetSelectedTarget().GetProcess())),
+                1,
+                STOPPED_DUE_TO_EXC_BAD_ACCESS)
 
     def get_api_stop_reason(self):
         return lldb.eStopReasonException
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number of the crash.
         self.line = line_number('main.c', '// Crash here.')
 
     def inferior_crashing(self):
         """Inferior crashes upon launching; lldb should catch the event and stop."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
-        stop_reason = self.check_stop_reason()
+        # The exact stop reason depends on the platform
+        if self.platformIsDarwin():
+            stop_reason = 'stop reason = EXC_BAD_ACCESS'
+        elif self.getPlatform() == "linux":
+            stop_reason = 'stop reason = signal SIGSEGV'
+        else:
+            stop_reason = 'stop reason = invalid address'
+        self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
+            substrs = ['stopped',
+                       stop_reason])
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
             substrs = [stop_reason,
                        'main.c:%d' % self.line])
 
     def inferior_crashing_python(self):
         """Inferior crashes upon launching; lldb should catch the event and stop."""
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Now launch the process, and do not stop at entry point.
         # Both argv and envp are null.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
 
         if process.GetState() != lldb.eStateStopped:
             self.fail("Process should be in the 'stopped' state, "
                       "instead the actual state is: '%s'" %
                       lldbutil.state_type_to_str(process.GetState()))
 
-        thread = lldbutil.get_stopped_thread(process, self.get_api_stop_reason())
-        if not thread:
-            self.fail("Fail to stop the thread upon bad access exception")
+        threads = lldbutil.get_crashed_threads(self, process)
+        self.assertEqual(len(threads), 1, "Failed to stop the thread upon bad access exception")
 
         if self.TraceOn():
-            lldbutil.print_stacktrace(thread)
+            lldbutil.print_stacktrace(threads[0])
 
     def inferior_crashing_registers(self):
         """Test that lldb can read registers after crashing."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
         self.check_stop_reason()
def inferior_crashing_step(self):
         self.set_breakpoint(self.line)
         self.runCmd("run", RUN_FAILED)
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['main.c:%d' % self.line,
                        'stop reason = breakpoint'])
 
         self.runCmd("next")
-        stop_reason = self.check_stop_reason()
+        self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
         self.expect("p argv[0]",
             substrs = ['a.out'])
         self.expect("p null_ptr",
             substrs = ['= 0x0'])
 
         # lldb should be able to read from registers from the inferior after crashing.
         lldbplatformutil.check_first_register_readable(self)
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
-            substrs = [stop_reason,
-                       'main.c:%d' % self.line])
+            substrs = ['main.c:%d' % self.line])
 
     def inferior_crashing_step_after_break(self):
         """Test that lldb behaves correctly when stepping after a crash."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
         self.check_stop_reason()
 
-        self.runCmd("next")
+        expected_state = 'exited' # Provide the exit code.
+        if self.platformIsDarwin():
+            expected_state = 'stopped' # TODO: Determine why 'next' and 'continue' have no effect after a crash.
+
+        self.expect("next",
+            substrs = ['Process', expected_state])
+
+        if expected_state == 'exited':
+            self.expect("thread list", error=True,substrs = ['Process must be launched'])
+        else:
             self.check_stop_reason()
 
     def inferior_crashing_expr_step_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
         self.check_stop_reason()

lldb/trunk/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

class CrashingRecursiveInferiorTestCase(TestBase):
 
     @skipUnlessDarwin
     def test_recursive_inferior_crashing_expr_step_and_expr_dsym(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDsym()
         self.recursive_inferior_crashing_expr_step_expr()
 
     @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
+    @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.
     def test_recursive_inferior_crashing_expr_step_and_expr_dwarf(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.buildDwarf()
         self.recursive_inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 
     def check_stop_reason(self):
-        if self.platformIsDarwin():
-            stop_reason = 'stop reason = EXC_BAD_ACCESS'
-        else:
-            stop_reason = 'stop reason = invalid address'
-
-        # The stop reason of the thread should be a bad access exception.
-        self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
-            substrs = ['stopped',
-                       stop_reason])
-
-        return stop_reason
+        # We should have one crashing thread
+        self.assertEquals(
+                len(lldbutil.get_crashed_threads(self, self.dbg.GetSelectedTarget().GetProcess())),
+                1,
+                STOPPED_DUE_TO_EXC_BAD_ACCESS)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number of the crash.
         self.line = line_number('main.c', '// Crash here.')
 
     def recursive_inferior_crashing(self):
         """Inferior crashes upon launching; lldb should catch the event and stop."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
-        stop_reason = self.check_stop_reason()
+
+        # The exact stop reason depends on the platform
+        if self.platformIsDarwin():
+            stop_reason = 'stop reason = EXC_BAD_ACCESS'
+        elif self.getPlatform() == "linux":
+            stop_reason = 'stop reason = signal SIGSEGV'
+        else:
+            stop_reason = 'stop reason = invalid address'
+        self.expect("thread list", STOPPED_DUE_TO_EXC_BAD_ACCESS,
+            substrs = ['stopped',
+                       stop_reason])
 
         # And it should report a backtrace that includes main and the crash site.
         self.expect("thread backtrace all",
             substrs = [stop_reason, 'main', 'argc', 'argv', 'recursive_function'])
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
             substrs = [stop_reason,
def recursive_inferior_crashing_python(self):
         # Both argv and envp are null.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
 
         if process.GetState() != lldb.eStateStopped:
             self.fail("Process should be in the 'stopped' state, "
                       "instead the actual state is: '%s'" %
                       lldbutil.state_type_to_str(process.GetState()))
 
-        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonException)
-        if not thread:
-            self.fail("Fail to stop the thread upon bad access exception")
+        threads = lldbutil.get_crashed_threads(self, process)
+        self.assertEqual(len(threads), 1, "Failed to stop the thread upon bad access exception")
 
         if self.TraceOn():
-            lldbutil.print_stacktrace(thread)
+            lldbutil.print_stacktrace(threads[0])
 
     def recursive_inferior_crashing_registers(self):
         """Test that lldb can read registers after crashing."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
         self.check_stop_reason()
def recursive_inferior_crashing_step(self):
         self.set_breakpoint(self.line)
         self.runCmd("run", RUN_FAILED)
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['main.c:%d' % self.line,
                        'stop reason = breakpoint'])
 
         self.runCmd("next")
-        stop_reason = self.check_stop_reason()
+        self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
         self.expect("p i",
             substrs = ['(int) $0 ='])
 
         # lldb should be able to read from registers from the inferior after crashing.
         lldbplatformutil.check_first_register_readable(self)
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
-            substrs = [stop_reason,
-                       'main.c:%d' % self.line])
+            substrs = ['main.c:%d' % self.line])
 
     def recursive_inferior_crashing_step_after_break(self):
         """Test that lldb behaves correctly when stepping after a crash."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_FAILED)
         self.check_stop_reason()
 
         expected_state = 'exited' # Provide the exit code.
-        if self.platformIsDarwin() or self.getPlatform() == "linux":
+        if self.platformIsDarwin():
             expected_state = 'stopped' # TODO: Determine why 'next' and 'continue' have no effect after a crash.
 
         self.expect("next",
             substrs = ['Process', expected_state])
 
         if expected_state == 'exited':
             self.expect("thread list", error=True,substrs = ['Process must be launched'])
         else:

lldb/trunk/test/functionalities/signal/handle-segv/Makefile

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

lldb/trunk/test/functionalities/signal/handle-segv/TestHandleSegv.py

+"""Test that we can debug inferiors that handle SIGSEGV by themselves"""
+
+import os
+import unittest2
+import lldb
+from lldbtest import *
+import lldbutil
+import re
+
+
+class HandleSegvTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows # signals do not exist on Windows
+    @skipIfDarwin
+    def test_inferior_handle_sigsegv_with_dwarf(self):
+        self.buildDefault()
+        exe = os.path.join(os.getcwd(), "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("SIGSEGV")
+
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
+        self.assertTrue(thread.IsValid(), "Thread should be stopped due to a signal")
+        self.assertTrue(thread.GetStopReasonDataCount() >= 1, "There was data in the event.")
+        self.assertEqual(thread.GetStopReasonDataAtIndex(0), signo, "The stop signal was SIGSEGV")
+
+        # Continue until we exit.
+        process.Continue()
+        self.assertEqual(process.GetState(), lldb.eStateExited)
+        self.assertEqual(process.GetExitStatus(), 0)
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

lldb/trunk/test/functionalities/signal/handle-segv/main.c

+#include <sys/mman.h>
+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+
+enum {
+    kMmapSize = 0x1000,
+    kMagicValue = 47,
+};
+
+void *address;
+volatile sig_atomic_t signaled = 0;
+
+void handler(int sig)
+{
+    signaled = 1;
+    if (munmap(address, kMmapSize) != 0)
+    {
+        perror("munmap");
+        _exit(5);
+    }
+
+    void* newaddr = mmap(address, kMmapSize, PROT_READ | PROT_WRITE,
+            MAP_ANON | MAP_FIXED | MAP_PRIVATE, -1, 0);
+    if (newaddr != address)
+    {
+        fprintf(stderr, "Newly mmaped address (%p) does not equal old address (%p).\n",
+                newaddr, address);
+        _exit(6);
+    }
+    *(int*)newaddr = kMagicValue;
+}
+
+int main()
+{
+    if (signal(SIGSEGV, handler) == SIG_ERR)
+    {
+        perror("signal");
+        return 1;
+    }
+
+    address = mmap(NULL, kMmapSize, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (address == MAP_FAILED)
+    {
+        perror("mmap");
+        return 2;
+    }
+
+    // This should first trigger a segfault. Our handler will make the memory readable and write
+    // the magic value into memory.
+    if (*(int*)address != kMagicValue)
+        return 3;
+
+    if (! signaled)
+        return 4;
+
+    return 0;
+}

lldb/trunk/test/functionalities/thread/concurrent_events/TestConcurrentEvents.py

class ConcurrentEventsTestCase(TestBase):
     def inferior_done(self):
         """ Returns true if the inferior is done executing all the event threads (and is stopped at self.finish_breakpoint, 
             or has terminated execution.
         """
         return self.finish_breakpoint.GetHitCount() > 0 or \
                 self.crash_count > 0 or \
                 self.inferior_process.GetState() == lldb.eStateExited
 
+    def count_signaled_threads(self):
+        count = 0
+        for thread in self.inferior_process:
+            if thread.GetStopReason() == lldb.eStopReasonSignal and thread.GetStopReasonDataAtIndex(0) == self.inferior_process.GetUnixSignals().GetSignalNumberFromName('SIGUSR1'):
+                count += 1
+        return count
+
     def do_thread_actions(self,
                           num_breakpoint_threads = 0,
                           num_signal_threads = 0,
                           num_watchpoint_threads = 0,
                           num_crash_threads = 0,
                           num_delay_breakpoint_threads = 0,
                           num_delay_signal_threads = 0,
                           num_delay_watchpoint_threads = 0,
def do_thread_actions(self,
                              + num_signal_threads + num_delay_signal_threads \
                              + num_watchpoint_threads + num_delay_watchpoint_threads \
                              + num_crash_threads + num_delay_crash_threads + 1
         self.assertEqual(num_threads, expected_num_threads,
             'Expected to see %d threads, but seeing %d. Details:\n%s' % (expected_num_threads,
                                                                          num_threads,
                                                                          "\n\t".join(self.describe_threads())))
 
-        self.signal_count = len(lldbutil.get_stopped_threads(self.inferior_process, lldb.eStopReasonSignal))
-        self.crash_count = len(lldbutil.get_stopped_threads(self.inferior_process, lldb.eStopReasonException))
+        self.signal_count = self.count_signaled_threads()
+        self.crash_count = len(lldbutil.get_crashed_threads(self, self.inferior_process))
 
         # Run to completion (or crash)
         while not self.inferior_done(): 
             if self.TraceOn():
                 self.runCmd("thread backtrace all")
             self.runCmd("continue")
-            self.signal_count += len(lldbutil.get_stopped_threads(self.inferior_process, lldb.eStopReasonSignal))
-            self.crash_count += len(lldbutil.get_stopped_threads(self.inferior_process, lldb.eStopReasonException))
+            self.signal_count += self.count_signaled_threads()
+            self.crash_count += len(lldbutil.get_crashed_threads(self, self.inferior_process))
 
         if num_crash_threads > 0 or num_delay_crash_threads > 0:
             # Expecting a crash
             self.assertTrue(self.crash_count > 0,
                 "Expecting at least one thread to crash. Details: %s" % "\t\n".join(self.describe_threads()))
 
             # Ensure the zombie process is reaped
             self.runCmd("process kill")

lldb/trunk/test/lldbutil.py

def get_threads_stopped_at_breakpoint (process, bkpt):
     for thread in stopped_threads:
         # Make sure we've hit our breakpoint...
         break_id = thread.GetStopReasonDataAtIndex (0)
         if break_id == bkpt.GetID():
             threads.append(thread)
 
     return threads
 
+def is_thread_crashed (test, thread):
+    """In the test suite we dereference a null pointer to simulate a crash. The way this is
+    reported depends on the platform."""
+    if test.platformIsDarwin():
+        return thread.GetStopReason() == lldb.eStopReasonException and "EXC_BAD_ACCESS" in thread.GetStopDescription(100)
+    elif test.getPlatform() == "linux":
+        return thread.GetStopReason() == lldb.eStopReasonSignal and thread.GetStopReasonDataAtIndex(0) == thread.GetProcess().GetUnixSignals().GetSignalNumberFromName("SIGSEGV")
+    else:
+        return "invalid address" in thread.GetStopDescription(100)
+
+def get_crashed_threads (test, process):
+    threads = []
+    if process.GetState() != lldb.eStateStopped:
+        return threads
+    for thread in process:
+        if is_thread_crashed(test, thread):
+            threads.append(thread)
+    return threads
+
 def continue_to_breakpoint (process, bkpt):
     """ Continues the process, if it stops, returns the threads stopped at bkpt; otherwise, returns None"""
     process.Continue()
     if process.GetState() != lldb.eStateStopped:
         return None
     else:
         return get_threads_stopped_at_breakpoint (process, bkpt)