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
| //===-- TargetList.h --------------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_TargetList_h_
#define liblldb_TargetList_h_
#include <mutex>
#include <vector>
#include "lldb/Target/Target.h"
#include "lldb/Utility/Broadcaster.h"
namespace lldb_private {
class TargetList : public Broadcaster {
private:
friend class Debugger;
/// Constructor
///
/// The constructor for the target list is private. Clients can
/// get ahold of of the one and only target list through the
/// lldb_private::Debugger::GetSharedInstance().GetTargetList().
///
/// \see static TargetList& lldb_private::Debugger::GetTargetList().
TargetList(Debugger &debugger);
public:
/// Broadcaster event bits definitions.
enum { eBroadcastBitInterrupt = (1 << 0) };
// These two functions fill out the Broadcaster interface:
static ConstString &GetStaticBroadcasterClass();
ConstString &GetBroadcasterClass() const override {
return GetStaticBroadcasterClass();
}
~TargetList() override;
/// Create a new Target.
///
/// Clients must use this function to create a Target. This allows
/// a global list of targets to be maintained in a central location
/// so signal handlers and other global functions can use it to
/// locate an appropriate target to deliver asynchronous information
/// to.
///
/// \param[in] debugger
/// The debugger to associate this target with
///
/// \param[in] file_spec
/// The main executable file for a debug target. This value
/// can be nullptr and the file can be set later using:
/// Target::SetExecutableModule (ModuleSP&)
///
/// \param[in] triple_cstr
/// A target triple string to be used for the target. This can
/// be nullptr if the triple is not known or when attaching to a
/// process.
///
/// \param[in] get_dependent_modules
/// Track down the dependent modules for an executable and
/// load those into the module list.
///
/// \param[in] platform_options
/// A pointer to the platform options to use when creating this
/// target. If this value is nullptr, then the currently selected
/// platform will be used.
///
/// \param[out] target_sp
/// A shared pointer to a target that will be filled in if
/// this call is successful.
///
/// \return
/// An error object that indicates success or failure
Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path,
llvm::StringRef triple_str,
LoadDependentFiles get_dependent_modules,
const OptionGroupPlatform *platform_options,
lldb::TargetSP &target_sp);
/// Create a new Target.
///
/// Same as the function above, but used when you already know the
/// platform you will be using
Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path,
const ArchSpec &arch,
LoadDependentFiles get_dependent_modules,
lldb::PlatformSP &platform_sp, lldb::TargetSP &target_sp);
/// Delete a Target object from the list.
///
/// When clients are done with the Target objects, this function
/// should be called to release the memory associated with a target
/// object.
///
/// \param[in] target_sp
/// The shared pointer to a target.
///
/// \return
/// Returns \b true if the target was successfully removed from
/// from this target list, \b false otherwise. The client will
/// be left with the last remaining shared pointer to the target
/// in \a target_sp which can then be properly released.
bool DeleteTarget(lldb::TargetSP &target_sp);
int GetNumTargets() const;
lldb::TargetSP GetTargetAtIndex(uint32_t index) const;
uint32_t GetIndexOfTarget(lldb::TargetSP target_sp) const;
/// Find the target that contains has an executable whose path
/// matches \a exe_file_spec, and whose architecture matches
/// \a arch_ptr if arch_ptr is not nullptr.
///
/// \param[in] exe_file_spec
/// A file spec containing a basename, or a full path (directory
/// and basename). If \a exe_file_spec contains only a filename
/// (empty GetDirectory() value) then matching will be done
/// solely based on the filenames and directories won't be
/// compared. If \a exe_file_spec contains a filename and a
/// directory, then both must match.
///
/// \param[in] exe_arch_ptr
/// If not nullptr then the architecture also needs to match, else
/// the architectures will be compared.
///
/// \return
/// A shared pointer to a target object. The returned shared
/// pointer will contain nullptr if no target objects have a
/// executable whose full or partial path matches
/// with a matching process ID.
lldb::TargetSP FindTargetWithExecutableAndArchitecture(
const FileSpec &exe_file_spec,
const ArchSpec *exe_arch_ptr = nullptr) const;
/// Find the target that contains a process with process ID \a
/// pid.
///
/// \param[in] pid
/// The process ID to search our target list for.
///
/// \return
/// A shared pointer to a target object. The returned shared
/// pointer will contain nullptr if no target objects own a process
/// with a matching process ID.
lldb::TargetSP FindTargetWithProcessID(lldb::pid_t pid) const;
lldb::TargetSP FindTargetWithProcess(lldb_private::Process *process) const;
lldb::TargetSP GetTargetSP(Target *target) const;
/// Send an async interrupt to one or all processes.
///
/// Find the target that contains the process with process ID \a
/// pid and send a LLDB_EVENT_ASYNC_INTERRUPT event to the process's
/// event queue.
///
/// \param[in] pid
/// The process ID to search our target list for, if \a pid is
/// LLDB_INVALID_PROCESS_ID, then the interrupt will be sent to
/// all processes.
///
/// \return
/// The number of async interrupts sent.
uint32_t SendAsyncInterrupt(lldb::pid_t pid = LLDB_INVALID_PROCESS_ID);
uint32_t SignalIfRunning(lldb::pid_t pid, int signo);
uint32_t SetSelectedTarget(Target *target);
lldb::TargetSP GetSelectedTarget();
protected:
typedef std::vector<lldb::TargetSP> collection;
// Member variables.
collection m_target_list;
lldb::TargetSP m_dummy_target_sp;
mutable std::recursive_mutex m_target_list_mutex;
uint32_t m_selected_target_idx;
private:
lldb::TargetSP GetDummyTarget(lldb_private::Debugger &debugger);
Status CreateDummyTarget(Debugger &debugger,
llvm::StringRef specified_arch_name,
lldb::TargetSP &target_sp);
Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
llvm::StringRef triple_str,
LoadDependentFiles load_dependent_files,
const OptionGroupPlatform *platform_options,
lldb::TargetSP &target_sp, bool is_dummy_target);
Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
const ArchSpec &arch,
LoadDependentFiles get_dependent_modules,
lldb::PlatformSP &platform_sp,
lldb::TargetSP &target_sp, bool is_dummy_target);
DISALLOW_COPY_AND_ASSIGN(TargetList);
};
} // namespace lldb_private
#endif // liblldb_TargetList_h_
|