Fix =thread-exited message (MI)

[ki.stfu]

Summary

This patch includes:

1. Fix invalid thread id in =thread-exited message
2. Remove invalid threads from cache

All tests pass on OS X.

[ki.stfu]

oops. remove mistakenly added files

[abidh]

Looks ok.

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

1677

Just a question. It was printing invalid thread id because thread.GetIndexID() was returning a garbage value?

[ki.stfu]

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

1677

It's not quite correct. SBThread::IsValid() means that SBThread.m_opaque_ptr isn't null. Therefore when it's invalid the m_opaque_ptr is null and in this case the SBThread::GetIndexID() returns LLDB_INVALID_THREAD_ID constant (I don't remember the name of this constant exactly).

source/Target/Process.cpp

Process::GetGlobalProperties()
     if (!g_settings_sp)
         g_settings_sp.reset (new ProcessProperties (NULL));
     return g_settings_sp;
 }
 
 void
 Process::Finalize()
 {
-    switch (GetPrivateState())
-    {
-        case eStateConnected:
-        case eStateAttaching:
-        case eStateLaunching:
-        case eStateStopped:
-        case eStateRunning:
-        case eStateStepping:
-        case eStateCrashed:
-        case eStateSuspended:
-            if (GetShouldDetach())
-            {
-                // FIXME: This will have to be a process setting:
-                bool keep_stopped = false;
-                Detach(keep_stopped);
-            }
-            else
-                Destroy();
-            break;
-            
-        case eStateInvalid:
-        case eStateUnloaded:
-        case eStateDetached:
-        case eStateExited:
-            break;
-    }
+    // Destroy this process first
 
     // Clear our broadcaster before we proceed with destroying
     Broadcaster::Clear();
 
     // Do any cleanup needed prior to being destructed... Subclasses
     // that override this method should call this superclass method as well.
     
     // We need to destroy the loader before the derived Process class gets destroyed

 Error
 Process::Destroy ()
 {
     
     // Tell ourselves we are in the process of destroying the process, so that we don't do any unnecessary work
     // that might hinder the destruction.  Remember to set this back to false when we are done.  That way if the attempt
     // failed and the process stays around for some reason it won't be in a confused state.
     
+    if (GetShouldDetach())
+    {
+        // FIXME: This will have to be a process setting:
+        bool keep_stopped = false;
+        Detach(keep_stopped);
+    }
+
     m_destroy_in_process = true;
 
     Error error (WillDestroy());
     if (error.Success())
     {
         EventSP exit_event_sp;
         if (DestroyRequiresHalt())
         {

tools/lldb-mi/MICmdCmdMiscellanous.cpp

 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdGdbExit::Execute(void)
 {
     CMICmnLLDBDebugger::Instance().GetDriver().SetExitApplicationFlag(true);
-    const lldb::SBError sbErr = m_rLLDBDebugSessionInfo.GetProcess().Detach();
+    const lldb::SBError sbErr = m_rLLDBDebugSessionInfo.GetProcess().Destroy();
     // Do not check for sbErr.Fail() here, m_lldbProcess is likely !IsValid()
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record Result
 //          for the work carried out in the Execute().

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::ChkForStateChanges(void)
 {
-    lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess();
+    CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
+    lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     if (!sbProcess.IsValid())
         return MIstatus::success;
-    lldb::SBTarget sbTarget = CMICmnLLDBDebugSessionInfo::Instance().GetTarget();
-    if (!sbTarget.IsValid())
-        return MIstatus::success;
-
-    bool bOk = MIstatus::success;
 
     // Check for created threads
     const MIuint nThread = sbProcess.GetNumThreads();
     for (MIuint i = 0; i < nThread; i++)
     {
         //  GetThreadAtIndex() uses a base 0 index
         //  GetThreadByIndexID() uses a base 1 index
         lldb::SBThread thread = sbProcess.GetThreadAtIndex(i);
         if (!thread.IsValid())
             continue;
 
-        CMICmnLLDBDebugSessionInfo::VecActiveThreadId_t::const_iterator it =
-            CMICmnLLDBDebugSessionInfo::Instance().m_vecActiveThreadId.begin();
-        bool bFound = false;
-        while (it != CMICmnLLDBDebugSessionInfo::Instance().m_vecActiveThreadId.end())
-        {
-            const MIuint nThreadId = *it;
-            if (nThreadId == i)
-            {
-                bFound = true;
-                break;
-            }
-
-            // Next
-            ++it;
-        }
+        const MIuint threadIndexID = thread.GetIndexID();
+        const bool bFound = std::find(rSessionInfo.m_vecActiveThreadId.begin(), rSessionInfo.m_vecActiveThreadId.end(), threadIndexID) != rSessionInfo.m_vecActiveThreadId.end();
         if (!bFound)
         {
-            CMICmnLLDBDebugSessionInfo::Instance().m_vecActiveThreadId.push_back(i);
+            rSessionInfo.m_vecActiveThreadId.push_back(threadIndexID);
 
             // Form MI "=thread-created,id=\"%d\",group-id=\"i1\""
-            const CMIUtilString strValue(CMIUtilString::Format("%d", thread.GetIndexID()));
+            const CMIUtilString strValue(CMIUtilString::Format("%d", threadIndexID));
             const CMICmnMIValueConst miValueConst(strValue);
             const CMICmnMIValueResult miValueResult("id", miValueConst);
             CMICmnMIOutOfBandRecord miOutOfBand(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated, miValueResult);
             const CMICmnMIValueConst miValueConst2("i1");
             const CMICmnMIValueResult miValueResult2("group-id", miValueConst2);
-            bOk = miOutOfBand.Add(miValueResult2);
+            bool bOk = miOutOfBand.Add(miValueResult2);
             bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBand);
             if (!bOk)
                 return MIstatus::failure;
         }
     }
 
     lldb::SBThread currentThread = sbProcess.GetSelectedThread();
     if (currentThread.IsValid())
     {
-        const MIuint threadId = currentThread.GetIndexID();
-        if (CMICmnLLDBDebugSessionInfo::Instance().m_currentSelectedThread != threadId)
+        const MIuint currentThreadIndexID = currentThread.GetIndexID();
+        if (rSessionInfo.m_currentSelectedThread != currentThreadIndexID)
         {
-            CMICmnLLDBDebugSessionInfo::Instance().m_currentSelectedThread = threadId;
+            rSessionInfo.m_currentSelectedThread = currentThreadIndexID;
 
             // Form MI "=thread-selected,id=\"%d\""
-            const CMIUtilString strValue(CMIUtilString::Format("%d", currentThread.GetIndexID()));
+            const CMIUtilString strValue(CMIUtilString::Format("%d", currentThreadIndexID));
             const CMICmnMIValueConst miValueConst(strValue);
             const CMICmnMIValueResult miValueResult("id", miValueConst);
             CMICmnMIOutOfBandRecord miOutOfBand(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, miValueResult);
             if (!MiOutOfBandRecordToStdout(miOutOfBand))
                 return MIstatus::failure;
         }
     }
 
     // Check for invalid (removed) threads
-    CMICmnLLDBDebugSessionInfo::VecActiveThreadId_t::const_iterator it = CMICmnLLDBDebugSessionInfo::Instance().m_vecActiveThreadId.begin();
-    while (it != CMICmnLLDBDebugSessionInfo::Instance().m_vecActiveThreadId.end())
+    CMICmnLLDBDebugSessionInfo::VecActiveThreadId_t::const_iterator it = rSessionInfo.m_vecActiveThreadId.begin();
+    while (it != rSessionInfo.m_vecActiveThreadId.end())
     {
-        const MIuint nThreadId = *it;
-        lldb::SBThread thread = sbProcess.GetThreadAtIndex(nThreadId);
+        const MIuint threadIndexID = *it;
+        lldb::SBThread thread = sbProcess.GetThreadByIndexID(threadIndexID);
         if (!thread.IsValid())
         {
             // Form MI "=thread-exited,id=\"%ld\",group-id=\"i1\""
-            const CMIUtilString strValue(CMIUtilString::Format("%ld", thread.GetIndexID()));
+            const CMIUtilString strValue(CMIUtilString::Format("%ld", threadIndexID));
             const CMICmnMIValueConst miValueConst(strValue);
             const CMICmnMIValueResult miValueResult("id", miValueConst);
             CMICmnMIOutOfBandRecord miOutOfBand(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, miValueResult);
             const CMICmnMIValueConst miValueConst2("i1");
             const CMICmnMIValueResult miValueResult2("group-id", miValueConst2);
-            bOk = miOutOfBand.Add(miValueResult2);
+            bool bOk = miOutOfBand.Add(miValueResult2);
             bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBand);
             if (!bOk)
                 return MIstatus::failure;
-        }
 
+            // Remove current thread from cache and get next
+            it = rSessionInfo.m_vecActiveThreadId.erase(it);
+        }
+        else
             // Next
             ++it;
     }
 
     return TextToStdout("(gdb)");
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Take a fully formed MI result record and send to the stdout stream.
 //          Also output to the MI Log file.