| //===-- MICmnLLDBDebuggerHandleEvents.cpp -----------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // Third party headers: |
| #include "lldb/API/SBAddress.h" |
| #include "lldb/API/SBEvent.h" |
| #include "lldb/API/SBProcess.h" |
| #include "lldb/API/SBBreakpoint.h" |
| #include "lldb/API/SBStream.h" |
| #include "lldb/API/SBTarget.h" |
| #include "lldb/API/SBThread.h" |
| #include "lldb/API/SBCommandInterpreter.h" |
| #include "lldb/API/SBCommandReturnObject.h" |
| #include "lldb/API/SBUnixSignals.h" |
| #ifdef _WIN32 |
| #include <io.h> // For the ::_access() |
| #else |
| #include <unistd.h> // For the ::access() |
| #endif // _WIN32 |
| |
| // In-house headers: |
| #include "MICmnLLDBDebuggerHandleEvents.h" |
| #include "MICmnResources.h" |
| #include "MICmnLog.h" |
| #include "MICmnLLDBDebugger.h" |
| #include "MICmnLLDBDebugSessionInfo.h" |
| #include "MICmnMIResultRecord.h" |
| #include "MICmnMIValueConst.h" |
| #include "MICmnMIValueList.h" |
| #include "MICmnMIOutOfBandRecord.h" |
| #include "MICmnStreamStdout.h" |
| #include "MICmnStreamStderr.h" |
| #include "MIUtilDebug.h" |
| #include "MIDriver.h" |
| #include "Platform.h" // for PATH_MAX |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: CMICmnLLDBDebuggerHandleEvents constructor. |
| // Type: Method. |
| // Args: None. |
| // Return: None. |
| // Throws: None. |
| //-- |
| CMICmnLLDBDebuggerHandleEvents::CMICmnLLDBDebuggerHandleEvents() |
| { |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: CMICmnLLDBDebuggerHandleEvents destructor. |
| // Type: Overridable. |
| // Args: None. |
| // Return: None. |
| // Throws: None. |
| //-- |
| CMICmnLLDBDebuggerHandleEvents::~CMICmnLLDBDebuggerHandleEvents() |
| { |
| Shutdown(); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Initialize resources for *this broadcaster object. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::Initialize() |
| { |
| m_clientUsageRefCnt++; |
| |
| if (m_bInitialized) |
| return MIstatus::success; |
| |
| m_bInitialized = MIstatus::success; |
| m_bSignalsInitialized = false; |
| m_SIGINT = 0; |
| m_SIGSTOP = 0; |
| m_SIGSEGV = 0; |
| m_SIGTRAP = 0; |
| |
| return m_bInitialized; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Release resources for *this broadcaster object. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::Shutdown() |
| { |
| if (--m_clientUsageRefCnt > 0) |
| return MIstatus::success; |
| |
| if (!m_bInitialized) |
| return MIstatus::success; |
| |
| m_bInitialized = false; |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Interpret the event object to ascertain the action to take or information to |
| // to form and put in a MI Out-of-band record object which is given to stdout. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // vrbHandledEvent - (W) True - event handled, false = not handled. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEvent(const lldb::SBEvent &vEvent, bool &vrbHandledEvent) |
| { |
| bool bOk = MIstatus::success; |
| vrbHandledEvent = false; |
| |
| if (lldb::SBProcess::EventIsProcessEvent(vEvent)) |
| { |
| vrbHandledEvent = true; |
| bOk = HandleEventSBProcess(vEvent); |
| } |
| else if (lldb::SBBreakpoint::EventIsBreakpointEvent(vEvent)) |
| { |
| vrbHandledEvent = true; |
| bOk = HandleEventSBBreakPoint(vEvent); |
| } |
| else if (lldb::SBThread::EventIsThreadEvent(vEvent)) |
| { |
| vrbHandledEvent = true; |
| bOk = HandleEventSBThread(vEvent); |
| } |
| else if (lldb::SBTarget::EventIsTargetEvent(vEvent)) |
| { |
| vrbHandledEvent = true; |
| bOk = HandleEventSBTarget(vEvent); |
| } |
| else if (lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent(vEvent)) |
| { |
| vrbHandledEvent = true; |
| bOk = HandleEventSBCommandInterpreter(vEvent); |
| } |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBProcess event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBProcess(const lldb::SBEvent &vEvent) |
| { |
| bool bOk = MIstatus::success; |
| |
| const char *pEventType = ""; |
| const MIuint nEventType = vEvent.GetType(); |
| switch (nEventType) |
| { |
| case lldb::SBProcess::eBroadcastBitInterrupt: |
| pEventType = "eBroadcastBitInterrupt"; |
| break; |
| case lldb::SBProcess::eBroadcastBitProfileData: |
| pEventType = "eBroadcastBitProfileData"; |
| break; |
| case lldb::SBProcess::eBroadcastBitStateChanged: |
| pEventType = "eBroadcastBitStateChanged"; |
| bOk = HandleProcessEventBroadcastBitStateChanged(vEvent); |
| break; |
| case lldb::SBProcess::eBroadcastBitSTDERR: |
| pEventType = "eBroadcastBitSTDERR"; |
| bOk = GetProcessStderr(); |
| break; |
| case lldb::SBProcess::eBroadcastBitSTDOUT: |
| pEventType = "eBroadcastBitSTDOUT"; |
| bOk = GetProcessStdout(); |
| break; |
| default: |
| { |
| const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBProcess", (MIuint)nEventType)); |
| SetErrorDescription(msg); |
| return MIstatus::failure; |
| } |
| } |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SB Process event occurred: %s", pEventType)); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBBreakpoint event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBBreakPoint(const lldb::SBEvent &vEvent) |
| { |
| bool bOk = MIstatus::success; |
| |
| const char *pEventType = ""; |
| const lldb::BreakpointEventType eEvent = lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent(vEvent); |
| switch (eEvent) |
| { |
| case lldb::eBreakpointEventTypeThreadChanged: |
| pEventType = "eBreakpointEventTypeThreadChanged"; |
| break; |
| case lldb::eBreakpointEventTypeLocationsRemoved: |
| pEventType = "eBreakpointEventTypeLocationsRemoved"; |
| break; |
| case lldb::eBreakpointEventTypeInvalidType: |
| pEventType = "eBreakpointEventTypeInvalidType"; |
| break; |
| case lldb::eBreakpointEventTypeLocationsAdded: |
| pEventType = "eBreakpointEventTypeLocationsAdded"; |
| bOk = HandleEventSBBreakpointLocationsAdded(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeAdded: |
| pEventType = "eBreakpointEventTypeAdded"; |
| bOk = HandleEventSBBreakpointAdded(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeRemoved: |
| pEventType = "eBreakpointEventTypeRemoved"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeLocationsResolved: |
| pEventType = "eBreakpointEventTypeLocationsResolved"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeEnabled: |
| pEventType = "eBreakpointEventTypeEnabled"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeDisabled: |
| pEventType = "eBreakpointEventTypeDisabled"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeCommandChanged: |
| pEventType = "eBreakpointEventTypeCommandChanged"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeConditionChanged: |
| pEventType = "eBreakpointEventTypeConditionChanged"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| case lldb::eBreakpointEventTypeIgnoreChanged: |
| pEventType = "eBreakpointEventTypeIgnoreChanged"; |
| bOk = HandleEventSBBreakpointCmn(vEvent); |
| break; |
| } |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SB Breakpoint event occurred: %s", pEventType)); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBBreakpoint event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBBreakpointLocationsAdded(const lldb::SBEvent &vEvent) |
| { |
| const MIuint nLoc = lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent(vEvent); |
| if (nLoc == 0) |
| return MIstatus::success; |
| |
| lldb::SBBreakpoint brkPt = lldb::SBBreakpoint::GetBreakpointFromEvent(vEvent); |
| const CMIUtilString plural((nLoc == 1) ? "" : "s"); |
| const CMIUtilString msg(CMIUtilString::Format("%d location%s added to breakpoint %d", nLoc, plural.c_str(), brkPt.GetID())); |
| |
| return TextToStdout(msg); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBBreakpoint event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBBreakpointCmn(const lldb::SBEvent &vEvent) |
| { |
| lldb::SBBreakpoint brkPt = lldb::SBBreakpoint::GetBreakpointFromEvent(vEvent); |
| if (!brkPt.IsValid()) |
| return MIstatus::success; |
| |
| CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); |
| CMICmnLLDBDebugSessionInfo::SBrkPtInfo sBrkPtInfo; |
| if (!rSessionInfo.GetBrkPtInfo(brkPt, sBrkPtInfo)) |
| { |
| SetErrorDescription( |
| CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_BRKPT_INFO_GET), "HandleEventSBBreakpointCmn()", brkPt.GetID())); |
| return MIstatus::failure; |
| } |
| |
| // CODETAG_LLDB_BREAKPOINT_CREATION |
| // This is in a worker thread |
| // Add more breakpoint information or overwrite existing information |
| CMICmnLLDBDebugSessionInfo::SBrkPtInfo sBrkPtInfoRec; |
| if (!rSessionInfo.RecordBrkPtInfoGet(brkPt.GetID(), sBrkPtInfoRec)) |
| { |
| SetErrorDescription( |
| CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_BRKPT_NOTFOUND), "HandleEventSBBreakpointCmn()", brkPt.GetID())); |
| return MIstatus::failure; |
| } |
| sBrkPtInfo.m_bDisp = sBrkPtInfoRec.m_bDisp; |
| sBrkPtInfo.m_bEnabled = brkPt.IsEnabled(); |
| sBrkPtInfo.m_bHaveArgOptionThreadGrp = false; |
| sBrkPtInfo.m_strOptThrdGrp = ""; |
| sBrkPtInfo.m_nTimes = brkPt.GetHitCount(); |
| sBrkPtInfo.m_strOrigLoc = sBrkPtInfoRec.m_strOrigLoc; |
| sBrkPtInfo.m_nIgnore = sBrkPtInfoRec.m_nIgnore; |
| sBrkPtInfo.m_bPending = sBrkPtInfoRec.m_bPending; |
| sBrkPtInfo.m_bCondition = sBrkPtInfoRec.m_bCondition; |
| sBrkPtInfo.m_strCondition = sBrkPtInfoRec.m_strCondition; |
| sBrkPtInfo.m_bBrkPtThreadId = sBrkPtInfoRec.m_bBrkPtThreadId; |
| sBrkPtInfo.m_nBrkPtThreadId = sBrkPtInfoRec.m_nBrkPtThreadId; |
| |
| // MI print "=breakpoint-modified,bkpt={number=\"%d\",type=\"breakpoint\",disp=\"%s\",enabled=\"%c\",addr=\"0x%016" PRIx64 "\", |
| // func=\"%s\",file=\"%s\",fullname=\"%s/%s\",line=\"%d\",times=\"%d\",original-location=\"%s\"}" |
| CMICmnMIValueTuple miValueTuple; |
| if (!rSessionInfo.MIResponseFormBrkPtInfo(sBrkPtInfo, miValueTuple)) |
| { |
| SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_FORM_MI_RESPONSE), "HandleEventSBBreakpointCmn()")); |
| return MIstatus::failure; |
| } |
| |
| const CMICmnMIValueResult miValueResultC("bkpt", miValueTuple); |
| const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, miValueResultC); |
| bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBBreakpoint added event. |
| // Add more breakpoint information or overwrite existing information. |
| // Normally a break point session info objects exists by now when an MI command |
| // was issued to insert a break so the retrieval would normally always succeed |
| // however should a user type "b main" into a console then LLDB will create a |
| // breakpoint directly, hence no MI command, hence no previous record of the |
| // breakpoint so RecordBrkPtInfoGet() will fail. We still get the event though |
| // so need to create a breakpoint info object here and send appropriate MI |
| // response. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBBreakpointAdded(const lldb::SBEvent &vEvent) |
| { |
| lldb::SBBreakpoint brkPt = lldb::SBBreakpoint::GetBreakpointFromEvent(vEvent); |
| if (!brkPt.IsValid()) |
| return MIstatus::success; |
| |
| CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); |
| CMICmnLLDBDebugSessionInfo::SBrkPtInfo sBrkPtInfo; |
| if (!rSessionInfo.GetBrkPtInfo(brkPt, sBrkPtInfo)) |
| { |
| SetErrorDescription( |
| CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_BRKPT_INFO_GET), "HandleEventSBBreakpointAdded()", brkPt.GetID())); |
| return MIstatus::failure; |
| } |
| |
| // CODETAG_LLDB_BREAKPOINT_CREATION |
| // This is in a worker thread |
| CMICmnLLDBDebugSessionInfo::SBrkPtInfo sBrkPtInfoRec; |
| const bool bBrkPtExistAlready = rSessionInfo.RecordBrkPtInfoGet(brkPt.GetID(), sBrkPtInfoRec); |
| if (bBrkPtExistAlready) |
| { |
| // Update breakpoint information object |
| sBrkPtInfo.m_bDisp = sBrkPtInfoRec.m_bDisp; |
| sBrkPtInfo.m_bEnabled = brkPt.IsEnabled(); |
| sBrkPtInfo.m_bHaveArgOptionThreadGrp = false; |
| sBrkPtInfo.m_strOptThrdGrp.clear(); |
| sBrkPtInfo.m_nTimes = brkPt.GetHitCount(); |
| sBrkPtInfo.m_strOrigLoc = sBrkPtInfoRec.m_strOrigLoc; |
| sBrkPtInfo.m_nIgnore = sBrkPtInfoRec.m_nIgnore; |
| sBrkPtInfo.m_bPending = sBrkPtInfoRec.m_bPending; |
| sBrkPtInfo.m_bCondition = sBrkPtInfoRec.m_bCondition; |
| sBrkPtInfo.m_strCondition = sBrkPtInfoRec.m_strCondition; |
| sBrkPtInfo.m_bBrkPtThreadId = sBrkPtInfoRec.m_bBrkPtThreadId; |
| sBrkPtInfo.m_nBrkPtThreadId = sBrkPtInfoRec.m_nBrkPtThreadId; |
| } |
| else |
| { |
| // Create a breakpoint information object |
| sBrkPtInfo.m_bDisp = brkPt.IsOneShot(); |
| sBrkPtInfo.m_bEnabled = brkPt.IsEnabled(); |
| sBrkPtInfo.m_bHaveArgOptionThreadGrp = false; |
| sBrkPtInfo.m_strOptThrdGrp.clear(); |
| sBrkPtInfo.m_strOrigLoc = CMIUtilString::Format("%s:%d", sBrkPtInfo.m_fileName.c_str(), sBrkPtInfo.m_nLine); |
| sBrkPtInfo.m_nIgnore = brkPt.GetIgnoreCount(); |
| sBrkPtInfo.m_bPending = false; |
| const char *pStrCondition = brkPt.GetCondition(); |
| sBrkPtInfo.m_bCondition = (pStrCondition != nullptr) ? true : false; |
| sBrkPtInfo.m_strCondition = (pStrCondition != nullptr) ? pStrCondition : "??"; |
| sBrkPtInfo.m_bBrkPtThreadId = (brkPt.GetThreadID() != 0) ? true : false; |
| sBrkPtInfo.m_nBrkPtThreadId = brkPt.GetThreadID(); |
| } |
| |
| CMICmnMIValueTuple miValueTuple; |
| if (!rSessionInfo.MIResponseFormBrkPtInfo(sBrkPtInfo, miValueTuple)) |
| { |
| SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_FORM_MI_RESPONSE), "HandleEventSBBreakpointAdded()")); |
| return MIstatus::failure; |
| } |
| |
| bool bOk = MIstatus::success; |
| if (bBrkPtExistAlready) |
| { |
| // MI print |
| // "=breakpoint-modified,bkpt={number=\"%d\",type=\"breakpoint\",disp=\"%s\",enabled=\"%c\",addr=\"0x%016" PRIx64 "\",func=\"%s\",file=\"%s\",fullname=\"%s/%s\",line=\"%d\",times=\"%d\",original-location=\"%s\"}" |
| const CMICmnMIValueResult miValueResult("bkpt", miValueTuple); |
| const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, miValueResult); |
| bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| } |
| else |
| { |
| // CODETAG_LLDB_BRKPT_ID_MAX |
| if (brkPt.GetID() > (lldb::break_id_t)rSessionInfo.m_nBrkPointCntMax) |
| { |
| SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_BRKPT_CNT_EXCEEDED), "HandleEventSBBreakpointAdded()", |
| rSessionInfo.m_nBrkPointCntMax, sBrkPtInfo.m_id)); |
| return MIstatus::failure; |
| } |
| if (!rSessionInfo.RecordBrkPtInfo(brkPt.GetID(), sBrkPtInfo)) |
| { |
| SetErrorDescription( |
| CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_BRKPT_INFO_SET), "HandleEventSBBreakpointAdded()", sBrkPtInfo.m_id)); |
| return MIstatus::failure; |
| } |
| |
| // MI print |
| // "=breakpoint-created,bkpt={number=\"%d\",type=\"breakpoint\",disp=\"%s\",enabled=\"%c\",addr=\"0x%016" PRIx64 "\",func=\"%s\",file=\"%s\",fullname=\"%s/%s\",line=\"%d\",times=\"%d\",original-location=\"%s\"}" |
| const CMICmnMIValueResult miValueResult("bkpt", miValueTuple); |
| const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointCreated, miValueResult); |
| bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| } |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBThread event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBThread(const lldb::SBEvent &vEvent) |
| { |
| if (!ChkForStateChanges()) |
| return MIstatus::failure; |
| |
| bool bOk = MIstatus::success; |
| const char *pEventType = ""; |
| const MIuint nEventType = vEvent.GetType(); |
| switch (nEventType) |
| { |
| case lldb::SBThread::eBroadcastBitStackChanged: |
| pEventType = "eBroadcastBitStackChanged"; |
| bOk = HandleEventSBThreadBitStackChanged(vEvent); |
| break; |
| case lldb::SBThread::eBroadcastBitThreadSuspended: |
| pEventType = "eBroadcastBitThreadSuspended"; |
| bOk = HandleEventSBThreadSuspended(vEvent); |
| break; |
| case lldb::SBThread::eBroadcastBitThreadResumed: |
| pEventType = "eBroadcastBitThreadResumed"; |
| break; |
| case lldb::SBThread::eBroadcastBitSelectedFrameChanged: |
| pEventType = "eBroadcastBitSelectedFrameChanged"; |
| break; |
| case lldb::SBThread::eBroadcastBitThreadSelected: |
| pEventType = "eBroadcastBitThreadSelected"; |
| break; |
| default: |
| { |
| const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBThread", (MIuint)nEventType)); |
| SetErrorDescription(msg); |
| return MIstatus::failure; |
| } |
| } |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SBThread event occurred: %s", pEventType)); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBThread event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBThreadSuspended(const lldb::SBEvent &vEvent) |
| { |
| lldb::SBThread thread = lldb::SBThread::GetThreadFromEvent(vEvent); |
| if (!thread.IsValid()) |
| return MIstatus::success; |
| |
| const lldb::StopReason eStopReason = thread.GetStopReason(); |
| if (eStopReason != lldb::eStopReasonSignal) |
| return MIstatus::success; |
| |
| // MI print "@thread=%d,signal=%lld" |
| const MIuint64 nId = thread.GetStopReasonDataAtIndex(0); |
| const CMIUtilString strThread(CMIUtilString::Format("%d", thread.GetThreadID())); |
| const CMICmnMIValueConst miValueConst(strThread); |
| const CMICmnMIValueResult miValueResult("thread", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Thread, miValueResult); |
| const CMIUtilString strSignal(CMIUtilString::Format("%lld", nId)); |
| const CMICmnMIValueConst miValueConst2(strSignal); |
| const CMICmnMIValueResult miValueResult2("signal", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| return MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBThread event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBThreadBitStackChanged(const lldb::SBEvent &vEvent) |
| { |
| lldb::SBThread thread = lldb::SBThread::GetThreadFromEvent(vEvent); |
| if (!thread.IsValid()) |
| return MIstatus::success; |
| |
| lldb::SBStream streamOut; |
| const bool bOk = thread.GetStatus(streamOut); |
| return bOk && TextToStdout(streamOut.GetData()); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBTarget event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functional succeeded. |
| // MIstatus::failure - Functional failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBTarget(const lldb::SBEvent &vEvent) |
| { |
| if (!ChkForStateChanges()) |
| return MIstatus::failure; |
| |
| bool bOk = MIstatus::success; |
| const char *pEventType = ""; |
| const MIuint nEventType = vEvent.GetType(); |
| switch (nEventType) |
| { |
| case lldb::SBTarget::eBroadcastBitBreakpointChanged: |
| pEventType = "eBroadcastBitBreakpointChanged"; |
| break; |
| case lldb::SBTarget::eBroadcastBitModulesLoaded: |
| pEventType = "eBroadcastBitModulesLoaded"; |
| bOk = HandleTargetEventBroadcastBitModulesLoaded(vEvent); |
| break; |
| case lldb::SBTarget::eBroadcastBitModulesUnloaded: |
| pEventType = "eBroadcastBitModulesUnloaded"; |
| bOk = HandleTargetEventBroadcastBitModulesUnloaded(vEvent); |
| break; |
| case lldb::SBTarget::eBroadcastBitWatchpointChanged: |
| pEventType = "eBroadcastBitWatchpointChanged"; |
| break; |
| case lldb::SBTarget::eBroadcastBitSymbolsLoaded: |
| pEventType = "eBroadcastBitSymbolsLoaded"; |
| break; |
| default: |
| { |
| const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBTarget", (MIuint)nEventType)); |
| SetErrorDescription(msg); |
| return MIstatus::failure; |
| } |
| } |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SBTarget event occurred: %s", pEventType)); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Print to stdout "=library-loaded,id=\"%s\",target-name=\"%s\",host-name=\"%s\",symbols-loaded="%d"[,symbols-path=\"%s\"],loaded_addr=\"0x%016" PRIx64"\"" |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Function succeeded. |
| // MIstatus::failure - Function failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleTargetEventBroadcastBitModulesLoaded(const lldb::SBEvent &vEvent) |
| { |
| bool bOk = MIstatus::failure; |
| const MIuint nSize = lldb::SBTarget::GetNumModulesFromEvent(vEvent); |
| for (MIuint nIndex = 0; nIndex < nSize; ++nIndex) |
| { |
| const lldb::SBModule sbModule = lldb::SBTarget::GetModuleAtIndexFromEvent(nIndex, vEvent); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleLoaded); |
| const bool bWithExtraFields = true; |
| bOk = MiHelpGetModuleInfo(sbModule, bWithExtraFields, miOutOfBandRecord); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| if (!bOk) |
| break; |
| } |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Print to stdout "=library-unloaded,id=\"%s\",target-name=\"%s\",host-name=\"%s\",symbols-loaded="%d"[,symbols-path=\"%s\"],loaded_addr=\"0x%016" PRIx64"\"" |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Function succeeded. |
| // MIstatus::failure - Function failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleTargetEventBroadcastBitModulesUnloaded(const lldb::SBEvent &vEvent) |
| { |
| bool bOk = MIstatus::failure; |
| const MIuint nSize = lldb::SBTarget::GetNumModulesFromEvent(vEvent); |
| for (MIuint nIndex = 0; nIndex < nSize; ++nIndex) |
| { |
| const lldb::SBModule sbModule = lldb::SBTarget::GetModuleAtIndexFromEvent(nIndex, vEvent); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetModuleUnloaded); |
| const bool bWithExtraFields = false; |
| bOk = MiHelpGetModuleInfo(sbModule, bWithExtraFields, miOutOfBandRecord); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| if (!bOk) |
| break; |
| } |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Build module information for =library-loaded/=library-unloaded: "id=\"%s\",target-name=\"%s\",host-name=\"%s\",symbols-loaded="%d"[,symbols-path=\"%s\"],loaded_addr=\"0x%016" PRIx64"\"" |
| // Type: Method. |
| // Args: vwrMiValueList - (W) MI value list object. |
| // Return: MIstatus::success - Function succeeded. |
| // MIstatus::failure - Function failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::MiHelpGetModuleInfo(const lldb::SBModule &vModule, const bool vbWithExtraFields, |
| CMICmnMIOutOfBandRecord &vwrMiOutOfBandRecord) |
| { |
| bool bOk = MIstatus::success; |
| |
| // First, build standard fields: |
| // Build "id" field |
| std::unique_ptr<char[]> apPath(new char[PATH_MAX]); |
| vModule.GetFileSpec().GetPath(apPath.get(), PATH_MAX); |
| const CMIUtilString strTargetPath(apPath.get()); |
| const CMICmnMIValueConst miValueConst(strTargetPath.AddSlashes()); |
| const CMICmnMIValueResult miValueResult("id", miValueConst); |
| vwrMiOutOfBandRecord.Add(miValueResult); |
| // Build "target-name" field |
| const CMICmnMIValueConst miValueConst2(strTargetPath.AddSlashes()); |
| const CMICmnMIValueResult miValueResult2("target-name", miValueConst2); |
| vwrMiOutOfBandRecord.Add(miValueResult2); |
| // Build "host-name" field |
| vModule.GetPlatformFileSpec().GetPath(apPath.get(), PATH_MAX); |
| const CMIUtilString strHostPath(apPath.get()); |
| const CMICmnMIValueConst miValueConst3(strHostPath.AddSlashes()); |
| const CMICmnMIValueResult miValueResult3("host-name", miValueConst3); |
| vwrMiOutOfBandRecord.Add(miValueResult3); |
| |
| // Then build extra fields if needed: |
| if (vbWithExtraFields) |
| { |
| // Build "symbols-loaded" field |
| vModule.GetSymbolFileSpec().GetPath(apPath.get(), PATH_MAX); |
| const CMIUtilString strSymbolsPath(apPath.get()); |
| const bool bSymbolsLoaded = !CMIUtilString::Compare(strHostPath, strSymbolsPath); |
| const CMICmnMIValueConst miValueConst4(CMIUtilString::Format("%d", bSymbolsLoaded)); |
| const CMICmnMIValueResult miValueResult4("symbols-loaded", miValueConst4); |
| vwrMiOutOfBandRecord.Add(miValueResult4); |
| // Build "symbols-path" field |
| if (bSymbolsLoaded) |
| { |
| const CMICmnMIValueConst miValueConst5(strSymbolsPath.AddSlashes()); |
| const CMICmnMIValueResult miValueResult5("symbols-path", miValueConst5); |
| vwrMiOutOfBandRecord.Add(miValueResult5); |
| } |
| // Build "loaded_addr" field |
| lldb::SBAddress sbAddress(vModule.GetObjectFileHeaderAddress()); |
| CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); |
| const lldb::addr_t nLoadAddress(sbAddress.GetLoadAddress(rSessionInfo.GetTarget())); |
| const CMIUtilString strLoadedAddr(nLoadAddress != LLDB_INVALID_ADDRESS ? |
| CMIUtilString::Format("0x%016" PRIx64, nLoadAddress) : "-"); |
| const CMICmnMIValueConst miValueConst6(strLoadedAddr); |
| const CMICmnMIValueResult miValueResult6("loaded_addr", miValueConst6); |
| vwrMiOutOfBandRecord.Add(miValueResult6); |
| |
| // Build "size" field |
| lldb::SBSection sbSection = sbAddress.GetSection(); |
| const CMIUtilString strSize(CMIUtilString::Format("%" PRIu64, sbSection.GetByteSize())); |
| const CMICmnMIValueConst miValueConst7(strSize); |
| const CMICmnMIValueResult miValueResult7("size", miValueConst7); |
| vwrMiOutOfBandRecord.Add(miValueResult7); |
| } |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle a LLDB SBCommandInterpreter event. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB command interpreter event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleEventSBCommandInterpreter(const lldb::SBEvent &vEvent) |
| { |
| // This function is not used |
| // *** This function is under development |
| |
| const char *pEventType = ""; |
| const MIuint nEventType = vEvent.GetType(); |
| switch (nEventType) |
| { |
| case lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit: |
| pEventType = "eBroadcastBitThreadShouldExit"; |
| // ToDo: IOR: Reminder to maybe handle this here |
| // const MIuint nEventType = event.GetType(); |
| // if (nEventType & lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit) |
| //{ |
| // m_pClientDriver->SetExitApplicationFlag(); |
| // vrbYesExit = true; |
| // return MIstatus::success; |
| //} |
| break; |
| case lldb::SBCommandInterpreter::eBroadcastBitResetPrompt: |
| pEventType = "eBroadcastBitResetPrompt"; |
| break; |
| case lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived: |
| { |
| pEventType = "eBroadcastBitQuitCommandReceived"; |
| const bool bForceExit = true; |
| CMICmnLLDBDebugger::Instance().GetDriver().SetExitApplicationFlag(bForceExit); |
| break; |
| } |
| case lldb::SBCommandInterpreter::eBroadcastBitAsynchronousOutputData: |
| pEventType = "eBroadcastBitAsynchronousOutputData"; |
| break; |
| case lldb::SBCommandInterpreter::eBroadcastBitAsynchronousErrorData: |
| pEventType = "eBroadcastBitAsynchronousErrorData"; |
| break; |
| default: |
| { |
| const CMIUtilString msg( |
| CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBCommandInterpreter", (MIuint)nEventType)); |
| SetErrorDescription(msg); |
| return MIstatus::failure; |
| } |
| } |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SBCommandInterpreter event occurred: %s", pEventType)); |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Handle SBProcess event eBroadcastBitStateChanged. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB event object. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent) |
| { |
| // Make sure the program hasn't been auto-restarted: |
| if (lldb::SBProcess::GetRestartedFromEvent(vEvent)) |
| return MIstatus::success; |
| |
| bool bOk = ChkForStateChanges(); |
| bOk = bOk && GetProcessStdout(); |
| bOk = bOk && GetProcessStderr(); |
| if (!bOk) |
| return MIstatus::failure; |
| |
| // Something changed in the process; get the event and report the process's current |
| // status and location |
| const lldb::StateType eEventState = lldb::SBProcess::GetStateFromEvent(vEvent); |
| if (eEventState == lldb::eStateInvalid) |
| return MIstatus::success; |
| |
| lldb::SBProcess process = lldb::SBProcess::GetProcessFromEvent(vEvent); |
| if (!process.IsValid()) |
| { |
| const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_PROCESS_INVALID), "SBProcess", |
| "HandleProcessEventBroadcastBitStateChanged()")); |
| SetErrorDescription(msg); |
| return MIstatus::failure; |
| } |
| |
| bool bShouldBrk = true; |
| const char *pEventType = ""; |
| switch (eEventState) |
| { |
| case lldb::eStateUnloaded: |
| pEventType = "eStateUnloaded"; |
| break; |
| case lldb::eStateConnected: |
| pEventType = "eStateConnected"; |
| break; |
| case lldb::eStateAttaching: |
| pEventType = "eStateAttaching"; |
| break; |
| case lldb::eStateLaunching: |
| pEventType = "eStateLaunching"; |
| break; |
| case lldb::eStateStopped: |
| pEventType = "eStateStopped"; |
| bOk = HandleProcessEventStateStopped(vEvent, bShouldBrk); |
| if (bShouldBrk) |
| break; |
| case lldb::eStateCrashed: |
| case lldb::eStateSuspended: |
| pEventType = "eStateSuspended"; |
| bOk = HandleProcessEventStateSuspended(vEvent); |
| break; |
| case lldb::eStateRunning: |
| pEventType = "eStateRunning"; |
| bOk = HandleProcessEventStateRunning(); |
| break; |
| case lldb::eStateStepping: |
| pEventType = "eStateStepping"; |
| break; |
| case lldb::eStateDetached: |
| pEventType = "eStateDetached"; |
| break; |
| case lldb::eStateExited: |
| // Don't exit from lldb-mi here. We should be able to re-run target. |
| pEventType = "eStateExited"; |
| bOk = HandleProcessEventStateExited(); |
| break; |
| default: |
| { |
| const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBProcess BroadcastBitStateChanged", |
| (MIuint)eEventState)); |
| SetErrorDescription(msg); |
| return MIstatus::failure; |
| } |
| } |
| |
| // ToDo: Remove when finished coding application |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SB Process event BroadcastBitStateChanged occurred: %s", pEventType)); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Asynchronous event handler for LLDB Process state suspended. |
| // Type: Method. |
| // Args: vEvent - (R) An LLDB event object. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateSuspended(const lldb::SBEvent &vEvent) |
| { |
| bool bOk = MIstatus::success; |
| lldb::SBDebugger &rDebugger = CMICmnLLDBDebugSessionInfo::Instance().GetDebugger(); |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| lldb::SBTarget target = sbProcess.GetTarget(); |
| if (rDebugger.GetSelectedTarget() == target) |
| { |
| if (!UpdateSelectedThread()) |
| return MIstatus::failure; |
| |
| lldb::SBCommandReturnObject result; |
| const lldb::ReturnStatus status = rDebugger.GetCommandInterpreter().HandleCommand("process status", result, false); |
| MIunused(status); |
| bOk = TextToStderr(result.GetError()); |
| bOk = bOk && TextToStdout(result.GetOutput()); |
| } |
| else |
| { |
| lldb::SBStream streamOut; |
| const MIuint nTargetIndex = rDebugger.GetIndexOfTarget(target); |
| if (nTargetIndex != UINT_MAX) |
| streamOut.Printf("Target %d: (", nTargetIndex); |
| else |
| streamOut.Printf("Target <unknown index>: ("); |
| target.GetDescription(streamOut, lldb::eDescriptionLevelBrief); |
| streamOut.Printf(") stopped.\n"); |
| bOk = TextToStdout(streamOut.GetData()); |
| } |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Print to stdout MI formatted text to indicate process stopped. |
| // Type: Method. |
| // Args: vwrbShouldBrk - (W) True = Yes break, false = do not. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateStopped(const lldb::SBEvent &vrEvent, bool &vwrbShouldBrk) |
| { |
| if (!UpdateSelectedThread()) |
| return MIstatus::failure; |
| |
| const char *pEventType = ""; |
| bool bOk = MIstatus::success; |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| const lldb::StopReason eStoppedReason = sbProcess.GetSelectedThread().GetStopReason(); |
| switch (eStoppedReason) |
| { |
| case lldb::eStopReasonInvalid: |
| pEventType = "eStopReasonInvalid"; |
| vwrbShouldBrk = false; |
| break; |
| case lldb::eStopReasonNone: |
| pEventType = "eStopReasonNone"; |
| break; |
| case lldb::eStopReasonTrace: |
| pEventType = "eStopReasonTrace"; |
| bOk = HandleProcessEventStopReasonTrace(); |
| break; |
| case lldb::eStopReasonBreakpoint: |
| pEventType = "eStopReasonBreakpoint"; |
| bOk = HandleProcessEventStopReasonBreakpoint(); |
| break; |
| case lldb::eStopReasonWatchpoint: |
| pEventType = "eStopReasonWatchpoint"; |
| break; |
| case lldb::eStopReasonSignal: |
| pEventType = "eStopReasonSignal"; |
| bOk = HandleProcessEventStopSignal(vrEvent); |
| break; |
| case lldb::eStopReasonException: |
| pEventType = "eStopReasonException"; |
| bOk = HandleProcessEventStopException(); |
| break; |
| case lldb::eStopReasonExec: |
| pEventType = "eStopReasonExec"; |
| break; |
| case lldb::eStopReasonPlanComplete: |
| pEventType = "eStopReasonPlanComplete"; |
| bOk = HandleProcessEventStopReasonTrace(); |
| break; |
| case lldb::eStopReasonThreadExiting: |
| pEventType = "eStopReasonThreadExiting"; |
| break; |
| case lldb::eStopReasonInstrumentation: |
| pEventType = "eStopReasonInstrumentation"; |
| break; |
| } |
| |
| // ToDo: Remove when finished coding application |
| m_pLog->WriteLog(CMIUtilString::Format("##### An SB Process event stop state occurred: %s", pEventType)); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Asynchronous event handler for LLDB Process stop signal. |
| // Type: Method. |
| // Args: vrEvent - (R) An LLDB broadcast event. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopSignal(const lldb::SBEvent &vrEvent) |
| { |
| bool bOk = MIstatus::success; |
| |
| InitializeSignals (); |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| const MIuint64 nStopReason = sbProcess.GetSelectedThread().GetStopReasonDataAtIndex(0); |
| const bool bInterrupted = lldb::SBProcess::GetInterruptedFromEvent(vrEvent); |
| if (nStopReason == m_SIGINT || (nStopReason == m_SIGSTOP && bInterrupted)) |
| { |
| // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\",frame={%s},thread-id=\"%d\",stopped-threads=\"all\"" |
| const CMICmnMIValueConst miValueConst("signal-received"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueConst miValueConst2("SIGINT"); |
| const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| const CMICmnMIValueConst miValueConst3("Interrupt"); |
| const CMICmnMIValueResult miValueResult3("signal-meaning", miValueConst3); |
| miOutOfBandRecord.Add(miValueResult3); |
| CMICmnMIValueTuple miValueTuple; |
| bOk = bOk && MiHelpGetCurrentThreadFrame(miValueTuple); |
| const CMICmnMIValueResult miValueResult4("frame", miValueTuple); |
| miOutOfBandRecord.Add(miValueResult4); |
| const CMIUtilString strThreadId(CMIUtilString::Format("%" PRIu32, sbProcess.GetSelectedThread().GetIndexID())); |
| const CMICmnMIValueConst miValueConst5(strThreadId); |
| const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5); |
| miOutOfBandRecord.Add(miValueResult5); |
| const CMICmnMIValueConst miValueConst6("all"); |
| const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6); |
| miOutOfBandRecord.Add(miValueResult6); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| } |
| else if (nStopReason == m_SIGSTOP) |
| { |
| // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGSTOP\",signal-meaning=\"Stop\",frame={%s},thread-id=\"%d\",stopped-threads=\"all\"" |
| const CMICmnMIValueConst miValueConst("signal-received"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueConst miValueConst2("SIGSTOP"); |
| const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| const CMICmnMIValueConst miValueConst3("Stop"); |
| const CMICmnMIValueResult miValueResult3("signal-meaning", miValueConst3); |
| miOutOfBandRecord.Add(miValueResult3); |
| CMICmnMIValueTuple miValueTuple; |
| bOk = bOk && MiHelpGetCurrentThreadFrame(miValueTuple); |
| const CMICmnMIValueResult miValueResult4("frame", miValueTuple); |
| miOutOfBandRecord.Add(miValueResult4); |
| const CMIUtilString strThreadId(CMIUtilString::Format("%" PRIu32, sbProcess.GetSelectedThread().GetIndexID())); |
| const CMICmnMIValueConst miValueConst5(strThreadId); |
| const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5); |
| miOutOfBandRecord.Add(miValueResult5); |
| const CMICmnMIValueConst miValueConst6("all"); |
| const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6); |
| miOutOfBandRecord.Add(miValueResult6); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| } |
| else if (nStopReason == m_SIGSEGV) |
| { |
| // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGSEGV\",signal-meaning=\"Segmentation fault\",thread-id=\"%d\",frame={%s}" |
| const CMICmnMIValueConst miValueConst("signal-received"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueConst miValueConst2("SIGSEGV"); |
| const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| const CMICmnMIValueConst miValueConst3("Segmentation fault"); |
| const CMICmnMIValueResult miValueResult3("signal-meaning", miValueConst3); |
| miOutOfBandRecord.Add(miValueResult3); |
| CMICmnMIValueTuple miValueTuple; |
| bOk = bOk && MiHelpGetCurrentThreadFrame(miValueTuple); |
| const CMICmnMIValueResult miValueResult4("frame", miValueTuple); |
| miOutOfBandRecord.Add(miValueResult4); |
| const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbProcess.GetSelectedThread().GetIndexID())); |
| const CMICmnMIValueConst miValueConst5(strThreadId); |
| const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5); |
| miOutOfBandRecord.Add(miValueResult5); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| // Note no "(gdb)" output here |
| } |
| else if (nStopReason == m_SIGTRAP) |
| { |
| lldb::SBThread thread = sbProcess.GetSelectedThread(); |
| const MIuint nFrames = thread.GetNumFrames(); |
| if (nFrames > 0) |
| { |
| lldb::SBFrame frame = thread.GetFrameAtIndex(0); |
| const char *pFnName = frame.GetFunctionName(); |
| if (pFnName != nullptr) |
| { |
| const CMIUtilString fnName = CMIUtilString(pFnName); |
| static const CMIUtilString threadCloneFn = CMIUtilString("__pthread_clone"); |
| |
| if (CMIUtilString::Compare(threadCloneFn, fnName)) |
| { |
| if (sbProcess.IsValid()) |
| sbProcess.Continue(); |
| } |
| } |
| } |
| } |
| else |
| { |
| // MI print "*stopped,reason=\"signal-received\",signal-name=\"%s\",thread-id=\"%d\",stopped-threads=\"all\"" |
| // MI print "*stopped,reason=\"signal-received\",signal=\"%d\",thread-id=\"%d\",stopped-threads=\"all\"" |
| const CMICmnMIValueConst miValueConst("signal-received"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| lldb::SBUnixSignals sbUnixSignals = sbProcess.GetUnixSignals(); |
| const char *pSignal = sbUnixSignals.GetSignalAsCString(nStopReason); |
| if (pSignal) |
| { |
| const CMICmnMIValueConst miValueConst2(pSignal); |
| const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| } |
| else |
| { |
| const CMIUtilString strSignal(CMIUtilString::Format("%" PRIu64, nStopReason)); |
| const CMICmnMIValueConst miValueConst2(strSignal); |
| const CMICmnMIValueResult miValueResult2("signal", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| } |
| const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbProcess.GetSelectedThread().GetIndexID())); |
| const CMICmnMIValueConst miValueConst3(strThreadId); |
| const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3); |
| miOutOfBandRecord.Add(miValueResult3); |
| const CMICmnMIValueConst miValueConst4("all"); |
| const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4); |
| miOutOfBandRecord.Add(miValueResult4); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| } |
| 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() |
| { |
| const lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| lldb::SBThread sbThread = sbProcess.GetSelectedThread(); |
| const size_t nStopDescriptionLen = sbThread.GetStopDescription(nullptr, 0); |
| std::unique_ptr<char[]> apStopDescription(new char[nStopDescriptionLen]); |
| sbThread.GetStopDescription(apStopDescription.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(apStopDescription.get()); |
| const CMICmnMIValueConst miValueConst2(strReason); |
| const CMICmnMIValueResult miValueResult2("exception", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbThread.GetIndexID())); |
| const CMICmnMIValueConst miValueConst3(strThreadId); |
| const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3); |
| miOutOfBandRecord.Add(miValueResult3); |
| const CMICmnMIValueConst miValueConst4("all"); |
| const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4); |
| miOutOfBandRecord.Add(miValueResult4); |
| bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| |
| 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 |
| CMICmnLLDBDebuggerHandleEvents::MiHelpGetCurrentThreadFrame(CMICmnMIValueTuple &vwrMiValueTuple) |
| { |
| CMIUtilString strThreadFrame; |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| lldb::SBThread thread = sbProcess.GetSelectedThread(); |
| const MIuint nFrame = thread.GetNumFrames(); |
| if (nFrame == 0) |
| { |
| // MI print "addr=\"??\",func=\"??\",file=\"??\",fullname=\"??\",line=\"??\"" |
| const CMICmnMIValueConst miValueConst("??"); |
| const CMICmnMIValueResult miValueResult("addr", miValueConst); |
| CMICmnMIValueTuple miValueTuple(miValueResult); |
| const CMICmnMIValueResult miValueResult2("func", miValueConst); |
| miValueTuple.Add(miValueResult2); |
| const CMICmnMIValueResult miValueResult4("file", miValueConst); |
| miValueTuple.Add(miValueResult4); |
| const CMICmnMIValueResult miValueResult5("fullname", miValueConst); |
| miValueTuple.Add(miValueResult5); |
| const CMICmnMIValueResult miValueResult6("line", miValueConst); |
| miValueTuple.Add(miValueResult6); |
| |
| vwrMiValueTuple = miValueTuple; |
| |
| return MIstatus::success; |
| } |
| |
| CMICmnMIValueTuple miValueTuple; |
| if (!CMICmnLLDBDebugSessionInfo::Instance().MIResponseFormFrameInfo(thread, 0, CMICmnLLDBDebugSessionInfo::eFrameInfoFormat_NoArguments, miValueTuple)) |
| { |
| SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_FORM_MI_RESPONSE), "MiHelpGetCurrentThreadFrame()")); |
| return MIstatus::failure; |
| } |
| |
| vwrMiValueTuple = miValueTuple; |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Asynchronous event handler for LLDB Process stop reason breakpoint. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopReasonBreakpoint() |
| { |
| // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM |
| if (!CMIDriver::Instance().SetDriverStateRunningNotDebugging()) |
| { |
| const CMIUtilString &rErrMsg(CMIDriver::Instance().GetErrorDescription()); |
| SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_SETNEWDRIVERSTATE), |
| "HandleProcessEventStopReasonBreakpoint()", rErrMsg.c_str())); |
| return MIstatus::failure; |
| } |
| |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| const MIuint64 brkPtId = sbProcess.GetSelectedThread().GetStopReasonDataAtIndex(0); |
| lldb::SBBreakpoint brkPt = CMICmnLLDBDebugSessionInfo::Instance().GetTarget().GetBreakpointAtIndex((MIuint)brkPtId); |
| |
| return MiStoppedAtBreakPoint(brkPtId, brkPt); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Form the MI Out-of-band response for stopped reason on hitting a break point. |
| // Type: Method. |
| // Args: vBrkPtId - (R) The LLDB break point's ID |
| // vBrkPt - (R) THe LLDB break point object. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::MiStoppedAtBreakPoint(const MIuint64 vBrkPtId, const lldb::SBBreakpoint &vBrkPt) |
| { |
| bool bOk = MIstatus::success; |
| |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| lldb::SBThread thread = sbProcess.GetSelectedThread(); |
| const MIuint nFrame = thread.GetNumFrames(); |
| if (nFrame == 0) |
| { |
| // MI print "*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"%d\",frame={},thread-id=\"%d\",stopped-threads=\"all\"" |
| const CMICmnMIValueConst miValueConst("breakpoint-hit"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueConst miValueConst2("del"); |
| const CMICmnMIValueResult miValueResult2("disp", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| const CMIUtilString strBkp(CMIUtilString::Format("%d", vBrkPtId)); |
| const CMICmnMIValueConst miValueConst3(strBkp); |
| CMICmnMIValueResult miValueResult3("bkptno", miValueConst3); |
| miOutOfBandRecord.Add(miValueResult3); |
| const CMICmnMIValueConst miValueConst4("{}"); |
| const CMICmnMIValueResult miValueResult4("frame", miValueConst4); |
| miOutOfBandRecord.Add(miValueResult4); |
| const CMIUtilString strThreadId(CMIUtilString::Format("%d", vBrkPt.GetThreadIndex())); |
| const CMICmnMIValueConst miValueConst5(strThreadId); |
| const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5); |
| miOutOfBandRecord.Add(miValueResult5); |
| const CMICmnMIValueConst miValueConst6("all"); |
| const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6); |
| miOutOfBandRecord.Add(miValueResult6); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| return bOk; |
| } |
| |
| CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); |
| |
| // MI print |
| // "*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"%d\",frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[],file=\"%s\",fullname=\"%s\",line=\"%d\"},thread-id=\"%d\",stopped-threads=\"all\"" |
| const CMICmnMIValueConst miValueConst("breakpoint-hit"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueConst miValueConstA("del"); |
| const CMICmnMIValueResult miValueResultA("disp", miValueConstA); |
| miOutOfBandRecord.Add(miValueResultA); |
| const CMIUtilString strBkp(CMIUtilString::Format("%d", vBrkPtId)); |
| const CMICmnMIValueConst miValueConstB(strBkp); |
| CMICmnMIValueResult miValueResultB("bkptno", miValueConstB); |
| miOutOfBandRecord.Add(miValueResultB); |
| |
| // frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[],file=\"%s\",fullname=\"%s\",line=\"%d\"} |
| if (bOk) |
| { |
| CMICmnMIValueTuple miValueTuple; |
| bOk = bOk && rSessionInfo.MIResponseFormFrameInfo(thread, 0, CMICmnLLDBDebugSessionInfo::eFrameInfoFormat_AllArguments, miValueTuple); |
| const CMICmnMIValueResult miValueResult8("frame", miValueTuple); |
| miOutOfBandRecord.Add(miValueResult8); |
| } |
| |
| // Add to MI thread-id=\"%d\",stopped-threads=\"all\" |
| if (bOk) |
| { |
| const CMIUtilString strThreadId(CMIUtilString::Format("%d", thread.GetIndexID())); |
| const CMICmnMIValueConst miValueConst8(strThreadId); |
| const CMICmnMIValueResult miValueResult8("thread-id", miValueConst8); |
| miOutOfBandRecord.Add(miValueResult8); |
| } |
| if (bOk) |
| { |
| const CMICmnMIValueConst miValueConst9("all"); |
| const CMICmnMIValueResult miValueResult9("stopped-threads", miValueConst9); |
| miOutOfBandRecord.Add(miValueResult9); |
| bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| } |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Asynchronous event handler for LLDB Process stop reason trace. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopReasonTrace() |
| { |
| bool bOk = true; |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| lldb::SBThread thread = sbProcess.GetSelectedThread(); |
| const MIuint nFrame = thread.GetNumFrames(); |
| if (nFrame == 0) |
| { |
| // MI print "*stopped,reason=\"trace\",stopped-threads=\"all\"" |
| const CMICmnMIValueConst miValueConst("trace"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueConst miValueConst2("all"); |
| const CMICmnMIValueResult miValueResult2("stopped-threads", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| return bOk; |
| } |
| |
| CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); |
| |
| // MI print |
| // "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[\"%s\"],file=\"%s\",fullname=\"%s\",line=\"%d\"},thread-id=\"%d\",stopped-threads=\"all\"" |
| |
| // Function args |
| CMICmnMIValueTuple miValueTuple; |
| if (!rSessionInfo.MIResponseFormFrameInfo(thread, 0, CMICmnLLDBDebugSessionInfo::eFrameInfoFormat_AllArguments, miValueTuple)) |
| return MIstatus::failure; |
| |
| const CMICmnMIValueConst miValueConst("end-stepping-range"); |
| const CMICmnMIValueResult miValueResult("reason", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult); |
| const CMICmnMIValueResult miValueResult2("frame", miValueTuple); |
| miOutOfBandRecord.Add(miValueResult2); |
| |
| // Add to MI thread-id=\"%d\",stopped-threads=\"all\" |
| const CMIUtilString strThreadId(CMIUtilString::Format("%d", thread.GetIndexID())); |
| const CMICmnMIValueConst miValueConst8(strThreadId); |
| const CMICmnMIValueResult miValueResult8("thread-id", miValueConst8); |
| miOutOfBandRecord.Add(miValueResult8); |
| |
| const CMICmnMIValueConst miValueConst9("all"); |
| const CMICmnMIValueResult miValueResult9("stopped-threads", miValueConst9); |
| miOutOfBandRecord.Add(miValueResult9); |
| bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Asynchronous function update selected thread. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::UpdateSelectedThread() |
| { |
| lldb::SBProcess process = CMICmnLLDBDebugSessionInfo::Instance().GetDebugger().GetSelectedTarget().GetProcess(); |
| if (!process.IsValid()) |
| return MIstatus::success; |
| |
| lldb::SBThread currentThread = process.GetSelectedThread(); |
| lldb::SBThread thread; |
| const lldb::StopReason eCurrentThreadStoppedReason = currentThread.GetStopReason(); |
| if (!currentThread.IsValid() || (eCurrentThreadStoppedReason == lldb::eStopReasonInvalid) || |
| (eCurrentThreadStoppedReason == lldb::eStopReasonNone)) |
| { |
| // Prefer a thread that has just completed its plan over another thread as current thread |
| lldb::SBThread planThread; |
| lldb::SBThread otherThread; |
| const size_t nThread = process.GetNumThreads(); |
| for (MIuint i = 0; i < nThread; i++) |
| { |
| // GetThreadAtIndex() uses a base 0 index |
| // GetThreadByIndexID() uses a base 1 index |
| thread = process.GetThreadAtIndex(i); |
| const lldb::StopReason eThreadStopReason = thread.GetStopReason(); |
| switch (eThreadStopReason) |
| { |
| case lldb::eStopReasonTrace: |
| case lldb::eStopReasonBreakpoint: |
| case lldb::eStopReasonWatchpoint: |
| case lldb::eStopReasonSignal: |
| case lldb::eStopReasonException: |
| if (!otherThread.IsValid()) |
| otherThread = thread; |
| break; |
| case lldb::eStopReasonPlanComplete: |
| if (!planThread.IsValid()) |
| planThread = thread; |
| break; |
| case lldb::eStopReasonInvalid: |
| case lldb::eStopReasonNone: |
| default: |
| break; |
| } |
| } |
| if (planThread.IsValid()) |
| process.SetSelectedThread(planThread); |
| else if (otherThread.IsValid()) |
| process.SetSelectedThread(otherThread); |
| else |
| { |
| if (currentThread.IsValid()) |
| thread = currentThread; |
| else |
| thread = process.GetThreadAtIndex(0); |
| |
| if (thread.IsValid()) |
| process.SetSelectedThread(thread); |
| } |
| } // if( !currentThread.IsValid() || (eCurrentThreadStoppedReason == lldb::eStopReasonInvalid) || (eCurrentThreadStoppedReason == |
| // lldb::eStopReasonNone) ) |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Print to stdout "*running,thread-id=\"all\"", "(gdb)". |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateRunning() |
| { |
| CMICmnMIValueConst miValueConst("all"); |
| CMICmnMIValueResult miValueResult("thread-id", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Running, miValueResult); |
| bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Print to stdout "=thread-exited,id=\"%ld\",group-id=\"i1\"", |
| // "=thread-group-exited,id=\"i1\",exit-code=\"0\""), |
| // "*stopped,reason=\"exited-normally\"", |
| // "(gdb)" |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateExited() |
| { |
| const CMIUtilString strId(CMIUtilString::Format("%ld", 1)); |
| CMICmnMIValueConst miValueConst(strId); |
| CMICmnMIValueResult miValueResult("id", miValueConst); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, miValueResult); |
| CMICmnMIValueConst miValueConst2("i1"); |
| CMICmnMIValueResult miValueResult2("group-id", miValueConst2); |
| miOutOfBandRecord.Add(miValueResult2); |
| bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| if (bOk) |
| { |
| CMICmnMIValueConst miValueConst3("i1"); |
| CMICmnMIValueResult miValueResult3("id", miValueConst3); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord2(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited, miValueResult3); |
| CMICmnMIValueConst miValueConst2("0"); |
| CMICmnMIValueResult miValueResult2("exit-code", miValueConst2); |
| miOutOfBandRecord2.Add(miValueResult2); |
| bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord2); |
| } |
| if (bOk) |
| { |
| CMICmnMIValueConst miValueConst4("exited-normally"); |
| CMICmnMIValueResult miValueResult4("reason", miValueConst4); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord3(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult4); |
| bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord3); |
| } |
| bOk = bOk && CMICmnStreamStdout::WritePrompt(); |
| |
| return bOk; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Drain all stdout so we don't see any output come after we print our prompts. |
| // The process has stuff waiting for stdout; get it and write it out to the |
| // appropriate place. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::GetProcessStdout() |
| { |
| CMIUtilString text; |
| std::unique_ptr<char[]> apStdoutBuffer(new char[1024]); |
| lldb::SBProcess process = CMICmnLLDBDebugSessionInfo::Instance().GetDebugger().GetSelectedTarget().GetProcess(); |
| while (1) |
| { |
| const size_t nBytes = process.GetSTDOUT(apStdoutBuffer.get(), 1024); |
| text.append(apStdoutBuffer.get(), nBytes); |
| |
| while (1) |
| { |
| const size_t nNewLine = text.find('\n'); |
| if (nNewLine == std::string::npos) |
| break; |
| |
| const CMIUtilString line(text.substr(0, nNewLine + 1)); |
| text.erase(0, nNewLine + 1); |
| const bool bEscapeQuotes(true); |
| CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes)); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst); |
| const bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| if (!bOk) |
| return MIstatus::failure; |
| } |
| |
| if (nBytes == 0) |
| { |
| if (!text.empty()) |
| { |
| const bool bEscapeQuotes(true); |
| CMICmnMIValueConst miValueConst(text.Escape(bEscapeQuotes)); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst); |
| return MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| } |
| break; |
| } |
| } |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Drain all stderr so we don't see any output come after we print our prompts. |
| // The process has stuff waiting for stderr; get it and write it out to the |
| // appropriate place. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::GetProcessStderr() |
| { |
| CMIUtilString text; |
| std::unique_ptr<char[]> apStderrBuffer(new char[1024]); |
| lldb::SBProcess process = CMICmnLLDBDebugSessionInfo::Instance().GetDebugger().GetSelectedTarget().GetProcess(); |
| while (1) |
| { |
| const size_t nBytes = process.GetSTDERR(apStderrBuffer.get(), 1024); |
| text.append(apStderrBuffer.get(), nBytes); |
| |
| while (1) |
| { |
| const size_t nNewLine = text.find('\n'); |
| if (nNewLine == std::string::npos) |
| break; |
| |
| const CMIUtilString line(text.substr(0, nNewLine + 1)); |
| const bool bEscapeQuotes(true); |
| CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes)); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst); |
| const bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| if (!bOk) |
| return MIstatus::failure; |
| } |
| |
| if (nBytes == 0) |
| { |
| if (!text.empty()) |
| { |
| const bool bEscapeQuotes(true); |
| CMICmnMIValueConst miValueConst(text.Escape(bEscapeQuotes)); |
| CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst); |
| return MiOutOfBandRecordToStdout(miOutOfBandRecord); |
| } |
| break; |
| } |
| } |
| |
| return MIstatus::success; |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Asynchronous event function check for state changes. |
| // Type: Method. |
| // Args: None. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::ChkForStateChanges() |
| { |
| CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance()); |
| lldb::SBProcess sbProcess = rSessionInfo.GetProcess(); |
| if (!sbProcess.IsValid()) |
| return 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; |
| |
| const MIuint threadIndexID = thread.GetIndexID(); |
| const bool bFound = std::find(rSessionInfo.m_vecActiveThreadId.cbegin(), rSessionInfo.m_vecActiveThreadId.cend(), threadIndexID) != rSessionInfo.m_vecActiveThreadId.end(); |
| if (!bFound) |
| { |
| rSessionInfo.m_vecActiveThreadId.push_back(threadIndexID); |
| |
| // Form MI "=thread-created,id=\"%d\",group-id=\"i1\"" |
| 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); |
| miOutOfBand.Add(miValueResult2); |
| bool bOk = MiOutOfBandRecordToStdout(miOutOfBand); |
| if (!bOk) |
| return MIstatus::failure; |
| } |
| } |
| |
| lldb::SBThread currentThread = sbProcess.GetSelectedThread(); |
| if (currentThread.IsValid()) |
| { |
| const MIuint currentThreadIndexID = currentThread.GetIndexID(); |
| if (rSessionInfo.m_currentSelectedThread != currentThreadIndexID) |
| { |
| rSessionInfo.m_currentSelectedThread = currentThreadIndexID; |
| |
| // Form MI "=thread-selected,id=\"%d\"" |
| 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::iterator it = rSessionInfo.m_vecActiveThreadId.begin(); |
| while (it != rSessionInfo.m_vecActiveThreadId.end()) |
| { |
| 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", 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); |
| miOutOfBand.Add(miValueResult2); |
| bool 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 CMICmnStreamStdout::WritePrompt(); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Take a fully formed MI result record and send to the stdout stream. |
| // Also output to the MI Log file. |
| // Type: Method. |
| // Args: vrMiResultRecord - (R) MI result record object. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::MiResultRecordToStdout(const CMICmnMIResultRecord &vrMiResultRecord) |
| { |
| return TextToStdout(vrMiResultRecord.GetString()); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Take a fully formed MI Out-of-band record and send to the stdout stream. |
| // Also output to the MI Log file. |
| // Type: Method. |
| // Args: vrMiOutOfBandRecord - (R) MI Out-of-band record object. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::MiOutOfBandRecordToStdout(const CMICmnMIOutOfBandRecord &vrMiOutOfBandRecord) |
| { |
| return TextToStdout(vrMiOutOfBandRecord.GetString()); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Take a text data and send to the stdout stream. Also output to the MI Log |
| // file. |
| // Type: Method. |
| // Args: vrTxt - (R) Text. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::TextToStdout(const CMIUtilString &vrTxt) |
| { |
| return CMICmnStreamStdout::TextToStdout(vrTxt); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Take a text data and send to the stderr stream. Also output to the MI Log |
| // file. |
| // Type: Method. |
| // Args: vrTxt - (R) Text. |
| // Return: MIstatus::success - Functionality succeeded. |
| // MIstatus::failure - Functionality failed. |
| // Throws: None. |
| //-- |
| bool |
| CMICmnLLDBDebuggerHandleEvents::TextToStderr(const CMIUtilString &vrTxt) |
| { |
| return CMICmnStreamStderr::TextToStderr(vrTxt); |
| } |
| |
| //++ ------------------------------------------------------------------------------------ |
| // Details: Initialize the member variables with the signal values in this process |
| // file. |
| // Type: Method. |
| // Args: None |
| // Return: Noen |
| // Throws: None. |
| //-- |
| void |
| CMICmnLLDBDebuggerHandleEvents::InitializeSignals() |
| { |
| if (!m_bSignalsInitialized) |
| { |
| lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess(); |
| if (sbProcess.IsValid()) |
| { |
| lldb::SBUnixSignals unix_signals = sbProcess.GetUnixSignals(); |
| m_SIGINT = unix_signals.GetSignalNumberFromName("SIGINT"); |
| m_SIGSTOP = unix_signals.GetSignalNumberFromName("SIGSTOP"); |
| m_SIGSEGV = unix_signals.GetSignalNumberFromName("SIGSEGV"); |
| m_SIGTRAP = unix_signals.GetSignalNumberFromName("SIGTRAP"); |
| m_bSignalsInitialized = true; |
| } |
| } |
| } |
