8b3af63b89
A lot of comments in LLDB are surrounded by an ASCII line to delimit the begging and end of the comment. Its use is not really consistent across the code base, sometimes the lines are longer, sometimes they are shorter and sometimes they are omitted. Furthermore, it looks kind of weird with the 80 column limit, where the comment actually extends past the line, but not by much. Furthermore, when /// is used for Doxygen comments, it looks particularly odd. And when // is used, it incorrectly gives the impression that it's actually a Doxygen comment. I assume these lines were added to improve distinguishing between comments and code. However, given that todays editors and IDEs do a great job at highlighting comments, I think it's worth to drop this for the sake of consistency. The alternative is fixing all the inconsistencies, which would create a lot more churn. Differential revision: https://reviews.llvm.org/D60508 llvm-svn: 358135
864 lines
31 KiB
C++
864 lines
31 KiB
C++
//===-- MICmnLLDBDebugSessionInfo.cpp ---------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Third party headers:
|
|
#include "lldb/API/SBThread.h"
|
|
#include <inttypes.h>
|
|
#ifdef _WIN32
|
|
#include <io.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif // _WIN32
|
|
#include "lldb/API/SBBreakpointLocation.h"
|
|
|
|
// In-house headers:
|
|
#include "MICmdData.h"
|
|
#include "MICmnLLDBDebugSessionInfo.h"
|
|
#include "MICmnLLDBDebugger.h"
|
|
#include "MICmnLLDBUtilSBValue.h"
|
|
#include "MICmnMIResultRecord.h"
|
|
#include "MICmnMIValueConst.h"
|
|
#include "MICmnMIValueList.h"
|
|
#include "MICmnMIValueTuple.h"
|
|
#include "MICmnResources.h"
|
|
#include "Platform.h"
|
|
|
|
//++
|
|
// Details: CMICmnLLDBDebugSessionInfo constructor.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
CMICmnLLDBDebugSessionInfo::CMICmnLLDBDebugSessionInfo()
|
|
: m_nBrkPointCntMax(INT32_MAX),
|
|
m_currentSelectedThread(LLDB_INVALID_THREAD_ID),
|
|
m_constStrSharedDataKeyWkDir("Working Directory"),
|
|
m_constStrSharedDataSolibPath("Solib Path"),
|
|
m_constStrPrintCharArrayAsString("Print CharArrayAsString"),
|
|
m_constStrPrintExpandAggregates("Print ExpandAggregates"),
|
|
m_constStrPrintAggregateFieldNames("Print AggregateFieldNames") {}
|
|
|
|
//++
|
|
// Details: CMICmnLLDBDebugSessionInfo destructor.
|
|
// Type: Overridable.
|
|
// Args: None.
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
CMICmnLLDBDebugSessionInfo::~CMICmnLLDBDebugSessionInfo() { Shutdown(); }
|
|
|
|
//++
|
|
// Details: Initialize resources for *this object.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: MIstatus::success - Functionality succeeded.
|
|
// MIstatus::failure - Functionality failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::Initialize() {
|
|
m_clientUsageRefCnt++;
|
|
|
|
if (m_bInitialized)
|
|
return MIstatus::success;
|
|
|
|
m_currentSelectedThread = LLDB_INVALID_THREAD_ID;
|
|
CMICmnLLDBDebugSessionInfoVarObj::VarObjIdResetToZero();
|
|
|
|
m_bInitialized = MIstatus::success;
|
|
|
|
return m_bInitialized;
|
|
}
|
|
|
|
//++
|
|
// Details: Release resources for *this object.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: MIstatus::success - Functionality succeeded.
|
|
// MIstatus::failure - Functionality failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::Shutdown() {
|
|
if (--m_clientUsageRefCnt > 0)
|
|
return MIstatus::success;
|
|
|
|
if (!m_bInitialized)
|
|
return MIstatus::success;
|
|
|
|
// Tidy up
|
|
SharedDataDestroy();
|
|
|
|
m_vecActiveThreadId.clear();
|
|
CMICmnLLDBDebugSessionInfoVarObj::VarObjClear();
|
|
|
|
m_bInitialized = false;
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Command instances can create and share data between other instances
|
|
// of commands.
|
|
// Data can also be assigned by a command and retrieved by LLDB event
|
|
// handler.
|
|
// This function takes down those resources build up over the use of
|
|
// the commands.
|
|
// This function should be called when the creation and running of
|
|
// command has
|
|
// stopped i.e. application shutdown.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
void CMICmnLLDBDebugSessionInfo::SharedDataDestroy() {
|
|
m_mapIdToSessionData.Clear();
|
|
m_vecVarObj.clear();
|
|
m_mapBrkPtIdToBrkPtInfo.clear();
|
|
}
|
|
|
|
//++
|
|
// Details: Record information about a LLDB break point so that is can be
|
|
// recalled in other
|
|
// commands or LLDB event handling functions.
|
|
// Type: Method.
|
|
// Args: vBrkPtId - (R) LLDB break point ID.
|
|
// vrBrkPtInfo - (R) Break point information object.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::RecordBrkPtInfo(
|
|
const MIuint vnBrkPtId, const SBrkPtInfo &vrBrkPtInfo) {
|
|
MapPairBrkPtIdToBrkPtInfo_t pr(vnBrkPtId, vrBrkPtInfo);
|
|
m_mapBrkPtIdToBrkPtInfo.insert(pr);
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Retrieve information about a LLDB break point previous recorded
|
|
// either by
|
|
// commands or LLDB event handling functions.
|
|
// Type: Method.
|
|
// Args: vBrkPtId - (R) LLDB break point ID.
|
|
// vrwBrkPtInfo - (W) Break point information object.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::RecordBrkPtInfoGet(
|
|
const MIuint vnBrkPtId, SBrkPtInfo &vrwBrkPtInfo) const {
|
|
const MapBrkPtIdToBrkPtInfo_t::const_iterator it =
|
|
m_mapBrkPtIdToBrkPtInfo.find(vnBrkPtId);
|
|
if (it != m_mapBrkPtIdToBrkPtInfo.end()) {
|
|
vrwBrkPtInfo = (*it).second;
|
|
return MIstatus::success;
|
|
}
|
|
|
|
return MIstatus::failure;
|
|
}
|
|
|
|
//++
|
|
// Details: Delete information about a specific LLDB break point object. This
|
|
// function
|
|
// should be called when a LLDB break point is deleted.
|
|
// Type: Method.
|
|
// Args: vBrkPtId - (R) LLDB break point ID.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::RecordBrkPtInfoDelete(const MIuint vnBrkPtId) {
|
|
const MapBrkPtIdToBrkPtInfo_t::const_iterator it =
|
|
m_mapBrkPtIdToBrkPtInfo.find(vnBrkPtId);
|
|
if (it != m_mapBrkPtIdToBrkPtInfo.end()) {
|
|
m_mapBrkPtIdToBrkPtInfo.erase(it);
|
|
return MIstatus::success;
|
|
}
|
|
|
|
return MIstatus::failure;
|
|
}
|
|
|
|
//++
|
|
// Details: Retrieve the specified thread's frame information.
|
|
// Type: Method.
|
|
// Args: vCmdData - (R) A command's information.
|
|
// vThreadIdx - (R) Thread index.
|
|
// vwrThreadFrames - (W) Frame data.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::GetThreadFrames(
|
|
const SMICmdData &vCmdData, const MIuint vThreadIdx,
|
|
const FrameInfoFormat_e veFrameInfoFormat, CMIUtilString &vwrThreadFrames) {
|
|
lldb::SBThread thread = GetProcess().GetThreadByIndexID(vThreadIdx);
|
|
const uint32_t nFrames = thread.GetNumFrames();
|
|
if (nFrames == 0) {
|
|
// MI print "frame={}"
|
|
CMICmnMIValueTuple miValueTuple;
|
|
CMICmnMIValueResult miValueResult("frame", miValueTuple);
|
|
vwrThreadFrames = miValueResult.GetString();
|
|
return MIstatus::success;
|
|
}
|
|
|
|
// MI print
|
|
// "frame={level=\"%d\",addr=\"0x%016" PRIx64
|
|
// "\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},frame={level=\"%d\",addr=\"0x%016"
|
|
// PRIx64 "\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},
|
|
// ..."
|
|
CMIUtilString strListCommaSeparated;
|
|
for (MIuint nLevel = 0; nLevel < nFrames; nLevel++) {
|
|
CMICmnMIValueTuple miValueTuple;
|
|
if (!MIResponseFormFrameInfo(thread, nLevel, veFrameInfoFormat,
|
|
miValueTuple))
|
|
return MIstatus::failure;
|
|
|
|
const CMICmnMIValueResult miValueResult2("frame", miValueTuple);
|
|
if (nLevel != 0)
|
|
strListCommaSeparated += ",";
|
|
strListCommaSeparated += miValueResult2.GetString();
|
|
}
|
|
|
|
vwrThreadFrames = strListCommaSeparated;
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Return the resolved file's path for the given file.
|
|
// Type: Method.
|
|
// Args: vCmdData - (R) A command's information.
|
|
// vPath - (R) Original path.
|
|
// vwrResolvedPath - (W) Resolved path.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::ResolvePath(const SMICmdData &vCmdData,
|
|
const CMIUtilString &vPath,
|
|
CMIUtilString &vwrResolvedPath) {
|
|
// ToDo: Verify this code as it does not work as vPath is always empty
|
|
|
|
CMIUtilString strResolvedPath;
|
|
if (!SharedDataRetrieve<CMIUtilString>(m_constStrSharedDataKeyWkDir,
|
|
strResolvedPath)) {
|
|
vwrResolvedPath = "";
|
|
SetErrorDescription(CMIUtilString::Format(
|
|
MIRSRC(IDS_CMD_ERR_SHARED_DATA_NOT_FOUND), vCmdData.strMiCmd.c_str(),
|
|
m_constStrSharedDataKeyWkDir.c_str()));
|
|
return MIstatus::failure;
|
|
}
|
|
|
|
vwrResolvedPath = vPath;
|
|
|
|
return ResolvePath(strResolvedPath, vwrResolvedPath);
|
|
}
|
|
|
|
//++
|
|
// Details: Return the resolved file's path for the given file.
|
|
// Type: Method.
|
|
// Args: vstrUnknown - (R) String assigned to path when resolved path
|
|
// is empty.
|
|
// vwrResolvedPath - (RW) The original path overwritten with resolved
|
|
// path.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::ResolvePath(const CMIUtilString &vstrUnknown,
|
|
CMIUtilString &vwrResolvedPath) {
|
|
if (vwrResolvedPath.size() < 1) {
|
|
vwrResolvedPath = vstrUnknown;
|
|
return MIstatus::success;
|
|
}
|
|
|
|
bool bOk = MIstatus::success;
|
|
|
|
CMIUtilString::VecString_t vecPathFolders;
|
|
const MIuint nSplits = vwrResolvedPath.Split("/", vecPathFolders);
|
|
MIunused(nSplits);
|
|
MIuint nFoldersBack = 1; // 1 is just the file (last element of vector)
|
|
while (bOk && (vecPathFolders.size() >= nFoldersBack)) {
|
|
CMIUtilString strTestPath;
|
|
MIuint nFoldersToAdd = nFoldersBack;
|
|
while (nFoldersToAdd > 0) {
|
|
strTestPath += "/";
|
|
strTestPath += vecPathFolders[vecPathFolders.size() - nFoldersToAdd];
|
|
nFoldersToAdd--;
|
|
}
|
|
bool bYesAccessible = false;
|
|
bOk = AccessPath(strTestPath, bYesAccessible);
|
|
if (bYesAccessible) {
|
|
vwrResolvedPath = strTestPath;
|
|
return MIstatus::success;
|
|
} else
|
|
nFoldersBack++;
|
|
}
|
|
|
|
// No files exist in the union of working directory and debuginfo path
|
|
// Simply use the debuginfo path and let the IDE handle it.
|
|
|
|
return bOk;
|
|
}
|
|
|
|
//++
|
|
// Details: Determine the given file path exists or not.
|
|
// Type: Method.
|
|
// Args: vPath - (R) File name path.
|
|
// vwbYesAccessible - (W) True - file exists, false = does not
|
|
// exist.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::AccessPath(const CMIUtilString &vPath,
|
|
bool &vwbYesAccessible) {
|
|
#ifdef _WIN32
|
|
vwbYesAccessible = (::_access(vPath.c_str(), 0) == 0);
|
|
#else
|
|
vwbYesAccessible = (::access(vPath.c_str(), 0) == 0);
|
|
#endif // _WIN32
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Form MI partial response by appending more MI value type objects to
|
|
// the
|
|
// tuple type object past in.
|
|
// Type: Method.
|
|
// Args: vCmdData - (R) A command's information.
|
|
// vrThread - (R) LLDB thread object.
|
|
// vwrMIValueTuple - (W) MI value tuple object.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo(
|
|
const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
|
|
const ThreadInfoFormat_e veThreadInfoFormat,
|
|
CMICmnMIValueTuple &vwrMIValueTuple) {
|
|
lldb::SBThread &rThread = const_cast<lldb::SBThread &>(vrThread);
|
|
|
|
const bool bSuspended = rThread.IsSuspended();
|
|
const lldb::StopReason eReason = rThread.GetStopReason();
|
|
const bool bValidReason = !((eReason == lldb::eStopReasonNone) ||
|
|
(eReason == lldb::eStopReasonInvalid));
|
|
const CMIUtilString strState((bSuspended || bValidReason) ? "stopped"
|
|
: "running");
|
|
|
|
// Add "id"
|
|
const CMIUtilString strId(CMIUtilString::Format("%d", rThread.GetIndexID()));
|
|
const CMICmnMIValueConst miValueConst1(strId);
|
|
const CMICmnMIValueResult miValueResult1("id", miValueConst1);
|
|
vwrMIValueTuple.Add(miValueResult1);
|
|
|
|
// Add "target-id"
|
|
const char *pThreadName = rThread.GetName();
|
|
const MIuint len = CMIUtilString(pThreadName).length();
|
|
const bool bHaveName = (len > 0) && (len < 32) && // 32 is arbitrary number
|
|
CMIUtilString::IsAllValidAlphaAndNumeric(pThreadName);
|
|
const char *pThrdFmt = bHaveName ? "%s" : "Thread %d";
|
|
CMIUtilString strThread;
|
|
if (bHaveName)
|
|
strThread = CMIUtilString::Format(pThrdFmt, pThreadName);
|
|
else
|
|
strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
|
|
const CMICmnMIValueConst miValueConst2(strThread);
|
|
const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
|
|
vwrMIValueTuple.Add(miValueResult2);
|
|
|
|
// Add "frame"
|
|
if (veThreadInfoFormat != eThreadInfoFormat_NoFrames) {
|
|
CMIUtilString strFrames;
|
|
if (!GetThreadFrames(vCmdData, rThread.GetIndexID(),
|
|
eFrameInfoFormat_AllArgumentsInSimpleForm, strFrames))
|
|
return MIstatus::failure;
|
|
|
|
const CMICmnMIValueConst miValueConst3(strFrames, true);
|
|
vwrMIValueTuple.Add(miValueConst3, false);
|
|
}
|
|
|
|
// Add "state"
|
|
const CMICmnMIValueConst miValueConst4(strState);
|
|
const CMICmnMIValueResult miValueResult4("state", miValueConst4);
|
|
vwrMIValueTuple.Add(miValueResult4);
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Form MI partial response by appending more MI value type objects to
|
|
// the
|
|
// tuple type object past in.
|
|
// Type: Method.
|
|
// Args: vrFrame - (R) LLDB thread object.
|
|
// vMaskVarTypes - (R) Construed according to VariableType_e.
|
|
// veVarInfoFormat - (R) The type of variable info that should be
|
|
// shown.
|
|
// vwrMIValueList - (W) MI value list object.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::MIResponseFormVariableInfo(
|
|
const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
|
|
const VariableInfoFormat_e veVarInfoFormat,
|
|
CMICmnMIValueList &vwrMiValueList, const MIuint vnMaxDepth, /* = 10 */
|
|
const bool vbMarkArgs /* = false*/) {
|
|
bool bOk = MIstatus::success;
|
|
lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);
|
|
|
|
const bool bArg = (vMaskVarTypes & eVariableType_Arguments);
|
|
const bool bLocals = (vMaskVarTypes & eVariableType_Locals);
|
|
const bool bStatics = (vMaskVarTypes & eVariableType_Statics);
|
|
const bool bInScopeOnly = (vMaskVarTypes & eVariableType_InScope);
|
|
|
|
// Handle arguments first
|
|
lldb::SBValueList listArg = rFrame.GetVariables(bArg, false, false, false);
|
|
bOk = bOk && MIResponseForVariableInfoInternal(veVarInfoFormat,
|
|
vwrMiValueList, listArg,
|
|
vnMaxDepth, true, vbMarkArgs);
|
|
|
|
// Handle remaining variables
|
|
lldb::SBValueList listVars =
|
|
rFrame.GetVariables(false, bLocals, bStatics, bInScopeOnly);
|
|
bOk = bOk && MIResponseForVariableInfoInternal(veVarInfoFormat,
|
|
vwrMiValueList, listVars,
|
|
vnMaxDepth, false, vbMarkArgs);
|
|
|
|
return bOk;
|
|
}
|
|
|
|
bool CMICmnLLDBDebugSessionInfo::MIResponseForVariableInfoInternal(
|
|
const VariableInfoFormat_e veVarInfoFormat,
|
|
CMICmnMIValueList &vwrMiValueList, const lldb::SBValueList &vwrSBValueList,
|
|
const MIuint vnMaxDepth, const bool vbIsArgs, const bool vbMarkArgs) {
|
|
const MIuint nArgs = vwrSBValueList.GetSize();
|
|
for (MIuint i = 0; i < nArgs; i++) {
|
|
CMICmnMIValueTuple miValueTuple;
|
|
lldb::SBValue value = vwrSBValueList.GetValueAtIndex(i);
|
|
// If one stops inside try block with, which catch clause type is unnamed
|
|
// (e.g std::exception&) then value name will be nullptr as well as value
|
|
// pointer
|
|
const char *name = value.GetName();
|
|
if (name == nullptr)
|
|
continue;
|
|
const CMICmnMIValueConst miValueConst(name);
|
|
const CMICmnMIValueResult miValueResultName("name", miValueConst);
|
|
if (vbMarkArgs && vbIsArgs) {
|
|
const CMICmnMIValueConst miValueConstArg("1");
|
|
const CMICmnMIValueResult miValueResultArg("arg", miValueConstArg);
|
|
miValueTuple.Add(miValueResultArg);
|
|
}
|
|
if (veVarInfoFormat != eVariableInfoFormat_NoValues) {
|
|
miValueTuple.Add(miValueResultName); // name
|
|
if (veVarInfoFormat == eVariableInfoFormat_SimpleValues) {
|
|
const CMICmnMIValueConst miValueConst3(value.GetTypeName());
|
|
const CMICmnMIValueResult miValueResult3("type", miValueConst3);
|
|
miValueTuple.Add(miValueResult3);
|
|
}
|
|
const MIuint nChildren = value.GetNumChildren();
|
|
const bool bIsPointerType = value.GetType().IsPointerType();
|
|
if (nChildren == 0 || // no children
|
|
(bIsPointerType && nChildren == 1) || // pointers
|
|
veVarInfoFormat == eVariableInfoFormat_AllValues) // show all values
|
|
{
|
|
CMIUtilString strValue;
|
|
if (GetVariableInfo(value, vnMaxDepth == 0, strValue)) {
|
|
const CMICmnMIValueConst miValueConst2(
|
|
strValue.Escape().AddSlashes());
|
|
const CMICmnMIValueResult miValueResult2("value", miValueConst2);
|
|
miValueTuple.Add(miValueResult2);
|
|
}
|
|
}
|
|
vwrMiValueList.Add(miValueTuple);
|
|
continue;
|
|
}
|
|
|
|
if (vbMarkArgs) {
|
|
// If we are printing names only with vbMarkArgs, we still need to add the
|
|
// name to the value tuple
|
|
miValueTuple.Add(miValueResultName); // name
|
|
vwrMiValueList.Add(miValueTuple);
|
|
} else {
|
|
// If we are printing name only then no need to put it in the tuple.
|
|
vwrMiValueList.Add(miValueResultName);
|
|
}
|
|
}
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Extract the value's name and value or recurse into child value
|
|
// object.
|
|
// Type: Method.
|
|
// Args: vrValue - (R) LLDB value object.
|
|
// vbInSimpleForm - (R) True = Get variable info in simple form (i.e.
|
|
// don't expand aggregates).
|
|
// - False = Get variable info (and expand
|
|
// aggregates if any).
|
|
// vwrStrValue t - (W) The string representation of this value.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::GetVariableInfo(const lldb::SBValue &vrValue,
|
|
const bool vbInSimpleForm,
|
|
CMIUtilString &vwrStrValue) {
|
|
const CMICmnLLDBUtilSBValue utilValue(vrValue, true, false);
|
|
const bool bExpandAggregates = !vbInSimpleForm;
|
|
vwrStrValue = utilValue.GetValue(bExpandAggregates);
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Form MI partial response by appending more MI value type objects to
|
|
// the
|
|
// tuple type object past in.
|
|
// Type: Method.
|
|
// Args: vrThread - (R) LLDB thread object.
|
|
// vwrMIValueTuple - (W) MI value tuple object.
|
|
// vArgInfo - (R) Args information in MI response form.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::MIResponseFormFrameInfo(
|
|
const lldb::SBThread &vrThread, const MIuint vnLevel,
|
|
const FrameInfoFormat_e veFrameInfoFormat,
|
|
CMICmnMIValueTuple &vwrMiValueTuple) {
|
|
lldb::SBThread &rThread = const_cast<lldb::SBThread &>(vrThread);
|
|
|
|
lldb::SBFrame frame = rThread.GetFrameAtIndex(vnLevel);
|
|
lldb::addr_t pc = 0;
|
|
CMIUtilString fnName;
|
|
CMIUtilString fileName;
|
|
CMIUtilString path;
|
|
MIuint nLine = 0;
|
|
if (!GetFrameInfo(frame, pc, fnName, fileName, path, nLine))
|
|
return MIstatus::failure;
|
|
|
|
// MI print "{level=\"0\",addr=\"0x%016" PRIx64
|
|
// "\",func=\"%s\",file=\"%s\",fullname=\"%s\",line=\"%d\"}"
|
|
const CMIUtilString strLevel(CMIUtilString::Format("%d", vnLevel));
|
|
const CMICmnMIValueConst miValueConst(strLevel);
|
|
const CMICmnMIValueResult miValueResult("level", miValueConst);
|
|
vwrMiValueTuple.Add(miValueResult);
|
|
const CMIUtilString strAddr(CMIUtilString::Format("0x%016" PRIx64, pc));
|
|
const CMICmnMIValueConst miValueConst2(strAddr);
|
|
const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
|
|
vwrMiValueTuple.Add(miValueResult2);
|
|
const CMICmnMIValueConst miValueConst3(fnName);
|
|
const CMICmnMIValueResult miValueResult3("func", miValueConst3);
|
|
vwrMiValueTuple.Add(miValueResult3);
|
|
if (veFrameInfoFormat != eFrameInfoFormat_NoArguments) {
|
|
CMICmnMIValueList miValueList(true);
|
|
const MIuint maskVarTypes = eVariableType_Arguments;
|
|
if (veFrameInfoFormat == eFrameInfoFormat_AllArgumentsInSimpleForm) {
|
|
if (!MIResponseFormVariableInfo(frame, maskVarTypes,
|
|
eVariableInfoFormat_AllValues,
|
|
miValueList, 0))
|
|
return MIstatus::failure;
|
|
} else if (!MIResponseFormVariableInfo(frame, maskVarTypes,
|
|
eVariableInfoFormat_AllValues,
|
|
miValueList))
|
|
return MIstatus::failure;
|
|
|
|
const CMICmnMIValueResult miValueResult4("args", miValueList);
|
|
vwrMiValueTuple.Add(miValueResult4);
|
|
}
|
|
const CMICmnMIValueConst miValueConst5(fileName);
|
|
const CMICmnMIValueResult miValueResult5("file", miValueConst5);
|
|
vwrMiValueTuple.Add(miValueResult5);
|
|
const CMICmnMIValueConst miValueConst6(path);
|
|
const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
|
|
vwrMiValueTuple.Add(miValueResult6);
|
|
const CMIUtilString strLine(CMIUtilString::Format("%d", nLine));
|
|
const CMICmnMIValueConst miValueConst7(strLine);
|
|
const CMICmnMIValueResult miValueResult7("line", miValueConst7);
|
|
vwrMiValueTuple.Add(miValueResult7);
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Retrieve the frame information from LLDB frame object.
|
|
// Type: Method.
|
|
// Args: vrFrame - (R) LLDB thread object.
|
|
// vPc - (W) Address number.
|
|
// vFnName - (W) Function name.
|
|
// vFileName - (W) File name text.
|
|
// vPath - (W) Full file name and path text.
|
|
// vnLine - (W) File line number.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::GetFrameInfo(
|
|
const lldb::SBFrame &vrFrame, lldb::addr_t &vwPc, CMIUtilString &vwFnName,
|
|
CMIUtilString &vwFileName, CMIUtilString &vwPath, MIuint &vwnLine) {
|
|
lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);
|
|
|
|
static char pBuffer[PATH_MAX];
|
|
const MIuint nBytes =
|
|
rFrame.GetLineEntry().GetFileSpec().GetPath(&pBuffer[0], sizeof(pBuffer));
|
|
MIunused(nBytes);
|
|
CMIUtilString strResolvedPath(&pBuffer[0]);
|
|
const char *pUnkwn = "??";
|
|
if (!ResolvePath(pUnkwn, strResolvedPath))
|
|
return MIstatus::failure;
|
|
vwPath = strResolvedPath;
|
|
|
|
vwPc = rFrame.GetPC();
|
|
|
|
const char *pFnName = rFrame.GetFunctionName();
|
|
vwFnName = (pFnName != nullptr) ? pFnName : pUnkwn;
|
|
|
|
const char *pFileName = rFrame.GetLineEntry().GetFileSpec().GetFilename();
|
|
vwFileName = (pFileName != nullptr) ? pFileName : pUnkwn;
|
|
|
|
vwnLine = rFrame.GetLineEntry().GetLine();
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Form MI partial response by appending more MI value type objects to
|
|
// the
|
|
// tuple type object past in.
|
|
// Type: Method.
|
|
// Args: vrBrkPtInfo - (R) Break point information object.
|
|
// vwrMIValueTuple - (W) MI value tuple object.
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
void CMICmnLLDBDebugSessionInfo::MIResponseFormBrkPtFrameInfo(
|
|
const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple) {
|
|
const CMIUtilString strAddr(
|
|
CMIUtilString::Format("0x%016" PRIx64, vrBrkPtInfo.m_pc));
|
|
const CMICmnMIValueConst miValueConst2(strAddr);
|
|
const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
|
|
vwrMiValueTuple.Add(miValueResult2);
|
|
const CMICmnMIValueConst miValueConst3(vrBrkPtInfo.m_fnName);
|
|
const CMICmnMIValueResult miValueResult3("func", miValueConst3);
|
|
vwrMiValueTuple.Add(miValueResult3);
|
|
const CMICmnMIValueConst miValueConst5(vrBrkPtInfo.m_fileName);
|
|
const CMICmnMIValueResult miValueResult5("file", miValueConst5);
|
|
vwrMiValueTuple.Add(miValueResult5);
|
|
const CMIUtilString strN5 = CMIUtilString::Format(
|
|
"%s/%s", vrBrkPtInfo.m_path.c_str(), vrBrkPtInfo.m_fileName.c_str());
|
|
const CMICmnMIValueConst miValueConst6(strN5);
|
|
const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
|
|
vwrMiValueTuple.Add(miValueResult6);
|
|
const CMIUtilString strLine(CMIUtilString::Format("%d", vrBrkPtInfo.m_nLine));
|
|
const CMICmnMIValueConst miValueConst7(strLine);
|
|
const CMICmnMIValueResult miValueResult7("line", miValueConst7);
|
|
vwrMiValueTuple.Add(miValueResult7);
|
|
}
|
|
|
|
//++
|
|
// Details: Form MI partial response by appending more MI value type objects to
|
|
// the
|
|
// tuple type object past in.
|
|
// Type: Method.
|
|
// Args: vrBrkPtInfo - (R) Break point information object.
|
|
// vwrMIValueTuple - (W) MI value tuple object.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::MIResponseFormBrkPtInfo(
|
|
const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple) {
|
|
// 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\"}"
|
|
|
|
// "number="
|
|
const CMICmnMIValueConst miValueConst(
|
|
CMIUtilString::Format("%d", vrBrkPtInfo.m_id));
|
|
const CMICmnMIValueResult miValueResult("number", miValueConst);
|
|
CMICmnMIValueTuple miValueTuple(miValueResult);
|
|
// "type="
|
|
const CMICmnMIValueConst miValueConst2(vrBrkPtInfo.m_strType);
|
|
const CMICmnMIValueResult miValueResult2("type", miValueConst2);
|
|
miValueTuple.Add(miValueResult2);
|
|
// "disp="
|
|
const CMICmnMIValueConst miValueConst3(vrBrkPtInfo.m_bDisp ? "del" : "keep");
|
|
const CMICmnMIValueResult miValueResult3("disp", miValueConst3);
|
|
miValueTuple.Add(miValueResult3);
|
|
// "enabled="
|
|
const CMICmnMIValueConst miValueConst4(vrBrkPtInfo.m_bEnabled ? "y" : "n");
|
|
const CMICmnMIValueResult miValueResult4("enabled", miValueConst4);
|
|
miValueTuple.Add(miValueResult4);
|
|
// "addr="
|
|
// "func="
|
|
// "file="
|
|
// "fullname="
|
|
// "line="
|
|
MIResponseFormBrkPtFrameInfo(vrBrkPtInfo, miValueTuple);
|
|
// "pending="
|
|
if (vrBrkPtInfo.m_bPending) {
|
|
const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strOrigLoc);
|
|
const CMICmnMIValueList miValueList(miValueConst);
|
|
const CMICmnMIValueResult miValueResult("pending", miValueList);
|
|
miValueTuple.Add(miValueResult);
|
|
}
|
|
if (vrBrkPtInfo.m_bHaveArgOptionThreadGrp) {
|
|
const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strOptThrdGrp);
|
|
const CMICmnMIValueList miValueList(miValueConst);
|
|
const CMICmnMIValueResult miValueResult("thread-groups", miValueList);
|
|
miValueTuple.Add(miValueResult);
|
|
}
|
|
// "times="
|
|
const CMICmnMIValueConst miValueConstB(
|
|
CMIUtilString::Format("%d", vrBrkPtInfo.m_nTimes));
|
|
const CMICmnMIValueResult miValueResultB("times", miValueConstB);
|
|
miValueTuple.Add(miValueResultB);
|
|
// "thread="
|
|
if (vrBrkPtInfo.m_bBrkPtThreadId) {
|
|
const CMICmnMIValueConst miValueConst(
|
|
CMIUtilString::Format("%d", vrBrkPtInfo.m_nBrkPtThreadId));
|
|
const CMICmnMIValueResult miValueResult("thread", miValueConst);
|
|
miValueTuple.Add(miValueResult);
|
|
}
|
|
// "cond="
|
|
if (vrBrkPtInfo.m_bCondition) {
|
|
const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strCondition);
|
|
const CMICmnMIValueResult miValueResult("cond", miValueConst);
|
|
miValueTuple.Add(miValueResult);
|
|
}
|
|
// "ignore="
|
|
if (vrBrkPtInfo.m_nIgnore != 0) {
|
|
const CMICmnMIValueConst miValueConst(
|
|
CMIUtilString::Format("%d", vrBrkPtInfo.m_nIgnore));
|
|
const CMICmnMIValueResult miValueResult("ignore", miValueConst);
|
|
miValueTuple.Add(miValueResult);
|
|
}
|
|
// "original-location="
|
|
const CMICmnMIValueConst miValueConstC(vrBrkPtInfo.m_strOrigLoc);
|
|
const CMICmnMIValueResult miValueResultC("original-location", miValueConstC);
|
|
miValueTuple.Add(miValueResultC);
|
|
|
|
vwrMiValueTuple = miValueTuple;
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Retrieve breakpoint information and write into the given breakpoint
|
|
// information
|
|
// object. Note not all possible information is retrieved and so the
|
|
// information
|
|
// object may need to be filled in with more information after calling
|
|
// this
|
|
// function. Mainly breakpoint location information of information that
|
|
// is
|
|
// unlikely to change.
|
|
// Type: Method.
|
|
// Args: vBrkPt - (R) LLDB break point object.
|
|
// vrBrkPtInfo - (W) Break point information object.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMICmnLLDBDebugSessionInfo::GetBrkPtInfo(const lldb::SBBreakpoint &vBrkPt,
|
|
SBrkPtInfo &vrwBrkPtInfo) const {
|
|
lldb::SBBreakpoint &rBrkPt = const_cast<lldb::SBBreakpoint &>(vBrkPt);
|
|
lldb::SBBreakpointLocation brkPtLoc = rBrkPt.GetLocationAtIndex(0);
|
|
lldb::SBAddress brkPtAddr = brkPtLoc.GetAddress();
|
|
lldb::SBSymbolContext symbolCntxt =
|
|
brkPtAddr.GetSymbolContext(lldb::eSymbolContextEverything);
|
|
const char *pUnkwn = "??";
|
|
lldb::SBModule rModule = symbolCntxt.GetModule();
|
|
const char *pModule =
|
|
rModule.IsValid() ? rModule.GetFileSpec().GetFilename() : pUnkwn;
|
|
MIunused(pModule);
|
|
const char *pFile = pUnkwn;
|
|
const char *pFn = pUnkwn;
|
|
const char *pFilePath = pUnkwn;
|
|
size_t nLine = 0;
|
|
lldb::addr_t nAddr = brkPtAddr.GetLoadAddress(GetTarget());
|
|
if (nAddr == LLDB_INVALID_ADDRESS)
|
|
nAddr = brkPtAddr.GetFileAddress();
|
|
|
|
lldb::SBCompileUnit rCmplUnit = symbolCntxt.GetCompileUnit();
|
|
if (rCmplUnit.IsValid()) {
|
|
lldb::SBFileSpec rFileSpec = rCmplUnit.GetFileSpec();
|
|
pFile = rFileSpec.GetFilename();
|
|
pFilePath = rFileSpec.GetDirectory();
|
|
lldb::SBFunction rFn = symbolCntxt.GetFunction();
|
|
if (rFn.IsValid())
|
|
pFn = rFn.GetName();
|
|
lldb::SBLineEntry rLnEntry = symbolCntxt.GetLineEntry();
|
|
if (rLnEntry.GetLine() > 0)
|
|
nLine = rLnEntry.GetLine();
|
|
}
|
|
|
|
vrwBrkPtInfo.m_id = vBrkPt.GetID();
|
|
vrwBrkPtInfo.m_strType = "breakpoint";
|
|
vrwBrkPtInfo.m_pc = nAddr;
|
|
vrwBrkPtInfo.m_fnName = pFn;
|
|
vrwBrkPtInfo.m_fileName = pFile;
|
|
vrwBrkPtInfo.m_path = pFilePath;
|
|
vrwBrkPtInfo.m_nLine = nLine;
|
|
vrwBrkPtInfo.m_nTimes = vBrkPt.GetHitCount();
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
// Details: Get current debugger.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: lldb::SBDebugger - current debugger.
|
|
// Throws: None.
|
|
//--
|
|
lldb::SBDebugger &CMICmnLLDBDebugSessionInfo::GetDebugger() const {
|
|
return CMICmnLLDBDebugger::Instance().GetTheDebugger();
|
|
}
|
|
|
|
//++
|
|
// Details: Get current listener.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: lldb::SBListener - current listener.
|
|
// Throws: None.
|
|
//--
|
|
lldb::SBListener &CMICmnLLDBDebugSessionInfo::GetListener() const {
|
|
return CMICmnLLDBDebugger::Instance().GetTheListener();
|
|
}
|
|
|
|
//++
|
|
// Details: Get current target.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: lldb::SBTarget - current target.
|
|
// Throws: None.
|
|
//--
|
|
lldb::SBTarget CMICmnLLDBDebugSessionInfo::GetTarget() const {
|
|
auto target = GetDebugger().GetSelectedTarget();
|
|
if (target.IsValid())
|
|
return target;
|
|
return GetDebugger().GetDummyTarget();
|
|
}
|
|
|
|
//++
|
|
// Details: Get current process.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: lldb::SBProcess - current process.
|
|
// Throws: None.
|
|
//--
|
|
lldb::SBProcess CMICmnLLDBDebugSessionInfo::GetProcess() const {
|
|
return GetTarget().GetProcess();
|
|
}
|