Fix segfault notification in lldb-mi

[ki.stfu]

Summary

This patch adds system exception handling in lldb-mi + tests.

All tests pass on OS X.

[abidh]

Is this a known stop reason "exception-received" for MI. I had a quick look but could not find it. Code looks ok to me. But I have to yet run and make sure that it passes on Linux. As I noted yesterday in few other tests, output can be a little bit different which can cause the test to fail.

[ki.stfu]

I need to do some changes in tests.

[clayborg]

Make a test case that access violates and remove code from the MI driver in main.c

test/tools/lldb-mi/main.c

15–32

This should go into a test case binary, probably doesn't belong in the actual MI driver.

[ki.stfu]

Fix tests

[ki.stfu]

In D7500#120713, @abidh wrote:

Is this a known stop reason "exception-received" for MI. I had a quick look but could not find it.

I think we can set the reason to "exception-raised", if it's better.

[ki.stfu]

In D7500#120727, @clayborg wrote:

Make a test case that access violates and remove code from the MI driver in main.c

This case checks lldb-mi functionality. Why would you want to remove it from here?

test/tools/lldb-mi/main.c

15–32

Why? In this case I'm checking that lldb-mi prints the *stopped, so this test relates to MI driver.

[emaste]

test/tools/lldb-mi/main.c

15–32

I'm guessing it's just a case if mistaken identity. When I first glanced at this in email I spotted only "tools/lldb-mi/main.c" and thought it was the lldb-mi driver itself, not a test for lldb-mi. Perhaps also true for @clayborg.

[clayborg]

Never mind, as Ed said, I thought this was in the MI driver binary. It actually is in a test case binary...

test/tools/lldb-mi/TestMiNotification.py

def test_lldbmi_stopped_when_stopatentry_remote(self):
             self.runCmd("-gdb-exit")
             self.runCmd("") #FIXME lldb-mi hangs here on Linux; extra return is needed
             self.expect("\^exit")
 
         finally:
             # Clean up
             debugserver_child.terminate(force = True)
 
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    def test_lldbmi_stopped_when_segfault_local(self):
+        """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (local)."""
+
+        self.spawnLldbMi(args = None)
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # Run to main
+        self.runCmd("-break-insert -f main")
+        self.expect("\^done,bkpt={number=\"1\"")
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+        # Set dosegfault=1 and run (to cause a segfault error)
+        self.runCmd("-data-evaluate-expression \"dosegfault=1\"")
+        self.expect("\^done,value=\"1\"")
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+
+        # Test that *stopped is printed
+        self.expect("\*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS \(code=1, address=0x0\)\",thread-id=\"1\",stopped-threads=\"all\"")
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
+    def test_lldbmi_stopped_when_segfault_remote(self):
+        """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (remote)."""
+
+        # Prepare debugserver
+        import os, sys
+        lldb_gdbserver_folder = os.path.abspath(os.path.join(os.path.dirname(os.getcwd()), "lldb-gdbserver"))
+        sys.path.append(lldb_gdbserver_folder)
+        import lldbgdbserverutils
+        debugserver_exe = lldbgdbserverutils.get_debugserver_exe()
+        if not debugserver_exe:
+            raise Exception("debugserver not found")
+        hostname = "localhost"
+        import random
+        port = 12000 + random.randint(0,3999) # the same as GdbRemoteTestCaseBase.get_next_port
+        import pexpect
+        debugserver_child = pexpect.spawn("%s %s:%d" % (debugserver_exe, hostname, port))
+
+        self.spawnLldbMi(args = None)
+
+        # Connect to debugserver
+        self.runCmd("-interpreter-exec command \"platform select remote-macosx --sysroot /\"")
+        self.expect("\^done")
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+        self.runCmd("-interpreter-exec command \"process connect connect://%s:%d\"" % (hostname, port))
+        self.expect("\^done")
+
+        try:
+            # Run to main
+            self.runCmd("-break-insert -f main")
+            self.expect("\^done,bkpt={number=\"1\"")
+            #FIXME -exec-run doesn't work
+            self.runCmd("-interpreter-exec command \"process launch\"") #FIXME: self.runCmd("-exec-run")
+            self.expect("\^done")                                       #FIXME: self.expect("\^running")
+            self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+            # Set dosegfault=1 and run (to cause a segfault error)
+            self.runCmd("-data-evaluate-expression \"dosegfault=1\"")
+            self.expect("\^done,value=\"1\"")
+            self.runCmd("-exec-continue")
+            self.expect("\^running")
+
+            # Test that *stopped is printed
+            self.expect("\*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS \(code=1, address=0x0\)\",thread-id=\"1\",stopped-threads=\"all\"")
+
+            # Exit
+            self.runCmd("-gdb-exit")
+            self.runCmd("") #FIXME lldb-mi hangs here on Linux; extra return is needed
+            self.expect("\^exit")
+
+        finally:
+            # Clean up
+            debugserver_child.terminate(force = True)
+
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/main.c

 //===-- main.c --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 extern int a_MyFunction();
 extern int b_MyFunction();
 extern int infloop();
 int doloop;
