LLDB mainline
ProcessGDBRemote.h
Go to the documentation of this file.
1//===-- ProcessGDBRemote.h --------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
10#define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
11
12#include <atomic>
13#include <map>
14#include <mutex>
15#include <optional>
16#include <string>
17#include <vector>
18
24#include "lldb/Target/Process.h"
25#include "lldb/Target/Thread.h"
30#include "lldb/Utility/Status.h"
36
39
40#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/StringMap.h"
42
43namespace lldb_private {
44namespace repro {
45class Loader;
46}
47namespace process_gdb_remote {
48
49class ThreadGDBRemote;
50
53public:
54 ~ProcessGDBRemote() override;
55
57 lldb::ListenerSP listener_sp,
58 const FileSpec *crash_file_path,
59 bool can_connect);
60
61 static void Initialize();
62
63 static void DebuggerInitialize(Debugger &debugger);
64
65 static void Terminate();
66
67 static llvm::StringRef GetPluginNameStatic() { return "gdb-remote"; }
68
69 static llvm::StringRef GetPluginDescriptionStatic();
70
71 static std::chrono::seconds GetPacketTimeout();
72
74
75 // Check if a given Process
76 bool CanDebug(lldb::TargetSP target_sp,
77 bool plugin_specified_by_name) override;
78
80
81 void DumpPluginHistory(Stream &s) override;
82
83 // Creating a new process, or attaching to an existing one
84 Status DoWillLaunch(Module *module) override;
85
86 Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override;
87
88 void DidLaunch() override;
89
91
92 Status DoWillAttachToProcessWithName(const char *process_name,
93 bool wait_for_launch) override;
94
95 Status DoConnectRemote(llvm::StringRef remote_url) override;
96
98
100 const ProcessAttachInfo &attach_info) override;
101
102 Status
103 DoAttachToProcessWithName(const char *process_name,
104 const ProcessAttachInfo &attach_info) override;
105
106 void DidAttach(ArchSpec &process_arch) override;
107
108 // PluginInterface protocol
109 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
110
111 // Process Control
112 Status WillResume() override;
113
114 Status DoResume() override;
115
116 Status DoHalt(bool &caused_stop) override;
117
118 Status DoDetach(bool keep_stopped) override;
119
120 bool DetachRequiresHalt() override { return true; }
121
122 Status DoSignal(int signal) override;
123
124 Status DoDestroy() override;
125
126 void RefreshStateAfterStop() override;
127
128 void SetUnixSignals(const lldb::UnixSignalsSP &signals_sp);
129
130 // Process Queries
131 bool IsAlive() override;
132
134
135 void WillPublicStop() override;
136
137 // Process Memory
138 size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
139 Status &error) override;
140
141 Status
142 WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) override;
143
144 size_t DoWriteMemory(lldb::addr_t addr, const void *buf, size_t size,
145 Status &error) override;
146
147 lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions,
148 Status &error) override;
149
151
152 // Process STDIO
153 size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override;
154
155 // Process Breakpoints
156 Status EnableBreakpointSite(BreakpointSite *bp_site) override;
157
159
160 // Process Watchpoints
162 bool notify = true) override;
163
165 bool notify = true) override;
166
167 std::optional<uint32_t> GetWatchpointSlotCount() override;
168
169 llvm::Expected<TraceSupportedResponse> TraceSupported() override;
170
171 llvm::Error TraceStop(const TraceStopRequest &request) override;
172
173 llvm::Error TraceStart(const llvm::json::Value &request) override;
174
175 llvm::Expected<std::string> TraceGetState(llvm::StringRef type) override;
176
177 llvm::Expected<std::vector<uint8_t>>
178 TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override;
179
180 std::optional<bool> DoGetWatchpointReportedAfter() override;
181
182 bool StartNoticingNewThreads() override;
183
184 bool StopNoticingNewThreads() override;
185
187
188 Status SendEventData(const char *data) override;
189
190 // Override DidExit so we can disconnect from the remote GDB server
191 void DidExit() override;
192
193 void SetUserSpecifiedMaxMemoryTransferSize(uint64_t user_specified_max);
194
195 bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch,
196 ModuleSpec &module_spec) override;
197
198 void PrefetchModuleSpecs(llvm::ArrayRef<FileSpec> module_file_specs,
199 const llvm::Triple &triple) override;
200
201 llvm::VersionTuple GetHostOSVersion() override;
202 llvm::VersionTuple GetHostMacCatalystVersion() override;
203
204 llvm::Error LoadModules() override;
205
206 llvm::Expected<LoadedModuleInfoList> GetLoadedModuleList() override;
207
208 Status GetFileLoadAddress(const FileSpec &file, bool &is_loaded,
209 lldb::addr_t &load_addr) override;
210
211 void ModulesDidLoad(ModuleList &module_list) override;
212
215 lldb::addr_t image_count) override;
216
217 Status
218 ConfigureStructuredData(llvm::StringRef type_name,
219 const StructuredData::ObjectSP &config_sp) override;
220
222
224 const std::vector<lldb::addr_t> &load_addresses) override;
225
228
230
232
234 StringExtractorGDBRemote &inputStringExtractor);
235
236 void DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
237 void DidVFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override;
238 void DidVForkDone() override;
239 void DidExec() override;
240
241 llvm::Expected<bool> SaveCore(llvm::StringRef outfile) override;
242
243protected:
244 friend class ThreadGDBRemote;
247
248 ProcessGDBRemote(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
249
250 bool SupportsMemoryTagging() override;
251
252 /// Broadcaster event bits definitions.
253 enum {
257 };
258
260 std::atomic<lldb::pid_t> m_debugserver_pid;
261
262 std::optional<StringExtractorGDBRemote> m_last_stop_packet;
263 std::recursive_mutex m_last_stop_packet_mutex;
264
269 std::recursive_mutex m_async_thread_state_mutex;
270 typedef std::vector<lldb::tid_t> tid_collection;
271 typedef std::vector<std::pair<lldb::tid_t, int>> tid_sig_collection;
272 typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;
273 typedef std::map<uint32_t, std::string> ExpeditedRegisterMap;
274 tid_collection m_thread_ids; // Thread IDs for all threads. This list gets
275 // updated after stopping
276 std::vector<lldb::addr_t> m_thread_pcs; // PC values for all the threads.
277 StructuredData::ObjectSP m_jstopinfo_sp; // Stop info only for any threads
278 // that have valid stop infos
279 StructuredData::ObjectSP m_jthreadsinfo_sp; // Full stop info, expedited
280 // registers and memory for all
281 // threads if "jThreadsInfo"
282 // packet is supported
284 tid_sig_collection m_continue_C_tids; // 'C' for continue with signal
286 tid_sig_collection m_continue_S_tids; // 'S' for step with signal
287 uint64_t m_max_memory_size; // The maximum number of bytes to read/write when
288 // reading and writing memory
289 uint64_t m_remote_stub_max_memory_size; // The maximum memory size the remote
290 // gdb stub can handle
296 lldb::tid_t m_initial_tid; // The initial thread ID, given by stub on attach
298
303
304 // Number of vfork() operations being handled.
306
307 // Accessors
309 return state == lldb::eStateRunning || IsStepping(state);
310 }
311
313 return state == lldb::eStateStepping;
314 }
315
316 bool CanResume(lldb::StateType state) { return state == lldb::eStateStopped; }
317
318 bool HasExited(lldb::StateType state) { return state == lldb::eStateExited; }
319
320 void Clear();
321
322 bool DoUpdateThreadList(ThreadList &old_thread_list,
323 ThreadList &new_thread_list) override;
324
326
328
330
331 void BuildDynamicRegisterInfo(bool force);
332
333 void SetLastStopPacket(const StringExtractorGDBRemote &response);
334
335 bool ParsePythonTargetDefinition(const FileSpec &target_definition_fspec);
336
337 DataExtractor GetAuxvData() override;
338
340
341 void GetMaxMemorySize();
342
344
345 size_t UpdateThreadPCsFromStopReplyThreadsValue(llvm::StringRef value);
346
347 size_t UpdateThreadIDsFromStopReplyThreadsValue(llvm::StringRef value);
348
349 bool StartAsyncThread();
350
351 void StopAsyncThread();
352
354
355 static void
356 MonitorDebugserverProcess(std::weak_ptr<ProcessGDBRemote> process_wp,
357 lldb::pid_t pid, int signo, int exit_status);
358
360
361 bool
363 const StructuredData::ObjectSP &thread_infos_sp);
364
366
369 ExpeditedRegisterMap &expedited_register_map, uint8_t signo,
370 const std::string &thread_name, const std::string &reason,
371 const std::string &description, uint32_t exc_type,
372 const std::vector<lldb::addr_t> &exc_data,
373 lldb::addr_t thread_dispatch_qaddr, bool queue_vars_valid,
374 lldb_private::LazyBool associated_with_libdispatch_queue,
375 lldb::addr_t dispatch_queue_t, std::string &queue_name,
376 lldb::QueueKind queue_kind, uint64_t queue_serial);
377
378 void ClearThreadIDList();
379
380 bool UpdateThreadIDList();
381
382 void DidLaunchOrAttach(ArchSpec &process_arch);
383 void LoadStubBinaries();
385
386 Status ConnectToDebugserver(llvm::StringRef host_port);
387
388 const char *GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr,
389 std::string &dispatch_queue_name);
390
392
394 ArchSpec &arch_to_use, std::string xml_filename,
395 std::vector<DynamicRegisterInfo::Register> &registers);
396
397 // Convert DynamicRegisterInfo::Registers into RegisterInfos and add
398 // to the dynamic register list.
399 void AddRemoteRegisters(std::vector<DynamicRegisterInfo::Register> &registers,
400 const ArchSpec &arch_to_use);
401 // Query remote GDBServer for register information
403
405 lldb::addr_t link_map,
406 lldb::addr_t base_addr,
407 bool value_is_offset);
408
410
411 Status FlashErase(lldb::addr_t addr, size_t size);
412
414
415 bool HasErased(FlashRange range);
416
417 llvm::Expected<std::vector<uint8_t>>
418 DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type) override;
419
420 Status DoWriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type,
421 const std::vector<uint8_t> &tags) override;
422
424 MemoryRegionInfo &region_info) override;
425
426private:
427 // For ProcessGDBRemote only
429 std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map;
431
432 static bool NewThreadNotifyBreakpointHit(void *baton,
434 lldb::user_id_t break_id,
435 lldb::user_id_t break_loc_id);
436
437 // ContinueDelegate interface
438 void HandleAsyncStdout(llvm::StringRef out) override;
439 void HandleAsyncMisc(llvm::StringRef data) override;
440 void HandleStopReply() override;
441 void HandleAsyncStructuredDataPacket(llvm::StringRef data) override;
442
443 void SetThreadPc(const lldb::ThreadSP &thread_sp, uint64_t index);
444 using ModuleCacheKey = std::pair<std::string, std::string>;
445 // KeyInfo for the cached module spec DenseMap.
446 // The invariant is that all real keys will have the file and architecture
447 // set.
448 // The empty key has an empty file and an empty arch.
449 // The tombstone key has an invalid arch and an empty file.
450 // The comparison and hash functions take the file name and architecture
451 // triple into account.
454
455 static ModuleCacheKey getTombstoneKey() { return ModuleCacheKey("", "T"); }
456
457 static unsigned getHashValue(const ModuleCacheKey &key) {
458 return llvm::hash_combine(key.first, key.second);
459 }
460
461 static bool isEqual(const ModuleCacheKey &LHS, const ModuleCacheKey &RHS) {
462 return LHS == RHS;
463 }
464 };
465
466 llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>
468
471
472 // fork helpers
473 void DidForkSwitchSoftwareBreakpoints(bool enable);
474 void DidForkSwitchHardwareTraps(bool enable);
475
476 void ParseExpeditedRegisters(ExpeditedRegisterMap &expedited_register_map,
477 lldb::ThreadSP thread_sp);
478
479 // Lists of register fields generated from the remote's target XML.
480 // Pointers to these RegisterFlags will be set in the register info passed
481 // back to the upper levels of lldb. Doing so is safe because this class will
482 // live at least as long as the debug session. We therefore do not store the
483 // data directly in the map because the map may reallocate it's storage as new
484 // entries are added. Which would invalidate any pointers set in the register
485 // info up to that point.
486 llvm::StringMap<std::unique_ptr<RegisterFlags>> m_registers_flags_types;
487};
488
489} // namespace process_gdb_remote
490} // namespace lldb_private
491
492#endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H
static llvm::raw_ostream & error(Stream &strm)
An architecture specification class.
Definition: ArchSpec.h:31
Class that manages the actual breakpoint that will be inserted into the running program.
An event broadcasting class.
Definition: Broadcaster.h:145
An data extractor class.
Definition: DataExtractor.h:48
A class to manage flag bits.
Definition: Debugger.h:80
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
A file utility class.
Definition: FileSpec.h:56
A collection class for Module objects.
Definition: ModuleList.h:103
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
Range< lldb::addr_t, size_t > Entry
Definition: RangeMap.h:140
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
std::shared_ptr< Object > ObjectSP
Status FlashErase(lldb::addr_t addr, size_t size)
Status DisableWatchpoint(lldb::WatchpointSP wp_sp, bool notify=true) override
Status DoConnectRemote(llvm::StringRef remote_url) override
Attach to a remote system via a URL.
void HandleAsyncStructuredDataPacket(llvm::StringRef data) override
Process asynchronously-received structured data.
Status LaunchAndConnectToDebugserver(const ProcessInfo &process_info)
lldb::StateType SetThreadStopInfo(StringExtractor &stop_packet)
static void MonitorDebugserverProcess(std::weak_ptr< ProcessGDBRemote > process_wp, lldb::pid_t pid, int signo, int exit_status)
StructuredData::ObjectSP GetSharedCacheInfo() override
Status DisableBreakpointSite(BreakpointSite *bp_site) override
Status EnableWatchpoint(lldb::WatchpointSP wp_sp, bool notify=true) override
Status DoSignal(int signal) override
Sends a process a UNIX signal signal.
Status DoDeallocateMemory(lldb::addr_t ptr) override
Actually deallocate memory in the process.
bool ParsePythonTargetDefinition(const FileSpec &target_definition_fspec)
bool StopNoticingNewThreads() override
Call this to turn off the stop & notice new threads mode.
static bool NewThreadNotifyBreakpointHit(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
void DumpPluginHistory(Stream &s) override
The underlying plugin might store the low-level communication history for this session.
Status DoDetach(bool keep_stopped) override
Detaches from a running or stopped process.
lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions, Status &error) override
Actually allocate memory in the process.
std::optional< bool > DoGetWatchpointReportedAfter() override
Provide an override value in the subclass for lldb's CPU-based logic for whether watchpoint exception...
std::optional< uint32_t > GetWatchpointSlotCount() override
Get the number of watchpoints supported by this target.
llvm::Expected< std::vector< uint8_t > > DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type) override
Does the final operation to read memory tags.
llvm::DenseMap< ModuleCacheKey, ModuleSpec, ModuleCacheInfo > m_cached_module_specs
Status DoWillAttachToProcessWithID(lldb::pid_t pid) override
Called before attaching to a process.
const ProcessGDBRemote & operator=(const ProcessGDBRemote &)=delete
Status DoGetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &region_info) override
DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has removed non address bits from loa...
size_t UpdateThreadIDsFromStopReplyThreadsValue(llvm::StringRef value)
Status GetFileLoadAddress(const FileSpec &file, bool &is_loaded, lldb::addr_t &load_addr) override
Try to find the load address of a file.
bool GetThreadStopInfoFromJSON(ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp)
void DidLaunch() override
Called after launching a process.
void SetUserSpecifiedMaxMemoryTransferSize(uint64_t user_specified_max)
void AddRemoteRegisters(std::vector< DynamicRegisterInfo::Register > &registers, const ArchSpec &arch_to_use)
void HandleAsyncStdout(llvm::StringRef out) override
std::map< uint32_t, std::string > ExpeditedRegisterMap
llvm::Error TraceStop(const TraceStopRequest &request) override
Stop tracing a live process or its threads.
StructuredData::ObjectSP GetExtendedInfoForThread(lldb::tid_t tid)
llvm::Expected< LoadedModuleInfoList > GetLoadedModuleList() override
Query remote GDBServer for a detailed loaded library list.
Status DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo &attach_info) override
Attach to an existing process using a process ID.
Status EstablishConnectionIfNeeded(const ProcessInfo &process_info)
void DidFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override
Called after a reported fork.
StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override
Status DoHalt(bool &caused_stop) override
Halts a running process.
llvm::Expected< TraceSupportedResponse > TraceSupported() override
Get the processor tracing type supported for this process.
llvm::Error TraceStart(const llvm::json::Value &request) override
Start tracing a process or its threads.
void ParseExpeditedRegisters(ExpeditedRegisterMap &expedited_register_map, lldb::ThreadSP thread_sp)
void WillPublicStop() override
Called when the process is about to broadcast a public stop.
const char * GetDispatchQueueNameForThread(lldb::addr_t thread_dispatch_qaddr, std::string &dispatch_queue_name)
bool StartNoticingNewThreads() override
Call this to set the lldb in the mode where it breaks on new thread creations, and then auto-restarts...
DynamicLoader * GetDynamicLoader() override
Get the dynamic loader plug-in for this process.
ArchSpec GetSystemArchitecture() override
Get the system architecture for this process.
Status ConfigureStructuredData(llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp) override
Configure asynchronous structured data feature.
void DidVFork(lldb::pid_t child_pid, lldb::tid_t child_tid) override
Called after a reported vfork.
void DidExec() override
Called after a process re-execs itself.
size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override
Puts data into this process's STDIN.
std::map< lldb::addr_t, lldb::addr_t > MMapMap
Status DoAttachToProcessWithName(const char *process_name, const ProcessAttachInfo &attach_info) override
Attach to an existing process using a partial process name.
StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args)
bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override
Check if a plug-in instance can debug the file in module.
void SetThreadPc(const lldb::ThreadSP &thread_sp, uint64_t index)
Status ConnectToDebugserver(llvm::StringRef host_port)
void SetUnixSignals(const lldb::UnixSignalsSP &signals_sp)
void RefreshStateAfterStop() override
Currently called as part of ShouldStop.
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Status &error) override
Actually do the reading of memory from a process.
std::optional< StringExtractorGDBRemote > m_last_stop_packet
CommandObject * GetPluginCommandObject() override
Return a multi-word command object that can be used to expose plug-in specific commands.
size_t DoWriteMemory(lldb::addr_t addr, const void *buf, size_t size, Status &error) override
Actually do the writing of memory to a process.
Status DoLaunch(Module *exe_module, ProcessLaunchInfo &launch_info) override
Launch a new process.
void DidVForkDone() override
Called after reported vfork completion.
std::string HarmonizeThreadIdsForProfileData(StringExtractorGDBRemote &inputStringExtractor)
bool GetGDBServerRegisterInfoXMLAndProcess(ArchSpec &arch_to_use, std::string xml_filename, std::vector< DynamicRegisterInfo::Register > &registers)
Status DoWillAttachToProcessWithName(const char *process_name, bool wait_for_launch) override
Called before attaching to a process.
Status DoResume() override
Resumes all of a process's threads as configured using the Thread run control functions.
std::pair< std::string, std::string > ModuleCacheKey
bool SupportsMemoryTagging() override
Check whether the process supports memory tagging.
std::vector< std::pair< lldb::tid_t, int > > tid_sig_collection
size_t UpdateThreadPCsFromStopReplyThreadsValue(llvm::StringRef value)
llvm::VersionTuple GetHostOSVersion() override
Sometimes the connection to a process can detect the host OS version that the process is running on.
std::map< uint64_t, uint32_t > m_thread_id_to_used_usec_map
Status DoWriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type, const std::vector< uint8_t > &tags) override
Does the final operation to write memory tags.
llvm::Expected< std::vector< uint8_t > > TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override
Get binary data given a trace technology and a data identifier.
Status EnableBreakpointSite(BreakpointSite *bp_site) override
void ModulesDidLoad(ModuleList &module_list) override
Status WillResume() override
Called before resuming to a process.
lldb::ModuleSP LoadModuleAtAddress(const FileSpec &file, lldb::addr_t link_map, lldb::addr_t base_addr, bool value_is_offset)
void SetLastStopPacket(const StringExtractorGDBRemote &response)
Status WriteObjectFile(std::vector< ObjectFile::LoadableData > entries) override
llvm::Error LoadModules() override
Sometimes processes know how to retrieve and load shared libraries.
void HandleAsyncMisc(llvm::StringRef data) override
ProcessGDBRemote(const ProcessGDBRemote &)=delete
lldb::addr_t GetImageInfoAddress() override
Get the image information address for the current process.
bool DoUpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list) override
Update the thread list following process plug-in's specific logic.
static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path, bool can_connect)
void PrefetchModuleSpecs(llvm::ArrayRef< FileSpec > module_file_specs, const llvm::Triple &triple) override
StructuredData::ObjectSP GetDynamicLoaderProcessState() override
bool GetModuleSpec(const FileSpec &module_file_spec, const ArchSpec &arch, ModuleSpec &module_spec) override
Try to fetch the module specification for a module with the given file name and architecture.
llvm::StringMap< std::unique_ptr< RegisterFlags > > m_registers_flags_types
Status DoWillLaunch(Module *module) override
Called before launching to a process.
void DidAttach(ArchSpec &process_arch) override
Called after attaching a process.
llvm::Expected< bool > SaveCore(llvm::StringRef outfile) override
Save core dump into the specified file.
llvm::Expected< std::string > TraceGetState(llvm::StringRef type) override
Get the current tracing state of the process and its threads.
bool IsAlive() override
Check if a process is still alive.
std::shared_ptr< GDBRemoteDynamicRegisterInfo > GDBRemoteDynamicRegisterInfoSP
A class that represents a running process on the host machine.
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:441
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
Definition: lldb-forward.h:328
void * thread_result_t
Definition: lldb-types.h:62
std::shared_ptr< lldb_private::UnixSignals > UnixSignalsSP
Definition: lldb-forward.h:471
StateType
Process and Thread States.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateRunning
Process or thread is running and can't be examined.
@ eStateExited
Process has exited and can't be examined.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:316
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:384
uint64_t pid_t
Definition: lldb-types.h:83
QueueKind
Queue type.
std::shared_ptr< lldb_private::Watchpoint > WatchpointSP
Definition: lldb-forward.h:480
std::shared_ptr< lldb_private::Listener > ListenerSP
Definition: lldb-forward.h:363
uint64_t user_id_t
Definition: lldb-types.h:82
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:439
uint64_t tid_t
Definition: lldb-types.h:84
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:368
jLLDBTraceGetBinaryData gdb-remote packet
jLLDBTraceStop gdb-remote packet
static bool isEqual(const ModuleCacheKey &LHS, const ModuleCacheKey &RHS)