LLDB API Documentation

- Main Page
- Namespaces
- Classes
- Files

- File List

SBAttachInfo.h
Go to the documentation of this file.
1 //===-- SBAttachInfo.h ------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #ifndef LLDB_SBAttachInfo_h_
11 #define LLDB_SBAttachInfo_h_
12
13 #include "lldb/API/SBDefines.h"
14
15 namespace lldb {
16
17 class SBTarget;
18
19 class LLDB_API SBAttachInfo {
20 public:
21 SBAttachInfo();
22
23 SBAttachInfo(lldb::pid_t pid);
24
25 //------------------------------------------------------------------
26 /// Attach to a process by name.
27 ///
28 /// This function implies that a future call to SBTarget::Attach(...)
29 /// will be synchronous.
30 ///
31 /// @param[in] path
32 /// A full or partial name for the process to attach to.
33 ///
34 /// @param[in] wait_for
35 /// If \b false, attach to an existing process whose name matches.
36 /// If \b true, then wait for the next process whose name matches.
37 //------------------------------------------------------------------
38 SBAttachInfo(const char *path, bool wait_for);
39
40 //------------------------------------------------------------------
41 /// Attach to a process by name.
42 ///
43 /// Future calls to SBTarget::Attach(...) will be synchronous or
44 /// asynchronous depending on the \a async argument.
45 ///
46 /// @param[in] path
47 /// A full or partial name for the process to attach to.
48 ///
49 /// @param[in] wait_for
50 /// If \b false, attach to an existing process whose name matches.
51 /// If \b true, then wait for the next process whose name matches.
52 ///
53 /// @param[in] async
54 /// If \b false, then the SBTarget::Attach(...) call will be a
55 /// synchronous call with no way to cancel the attach in
56 /// progress.
57 /// If \b true, then the SBTarget::Attach(...) function will
58 /// return immediately and clients are expected to wait for a
59 /// process eStateStopped event if a suitable process is
60 /// eventually found. If the client wants to cancel the event,
61 /// SBProcess::Stop() can be called and an eStateExited process
62 /// event will be delivered.
63 //------------------------------------------------------------------
64 SBAttachInfo(const char *path, bool wait_for, bool async);
65
66 SBAttachInfo(const SBAttachInfo &rhs);
67
68 ~SBAttachInfo();
69
70 SBAttachInfo &operator=(const SBAttachInfo &rhs);
71
72 lldb::pid_t GetProcessID();
73
74 void SetProcessID(lldb::pid_t pid);
75
76 void SetExecutable(const char *path);
77
78 void SetExecutable(lldb::SBFileSpec exe_file);
79
80 bool GetWaitForLaunch();
81
82 //------------------------------------------------------------------
83 /// Set attach by process name settings.
84 ///
85 /// Designed to be used after a call to SBAttachInfo::SetExecutable().
86 /// This function implies that a call to SBTarget::Attach(...) will
87 /// be synchronous.
88 ///
89 /// @param[in] wait_for
90 /// If \b false, attach to an existing process whose name matches.
91 /// If \b true, then wait for the next process whose name matches.
92 //------------------------------------------------------------------
93 void SetWaitForLaunch(bool b);
94
95 //------------------------------------------------------------------
96 /// Set attach by process name settings.
97 ///
98 /// Designed to be used after a call to SBAttachInfo::SetExecutable().
99 /// Future calls to SBTarget::Attach(...) will be synchronous or
100 /// asynchronous depending on the \a async argument.
101 ///
102 /// @param[in] wait_for
103 /// If \b false, attach to an existing process whose name matches.
104 /// If \b true, then wait for the next process whose name matches.
105 ///
106 /// @param[in] async
107 /// If \b false, then the SBTarget::Attach(...) call will be a
108 /// synchronous call with no way to cancel the attach in
109 /// progress.
110 /// If \b true, then the SBTarget::Attach(...) function will
111 /// return immediately and clients are expected to wait for a
112 /// process eStateStopped event if a suitable process is
113 /// eventually found. If the client wants to cancel the event,
114 /// SBProcess::Stop() can be called and an eStateExited process
115 /// event will be delivered.
116 //------------------------------------------------------------------
117 void SetWaitForLaunch(bool b, bool async);
118
119 bool GetIgnoreExisting();
120
121 void SetIgnoreExisting(bool b);
122
123 uint32_t GetResumeCount();
124
125 void SetResumeCount(uint32_t c);
126
127 const char *GetProcessPluginName();
128
129 void SetProcessPluginName(const char *plugin_name);
130
131 uint32_t GetUserID();
132
133 uint32_t GetGroupID();
134
135 bool UserIDIsValid();
136
137 bool GroupIDIsValid();
138
139 void SetUserID(uint32_t uid);
140
141 void SetGroupID(uint32_t gid);
142
143 uint32_t GetEffectiveUserID();
144
145 uint32_t GetEffectiveGroupID();
146
147 bool EffectiveUserIDIsValid();
148
149 bool EffectiveGroupIDIsValid();
150
151 void SetEffectiveUserID(uint32_t uid);
152
153 void SetEffectiveGroupID(uint32_t gid);
154
155 lldb::pid_t GetParentProcessID();
156
157 void SetParentProcessID(lldb::pid_t pid);
158
159 bool ParentProcessIDIsValid();
160
161 //----------------------------------------------------------------------
162 /// Get the listener that will be used to receive process events.
163 ///
164 /// If no listener has been set via a call to
165 /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
166 /// returned (SBListener::IsValid() will return false). If a listener
167 /// has been set, then the valid listener object will be returned.
168 //----------------------------------------------------------------------
169 SBListener GetListener();
170
171 //----------------------------------------------------------------------
172 /// Set the listener that will be used to receive process events.
173 ///
174 /// By default the SBDebugger, which has a listener, that the SBTarget
175 /// belongs to will listen for the process events. Calling this function
176 /// allows a different listener to be used to listen for process events.
177 //----------------------------------------------------------------------
178 void SetListener(SBListener &listener);
179
180 protected:
181 friend class SBTarget;
182
183 lldb_private::ProcessAttachInfo &ref();
184
185 ProcessAttachInfoSP m_opaque_sp;
186 };
187
188 } // namespace lldb
189
190 #endif // LLDB_SBAttachInfo_h_
lldb::SBAttachInfo
Definition: SBAttachInfo.h:19
lldb::SBTarget
class LLDB_API SBTarget
Definition: SBDefines.h:78
SBDefines.h
lldb::SBAttachInfo::m_opaque_sp
ProcessAttachInfoSP m_opaque_sp
Definition: SBAttachInfo.h:185
lldb::SBFileSpec
Definition: SBFileSpec.h:17
lldb::SBListener
Definition: SBListener.h:17
lldb::SBTarget
Definition: SBTarget.h:34