+int dosegfault;
 int g_MyVar = 3;
 static int s_MyVar = 4;
 int main (int argc, char const *argv[])
 {
     int a, b;
     printf("argc=%d\n", argc);   //BP_printf_call
     //BP_argctest
     a = a_MyFunction();          //BP_a_MyFunction_call
     b = b_MyFunction();          //BP_b_MyFunction_call
     //BP_localstest -- it must be at line #24 (or fix it in main*.micmds)
     if (doloop) // BP_doloop
         infloop();
+    if (dosegfault)
+    {
+        int *p = NULL;
+        *p = 1;
+    }
     if (argc > 1 && *argv[1] == 'l') {
         a++;
         printf("a=%d, argv[1]=%s\n", a, argv[1]); //BP_argtest
     }
     s_MyVar = a + b;
     return a + b - s_MyVar; //BP_source
 }

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.h

private:
     bool HandleEventSBCommandInterpreter(const lldb::SBEvent &vEvent);
     bool HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent, bool &vrbExitAppEvent);
     bool HandleProcessEventStateRunning(void);
     bool HandleProcessEventStateExited(void);
     bool HandleProcessEventStateStopped(bool &vwrbShouldBrk);
     bool HandleProcessEventStopReasonTrace(void);
     bool HandleProcessEventStopReasonBreakpoint(void);
     bool HandleProcessEventStopSignal(bool &vwrbShouldBrk);
+    bool HandleProcessEventStopException(void);
     bool HandleProcessEventStateSuspended(const lldb::SBEvent &vEvent);
     bool MiHelpGetCurrentThreadFrame(CMICmnMIValueTuple &vwrMiValueTuple);
     bool MiResultRecordToStdout(const CMICmnMIResultRecord &vrMiResultRecord);
     bool MiOutOfBandRecordToStdout(const CMICmnMIOutOfBandRecord &vrMiResultRecord);
     bool MiStoppedAtBreakPoint(const MIuint64 vBrkPtId, const lldb::SBBreakpoint &vBrkPt);
     bool TextToStdout(const CMIUtilString &vrTxt);
     bool TextToStderr(const CMIUtilString &vrTxt);
     bool UpdateSelectedThread(void);
     bool ConvertPrintfCtrlCodeToString(const MIchar vCtrl, CMIUtilString &vwrStrEquivalent);
 
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmnLLDBDebuggerHandleEvents(void);
 };

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

switch (eStoppedReason)
             pEventType = "eStopReasonWatchpoint";
             break;
         case lldb::eStopReasonSignal:
             pEventType = "eStopReasonSignal";
             bOk = HandleProcessEventStopSignal(vwrbShouldBrk);
             break;
         case lldb::eStopReasonException:
             pEventType = "eStopReasonException";
+            bOk = HandleProcessEventStopException();
             break;
         case lldb::eStopReasonExec:
             pEventType = "eStopReasonExec";
             break;
         case lldb::eStopReasonPlanComplete:
             pEventType = "eStopReasonPlanComplete";
             bOk = HandleProcessEventStopReasonTrace();
             break;
switch (nStopReason)
             bOk = bOk && TextToStdout("(gdb)");
         }
     } // switch( nStopReason )
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: Asynchronous event handler for LLDB Process stop exception.
+// Type:    Method.
+// Args:    None.
+// Return:  MIstatus::success - Functional succeeded.
+//          MIstatus::failure - Functional failed.
+// Throws:  None.
+//--
+bool
+CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopException(void)
+{
+    const lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess();
+    lldb::SBThread sbThread = sbProcess.GetSelectedThread();
+    const size_t nStopDescriptionLen = sbThread.GetStopDescription(nullptr, 0);
+    std::shared_ptr<char> spStopDescription(new char[nStopDescriptionLen]);
+    sbThread.GetStopDescription(spStopDescription.get(), nStopDescriptionLen);
+
+    // MI print "*stopped,reason=\"exception-received\",exception=\"%s\",thread-id=\"%d\",stopped-threads=\"all\""
+    const CMICmnMIValueConst miValueConst("exception-received");
+    const CMICmnMIValueResult miValueResult("reason", miValueConst);
+    CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
+    const CMIUtilString strReason(spStopDescription.get());
+    const CMICmnMIValueConst miValueConst2(strReason);
+    const CMICmnMIValueResult miValueResult2("exception", miValueConst2);
+    bool bOk = miOutOfBandRecord.Add(miValueResult2);
+    const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbThread.GetIndexID()));
+    const CMICmnMIValueConst miValueConst3(strThreadId);
+    const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3);
+    bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+    const CMICmnMIValueConst miValueConst4("all");
+    const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4);
+    bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
+    bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
+    bOk = bOk && TextToStdout("(gdb)");
+
+    return bOk;
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: Form partial MI response in a MI value tuple object.
 // Type:    Method.
 // Args:    vwrMiValueTuple   - (W) MI value tuple object.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool