1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
//===-- MICmnLLDBDebugSessionInfo.h -----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//++
// File: MICmnLLDBDebugSessionInfo.h
//
// Overview: CMICmnLLDBDebugSessionInfo interface.
//
// Environment: Compilers: Visual C++ 12.
// gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
// Libraries: See MIReadmetxt.
//
// Copyright: None.
//--
#pragma once
// Third party headers:
#include <map>
#include <vector>
#include <lldb/API/SBDebugger.h>
#include <lldb/API/SBListener.h>
#include <lldb/API/SBProcess.h>
#include <lldb/API/SBTarget.h>
// In-house headers:
#include "MICmnBase.h"
#include "MIUtilSingletonBase.h"
#include "MICmnLLDBDebugSessionInfoVarObj.h"
#include "MICmnMIValueTuple.h"
#include "MIUtilMapIdToVariant.h"
// Declarations:
class CMICmnLLDBDebugger;
struct SMICmdData;
class CMICmnMIValueTuple;
class CMICmnMIValueList;
//++ ============================================================================
// Details: MI debug session object that holds debugging information between
// instances of MI commands executing their work and producing MI
// result records. Information/data is set by one or many commands then
// retrieved by the same or other sebsequent commands.
// It primarily to hold LLDB type objects.
// A singleton class.
// Gotchas: None.
// Authors: Illya Rudkin 04/03/2014.
// Changes: None.
//--
class CMICmnLLDBDebugSessionInfo
: public CMICmnBase
, public MI::ISingleton< CMICmnLLDBDebugSessionInfo >
{
friend class MI::ISingleton< CMICmnLLDBDebugSessionInfo >;
// Structs:
public:
//++ ============================================================================
// Details: Break point information object. Used to easily pass information about
// a break around and record break point information to be recalled by
// other commands or LLDB event handling functions.
//--
struct SBrkPtInfo
{
SBrkPtInfo( void )
: m_id( 0 )
, m_bDisp( false )
, m_bEnabled( false )
, m_pc( 0 )
, m_nLine( 0 )
, m_bHaveArgOptionThreadGrp( false )
, m_nTimes( 0 )
, m_bPending( false )
, m_nIgnore( 0 )
, m_bCondition( false )
, m_bBrkPtThreadId( false )
, m_nBrkPtThreadId( 0 )
{
}
MIuint m_id; // LLDB break point ID.
CMIUtilString m_strType; // Break point type.
bool m_bDisp ; // True = "del", false = "keep".
bool m_bEnabled; // True = enabled, false = disabled break point.
MIuint m_pc; // Address number.
CMIUtilString m_fnName; // Function name.
CMIUtilString m_fileName; // File name text.
CMIUtilString m_path; // Full file name and path text.
MIuint m_nLine; // File line number.
bool m_bHaveArgOptionThreadGrp; // True = include MI field, false = do not include "thread-groups".
CMIUtilString m_strOptThrdGrp; // Thread group number.
MIuint m_nTimes; // The count of the breakpoint existence.
CMIUtilString m_strOrigLoc; // The name of the break point.
bool m_bPending; // True = the breakpoint has not been established yet, false = location found
MIuint m_nIgnore; // The number of time the breakpoint is run over before it is stopped on a hit
bool m_bCondition; // True = break point is conditional, use condition expression, false = no condition
CMIUtilString m_strCondition; // Break point condition expression
bool m_bBrkPtThreadId; // True = break point is specified to work with a specific thread, false = no specified thread given
MIuint m_nBrkPtThreadId; // Restrict the breakpoint to the specified thread-id
};
// Typedefs:
public:
typedef std::vector< uint32_t > VecActiveThreadId_t;
// Methods:
public:
bool Initialize( void );
bool Shutdown( void );
// Variant type data which can be assigned and retrieved across all command instances
template< typename T >
bool SharedDataAdd( const CMIUtilString & vKey, const T & vData );
template< typename T >
bool SharedDataRetrieve( const CMIUtilString & vKey, T & vwData );
bool SharedDataDestroy( void );
// Common command required functionality
bool AccessPath( const CMIUtilString & vPath, bool & vwbYesAccessible );
bool GetFrameInfo( const lldb::SBFrame & vrFrame, lldb::addr_t & vwPc, CMIUtilString & vwFnName, CMIUtilString & vwFileName, CMIUtilString & vwPath, MIuint & vwnLine );
bool GetThreadFrames( const SMICmdData & vCmdData, const MIuint vThreadIdx, CMIUtilString & vwrThreadFrames );
bool GetThreadFrames2( const SMICmdData & vCmdData, const MIuint vThreadIdx, CMIUtilString & vwrThreadFrames );
bool ResolvePath( const SMICmdData & vCmdData, const CMIUtilString & vPath, CMIUtilString & vwrResolvedPath );
bool ResolvePath( const CMIUtilString & vstrUnknown, CMIUtilString & vwrResolvedPath );
bool MIResponseFormFrameInfo( const lldb::SBThread & vrThread, const MIuint vnLevel, CMICmnMIValueTuple & vwrMiValueTuple );
bool MIResponseFormFrameInfo( const lldb::addr_t vPc, const CMIUtilString & vFnName, const CMIUtilString & vFileName, const CMIUtilString & vPath, const MIuint vnLine, CMICmnMIValueTuple & vwrMiValueTuple );
bool MIResponseFormFrameInfo2( const lldb::addr_t vPc, const CMIUtilString & vArgInfo, const CMIUtilString & vFnName, const CMIUtilString & vFileName, const CMIUtilString & vPath, const MIuint vnLine, CMICmnMIValueTuple & vwrMiValueTuple );
bool MIResponseFormThreadInfo( const SMICmdData & vCmdData, const lldb::SBThread & vrThread, CMICmnMIValueTuple & vwrMIValueTuple );
bool MIResponseFormThreadInfo2( const SMICmdData & vCmdData, const lldb::SBThread & vrThread, CMICmnMIValueTuple & vwrMIValueTuple );
bool MIResponseFormThreadInfo3( const SMICmdData & vCmdData, const lldb::SBThread & vrThread, CMICmnMIValueTuple & vwrMIValueTuple );
bool MIResponseFormVariableInfo( const lldb::SBFrame & vrFrame, const MIuint vMaskVarTypes, CMICmnMIValueList & vwrMiValueList );
bool MIResponseFormVariableInfo2( const lldb::SBFrame & vrFrame, const MIuint vMaskVarTypes, CMICmnMIValueList & vwrMiValueList );
bool MIResponseFormVariableInfo3( const lldb::SBFrame & vrFrame, const MIuint vMaskVarTypes, CMICmnMIValueList & vwrMiValueList );
bool MIResponseFormBrkPtFrameInfo( const SBrkPtInfo & vrBrkPtInfo, CMICmnMIValueTuple & vwrMiValueTuple );
bool MIResponseFormBrkPtInfo( const SBrkPtInfo & vrBrkPtInfo, CMICmnMIValueTuple & vwrMiValueTuple );
bool GetBrkPtInfo( const lldb::SBBreakpoint & vBrkPt, SBrkPtInfo & vrwBrkPtInfo ) const;
bool RecordBrkPtInfo( const MIuint vnBrkPtId, const SBrkPtInfo & vrBrkPtInfo );
bool RecordBrkPtInfoGet( const MIuint vnBrkPtId, SBrkPtInfo & vrwBrkPtInfo ) const;
bool RecordBrkPtInfoDelete( const MIuint vnBrkPtId );
// Attributes:
public:
// The following are available to all command instances
lldb::SBDebugger & m_rLldbDebugger;
lldb::SBListener & m_rLlldbListener;
lldb::SBTarget m_lldbTarget;
lldb::SBProcess m_lldbProcess;
const MIuint m_nBrkPointCntMax;
VecActiveThreadId_t m_vecActiveThreadId;
lldb::tid_t m_currentSelectedThread;
// These are keys that can be used to access the shared data map
// Note: This list is expected to grow and will be moved and abstracted in the future.
const CMIUtilString m_constStrSharedDataKeyWkDir;
const CMIUtilString m_constStrSharedDataSolibPath;
// Typedefs:
private:
typedef std::vector< CMICmnLLDBDebugSessionInfoVarObj > VecVarObj_t;
typedef std::map< MIuint, SBrkPtInfo > MapBrkPtIdToBrkPtInfo_t;
typedef std::pair< MIuint, SBrkPtInfo > MapPairBrkPtIdToBrkPtInfo_t;
// Methods:
private:
/* ctor */ CMICmnLLDBDebugSessionInfo( void );
/* ctor */ CMICmnLLDBDebugSessionInfo( const CMICmnLLDBDebugSessionInfo & );
void operator=( const CMICmnLLDBDebugSessionInfo & );
//
bool GetVariableInfo( const MIuint vnMaxDepth, const lldb::SBValue & vrValue, const bool vbIsChildValue, CMICmnMIValueList & vwrMiValueList, MIuint & vrwnDepth );
bool GetVariableInfo2( const MIuint vnMaxDepth, const lldb::SBValue & vrValue, const bool vbIsChildValue, CMICmnMIValueList & vwrMiValueList, MIuint & vrwnDepth );
// Overridden:
private:
// From CMICmnBase
/* dtor */ virtual ~CMICmnLLDBDebugSessionInfo( void );
// Attributes:
private:
CMIUtilMapIdToVariant m_mapIdToSessionData; // Hold and retrieve key to value data available across all commands
VecVarObj_t m_vecVarObj; // Vector of session variable objects
MapBrkPtIdToBrkPtInfo_t m_mapBrkPtIdToBrkPtInfo;
};
//++ ------------------------------------------------------------------------------------
// Details: Command instances can create and share data between other instances of commands.
// This function adds new data to the shared data. Using the same ID more than
// once replaces any previous matching data keys.
// Type: Template method.
// Args: T - The type of the object to be stored.
// vKey - (R) A non empty unique data key to retrieve the data by.
// vData - (R) Data to be added to the share.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
template< typename T >
bool CMICmnLLDBDebugSessionInfo::SharedDataAdd( const CMIUtilString & vKey, const T & vData )
{
if( !m_mapIdToSessionData.Add< T >( vKey, vData ) )
{
SetErrorDescription( m_mapIdToSessionData.GetErrorDescription() );
return MIstatus::failure;
}
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Command instances can create and share data between other instances of commands.
// This function retrieves data from the shared data container.
// Type: Method.
// Args: T - The type of the object being retrieved.
// vKey - (R) A non empty unique data key to retrieve the data by.
// vData - (W) The data.
// Return: bool - True = data found, false = data not found or an error occurred trying to fetch.
// Throws: None.
//--
template< typename T >
bool CMICmnLLDBDebugSessionInfo::SharedDataRetrieve( const CMIUtilString & vKey, T & vwData )
{
bool bDataFound = false;
if( !m_mapIdToSessionData.Get< T >( vKey, vwData, bDataFound ) )
{
SetErrorDescription( m_mapIdToSessionData.GetErrorDescription() );
return MIstatus::failure;
}
return bDataFound;
}
|
