LLDB  mainline
NativeProcessLinux.h
Go to the documentation of this file.
1 //===-- NativeProcessLinux.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 liblldb_NativeProcessLinux_H_
10 #define liblldb_NativeProcessLinux_H_
11 
12 #include <csignal>
13 #include <unordered_set>
14 
15 #include "lldb/Host/Debug.h"
16 #include "lldb/Host/HostThread.h"
19 #include "lldb/Utility/ArchSpec.h"
20 #include "lldb/Utility/FileSpec.h"
21 #include "lldb/lldb-types.h"
22 
23 #include "IntelPTCollector.h"
24 #include "NativeThreadLinux.h"
27 
28 namespace lldb_private {
29 class Status;
30 class Scalar;
31 
32 namespace process_linux {
33 /// \class NativeProcessLinux
34 /// Manages communication with the inferior (debugee) process.
35 ///
36 /// Upon construction, this class prepares and launches an inferior process
37 /// for debugging.
38 ///
39 /// Changes in the inferior process state are broadcasted.
42 public:
44  public:
45  llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
46  Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate,
47  MainLoop &mainloop) const override;
48 
49  llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
50  Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
51  MainLoop &mainloop) const override;
52 
53  Extension GetSupportedExtensions() const override;
54  };
55 
56  // NativeProcessProtocol Interface
57  Status Resume(const ResumeActionList &resume_actions) override;
58 
59  Status Halt() override;
60 
61  Status Detach() override;
62 
63  Status Signal(int signo) override;
64 
65  Status Interrupt() override;
66 
67  Status Kill() override;
68 
70  MemoryRegionInfo &range_info) override;
71 
72  Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
73  size_t &bytes_read) override;
74 
75  Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
76  size_t &bytes_written) override;
77 
78  llvm::Expected<lldb::addr_t> AllocateMemory(size_t size,
79  uint32_t permissions) override;
80 
82 
83  Status ReadMemoryTags(int32_t type, lldb::addr_t addr, size_t len,
84  std::vector<uint8_t> &tags) override;
85 
86  Status WriteMemoryTags(int32_t type, lldb::addr_t addr, size_t len,
87  const std::vector<uint8_t> &tags) override;
88 
89  size_t UpdateThreads() override;
90 
91  const ArchSpec &GetArchitecture() const override { return m_arch; }
92 
94  bool hardware) override;
95 
96  Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;
97 
98  void DoStopIDBumped(uint32_t newBumpId) override;
99 
100  Status GetLoadedModuleFileSpec(const char *module_path,
101  FileSpec &file_spec) override;
102 
103  Status GetFileLoadAddress(const llvm::StringRef &file_name,
104  lldb::addr_t &load_addr) override;
105 
108 
109  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
110  GetAuxvData() const override {
111  return getProcFile(GetID(), "auxv");
112  }
113 
114  /// Tracing
115  /// These methods implement the jLLDBTrace packets
116  /// \{
117  llvm::Error TraceStart(llvm::StringRef json_request,
118  llvm::StringRef type) override;
119 
120  llvm::Error TraceStop(const TraceStopRequest &request) override;
121 
122  llvm::Expected<llvm::json::Value>
123  TraceGetState(llvm::StringRef type) override;
124 
125  llvm::Expected<std::vector<uint8_t>>
126  TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override;
127 
128  llvm::Expected<TraceSupportedResponse> TraceSupported() override;
129  /// }
130 
131  // Interface used by NativeRegisterContext-derived classes.
132  static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
133  void *data = nullptr, size_t data_size = 0,
134  long *result = nullptr);
135 
136  bool SupportHardwareSingleStepping() const;
137 
138  /// Writes a siginfo_t structure corresponding to the given thread ID to the
139  /// memory region pointed to by \p siginfo.
140  Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const;
141 
142 protected:
143  llvm::Expected<llvm::ArrayRef<uint8_t>>
144  GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;
145 
146  llvm::Expected<uint64_t> Syscall(llvm::ArrayRef<uint64_t> args);
147 
148 private:
152 
154  std::vector<std::pair<MemoryRegionInfo, FileSpec>> m_mem_region_cache;
155 
157 
158  /// Inferior memory (allocated by us) and its size.
159  llvm::DenseMap<lldb::addr_t, lldb::addr_t> m_allocated_memory;
160 
161  // Private Instance Methods
162  NativeProcessLinux(::pid_t pid, int terminal_fd, NativeDelegate &delegate,
163  const ArchSpec &arch, MainLoop &mainloop,
164  llvm::ArrayRef<::pid_t> tids);
165 
166  // Returns a list of process threads that we have attached to.
167  static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid);
168 
170 
171  void MonitorCallback(NativeThreadLinux &thread, WaitStatus status);
172 
173  void WaitForCloneNotification(::pid_t pid);
174 
175  void MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread);
176 
177  void MonitorTrace(NativeThreadLinux &thread);
178 
179  void MonitorBreakpoint(NativeThreadLinux &thread);
180 
181  void MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index);
182 
183  void MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread);
184 
185  bool HasThreadNoLock(lldb::tid_t thread_id);
186 
188 
189  /// Create a new thread.
190  ///
191  /// If process tracing is enabled and the thread can't be traced, then the
192  /// thread is left stopped with a \a eStopReasonProcessorTrace status, and
193  /// then the process is stopped.
194  ///
195  /// \param[in] resume
196  /// If a tracing error didn't happen, then resume the thread after
197  /// creation if \b true, or leave it stopped with SIGSTOP if \b false.
198  NativeThreadLinux &AddThread(lldb::tid_t thread_id, bool resume);
199 
200  /// Start tracing a new thread if process tracing is enabled.
201  ///
202  /// Trace mechanisms should modify this method to provide automatic tracing
203  /// for new threads.
205 
206  /// Stop tracing threads upon a destroy event.
207  ///
208  /// Trace mechanisms should modify this method to provide automatic trace
209  /// stopping for threads being destroyed.
211 
212  void NotifyTracersProcessWillResume() override;
213 
214  void NotifyTracersProcessDidStop() override;
215 
216  /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
217  /// corresponding to the given thread ID to the memory pointed to by @p
218  /// message.
219  Status GetEventMessage(lldb::tid_t tid, unsigned long *message);
220 
221  void NotifyThreadDeath(lldb::tid_t tid);
222 
224 
225  // This method is requests a stop on all threads which are still running. It
226  // sets up a
227  // deferred delegate notification, which will fire once threads report as
228  // stopped. The
229  // triggerring_tid will be set as the current thread (main stop reason).
230  void StopRunningThreads(lldb::tid_t triggering_tid);
231 
232  // Notify the delegate if all threads have stopped.
234 
235  // Resume the given thread, optionally passing it the given signal. The type
236  // of resume
237  // operation (continue, single-step) depends on the state parameter.
239  int signo);
240 
241  void ThreadWasCreated(NativeThreadLinux &thread);
242 
243  void SigchldHandler();
244 
246 
247  /// Manages Intel PT process and thread traces.
249 
250  // Handle a clone()-like event.
251  bool MonitorClone(NativeThreadLinux &parent, lldb::pid_t child_pid,
252  int event);
253 };
254 
255 } // namespace process_linux
256 } // namespace lldb_private
257 
258 #endif // #ifndef liblldb_NativeProcessLinux_H_
lldb_private::process_linux::NativeProcessLinux::MonitorCallback
void MonitorCallback(NativeThreadLinux &thread, WaitStatus status)
Definition: NativeProcessLinux.cpp:431
lldb_private::NativeProcessProtocol::NativeDelegate
Definition: NativeProcessProtocol.h:236
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb_private::process_linux::NativeProcessLinux::NotifyTracersProcessDidStop
void NotifyTracersProcessDidStop() override
Notify tracers that the target process just stopped.
Definition: NativeProcessLinux.cpp:1671
lldb_private::TraceGetBinaryDataRequest
jLLDBTraceGetBinaryData gdb-remote packet
Definition: TraceGDBRemotePackets.h:149
lldb_private::process_linux::NativeProcessLinux::PtraceWrapper
static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr=nullptr, void *data=nullptr, size_t data_size=0, long *result=nullptr)
}
Definition: NativeProcessLinux.cpp:1935
lldb_private::process_linux::NativeProcessLinux::MonitorSIGTRAP
void MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread)
Definition: NativeProcessLinux.cpp:519
lldb_private::process_linux::NativeProcessLinux::GetThreadByID
NativeThreadLinux * GetThreadByID(lldb::tid_t id)
Definition: NativeProcessLinux.cpp:1763
lldb_private::process_linux::NativeProcessLinux::m_pending_notification_tid
lldb::tid_t m_pending_notification_tid
Definition: NativeProcessLinux.h:156
lldb_private::process_linux::NativeProcessLinux::GetSignalInfo
Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const
Writes a siginfo_t structure corresponding to the given thread ID to the memory region pointed to by ...
Definition: NativeProcessLinux.cpp:1627
lldb_private::process_linux::NativeProcessLinux::DoStopIDBumped
void DoStopIDBumped(uint32_t newBumpId) override
Definition: NativeProcessLinux.cpp:1218
lldb_private::process_linux::NativeProcessLinux::GetEventMessage
Status GetEventMessage(lldb::tid_t tid, unsigned long *message)
Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) corresponding to the given thread ID...
Definition: NativeProcessLinux.cpp:1631
lldb_private::process_linux::NativeProcessLinux::NativeProcessLinux
NativeProcessLinux(::pid_t pid, int terminal_fd, NativeDelegate &delegate, const ArchSpec &arch, MainLoop &mainloop, llvm::ArrayRef<::pid_t > tids)
Definition: NativeProcessLinux.cpp:310
lldb_private::process_linux::NativeProcessLinux::MonitorTrace
void MonitorTrace(NativeThreadLinux &thread)
Definition: NativeProcessLinux.cpp:708
lldb_private::process_linux::NativeThreadLinux
Definition: NativeThreadLinux.h:29
lldb_private::process_linux::NativeProcessLinux::MonitorClone
bool MonitorClone(NativeThreadLinux &parent, lldb::pid_t child_pid, int event)
Definition: NativeProcessLinux.cpp:835
lldb_private::process_linux::NativeProcessLinux::m_intel_pt_collector
IntelPTCollector m_intel_pt_collector
Manages Intel PT process and thread traces.
Definition: NativeProcessLinux.h:248
lldb_private::MemoryRegionInfo
Definition: MemoryRegionInfo.h:21
lldb_private::process_linux::NativeProcessLinux::PopulateMemoryRegionCache
Status PopulateMemoryRegionCache()
Definition: NativeProcessLinux.cpp:1155
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
NativeThreadLinux.h
lldb_private::process_linux::NativeProcessLinux::GetAuxvData
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > GetAuxvData() const override
Definition: NativeProcessLinux.h:110
lldb_private::process_linux::NativeProcessLinux::Factory::Launch
llvm::Expected< std::unique_ptr< NativeProcessProtocol > > Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate, MainLoop &mainloop) const override
Launch a process for debugging.
Definition: NativeProcessLinux.cpp:219
lldb_private::process_linux::NativeProcessLinux::Resume
Status Resume(const ResumeActionList &resume_actions) override
Definition: NativeProcessLinux.cpp:897
lldb_private::process_linux::NativeProcessLinux::ThreadWasCreated
void ThreadWasCreated(NativeThreadLinux &thread)
Definition: NativeProcessLinux.cpp:1860
lldb_private::process_linux::NativeProcessLinux::UpdateThreads
size_t UpdateThreads() override
Definition: NativeProcessLinux.cpp:1482
lldb_private::WaitStatus
Definition: Host.h:35
lldb_private::process_linux::NativeProcessLinux::WriteMemory
Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written) override
Definition: NativeProcessLinux.cpp:1581
lldb_private::process_linux::NativeProcessLinux::HasThreadNoLock
bool HasThreadNoLock(lldb::tid_t thread_id)
Definition: NativeProcessLinux.cpp:1643
lldb_private::process_linux::NativeProcessLinux::MonitorBreakpoint
void MonitorBreakpoint(NativeThreadLinux &thread)
Definition: NativeProcessLinux.cpp:718
lldb_private::process_linux::NativeProcessLinux::MonitorSignal
void MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread)
Definition: NativeProcessLinux.cpp:748
lldb_private::process_linux::NativeProcessLinux::TraceSupported
llvm::Expected< TraceSupportedResponse > TraceSupported() override
Get the processor tracing type supported for this process.
Definition: NativeProcessLinux.cpp:1970
lldb_private::process_linux::NativeProcessLinux::SetBreakpoint
Status SetBreakpoint(lldb::addr_t addr, uint32_t size, bool hardware) override
Definition: NativeProcessLinux.cpp:1489
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::process_linux::NativeProcessLinux::WaitForCloneNotification
void WaitForCloneNotification(::pid_t pid)
Definition: NativeProcessLinux.cpp:498
HostThread.h
lldb_private::process_linux::NativeProcessLinux::GetSoftwareBreakpointTrapOpcode
llvm::Expected< llvm::ArrayRef< uint8_t > > GetSoftwareBreakpointTrapOpcode(size_t size_hint) override
Definition: NativeProcessLinux.cpp:1505
lldb_private::process_linux::NativeProcessLinux::AddThread
NativeThreadLinux & AddThread(lldb::tid_t thread_id, bool resume)
Create a new thread.
Definition: NativeProcessLinux.cpp:1698
lldb_private::process_linux::NativeProcessLinux::SupportHardwareSingleStepping
bool SupportHardwareSingleStepping() const
Definition: NativeProcessLinux.cpp:891
lldb_private::NativeProcessSoftwareSingleStep
Definition: NativeProcessSoftwareSingleStep.h:19
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
lldb_private::process_linux::NativeProcessLinux::NotifyTracersOfThreadDestroyed
Status NotifyTracersOfThreadDestroyed(lldb::tid_t tid)
Stop tracing threads upon a destroy event.
Definition: NativeProcessLinux.cpp:1688
MemoryRegionInfo.h
lldb_private::process_linux::NativeProcessLinux::TraceGetBinaryData
llvm::Expected< std::vector< uint8_t > > TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override
Get binary data given a trace technology and a data identifier.
Definition: NativeProcessLinux.cpp:2001
lldb_private::process_linux::NativeProcessLinux::GetFileLoadAddress
Status GetFileLoadAddress(const llvm::StringRef &file_name, lldb::addr_t &load_addr) override
Definition: NativeProcessLinux.cpp:1746
lldb_private::process_linux::NativeProcessLinux::Factory::Attach
llvm::Expected< std::unique_ptr< NativeProcessProtocol > > Attach(lldb::pid_t pid, NativeDelegate &native_delegate, MainLoop &mainloop) const override
Attach to an existing process.
Definition: NativeProcessLinux.cpp:271
lldb_private::process_linux::NativeProcessLinux::NotifyTracersOfNewThread
Status NotifyTracersOfNewThread(lldb::tid_t tid)
Start tracing a new thread if process tracing is enabled.
Definition: NativeProcessLinux.cpp:1679
lldb_private::process_linux::IntelPTCollector
Main class that manages intel-pt process and thread tracing.
Definition: IntelPTCollector.h:32
lldb_private::process_linux::NativeProcessLinux::Factory::GetSupportedExtensions
Extension GetSupportedExtensions() const override
Get the bitmask of extensions supported by this process plugin.
Definition: NativeProcessLinux.cpp:293
lldb_private::NativeProcessProtocol::GetID
lldb::pid_t GetID() const
Definition: NativeProcessProtocol.h:183
lldb_private::process_linux::NativeProcessLinux::StopTrackingThread
void StopTrackingThread(NativeThreadLinux &thread)
Definition: NativeProcessLinux.cpp:1656
NativeProcessELF.h
lldb_private::process_linux::NativeProcessLinux::ResumeThread
Status ResumeThread(NativeThreadLinux &thread, lldb::StateType state, int signo)
Definition: NativeProcessLinux.cpp:1773
lldb_private::process_linux::NativeProcessLinux
Definition: NativeProcessLinux.h:40
lldb_private::process_linux::NativeProcessLinux::GetLoadedModuleFileSpec
Status GetLoadedModuleFileSpec(const char *module_path, FileSpec &file_spec) override
Definition: NativeProcessLinux.cpp:1726
lldb_private::process_linux::NativeProcessLinux::TraceStart
llvm::Error TraceStart(llvm::StringRef json_request, llvm::StringRef type) override
Tracing These methods implement the jLLDBTrace packets.
Definition: NativeProcessLinux.cpp:1976
lldb_private::getProcFile
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getProcFile(::pid_t pid, ::pid_t tid, const llvm::Twine &file)
Definition: Support.cpp:15
lldb_private::process_linux::NativeProcessLinux::TraceGetState
llvm::Expected< llvm::json::Value > TraceGetState(llvm::StringRef type) override
Get the current tracing state of the process and its threads.
Definition: NativeProcessLinux.cpp:1995
lldb_private::process_linux::NativeProcessLinux::m_sigchld_handle
MainLoop::SignalHandleUP m_sigchld_handle
Definition: NativeProcessLinux.h:149
lldb_private::process_linux::NativeProcessLinux::Kill
Status Kill() override
Definition: NativeProcessLinux.cpp:1050
lldb_private::process_linux::NativeProcessLinux::WriteMemoryTags
Status WriteMemoryTags(int32_t type, lldb::addr_t addr, size_t len, const std::vector< uint8_t > &tags) override
Definition: NativeProcessLinux.cpp:1412
lldb_private::process_linux::NativeProcessLinux::SigchldHandler
void SigchldHandler()
Definition: NativeProcessLinux.cpp:1897
lldb_private::process_linux::NativeProcessLinux::Interrupt
Status Interrupt() override
Tells a process to interrupt all operations as if by a Ctrl-C.
Definition: NativeProcessLinux.cpp:1007
lldb_private::NativeProcessProtocol::Extension
Extension
Extension flag constants, returned by Factory::GetSupportedExtensions() and passed to SetEnabledExten...
Definition: NativeProcessProtocol.h:260
lldb-types.h
lldb_private::process_linux::NativeProcessLinux::Attach
static llvm::Expected< std::vector<::pid_t > > Attach(::pid_t pid)
Definition: NativeProcessLinux.cpp:339
lldb_private::process_linux::NativeProcessLinux::Detach
Status Detach() override
Definition: NativeProcessLinux.cpp:972
IntelPTCollector.h
lldb_private::process_linux::NativeProcessLinux::MonitorWatchpoint
void MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index)
Definition: NativeProcessLinux.cpp:733
lldb_private::TraceStopRequest
jLLDBTraceStop gdb-remote packet
Definition: TraceGDBRemotePackets.h:64
lldb_private::process_linux::NativeProcessLinux::m_supports_mem_region
LazyBool m_supports_mem_region
Definition: NativeProcessLinux.h:153
lldb_private::Status
Definition: Status.h:44
lldb_private::process_linux::NativeProcessLinux::GetCurrentThread
NativeThreadLinux * GetCurrentThread()
Definition: NativeProcessLinux.cpp:1768
message
message(FATAL_ERROR "invalid libipt include path provided") endif() include_directories($
Definition: Plugins/Trace/intel-pt/CMakeLists.txt:6
uint32_t
lldb_private::process_linux::NativeProcessLinux::Signal
Status Signal(int signo) override
Sends a process a UNIX signal signal.
Definition: NativeProcessLinux.cpp:994
lldb_private::process_linux::NativeProcessLinux::m_main_loop
MainLoop & m_main_loop
Definition: NativeProcessLinux.h:151
lldb_private::MainLoop
Definition: MainLoop.h:39
lldb_private::process_linux::NativeProcessLinux::AllocateMemory
llvm::Expected< lldb::addr_t > AllocateMemory(size_t size, uint32_t permissions) override
Definition: NativeProcessLinux.cpp:1311
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
Support.h
lldb_private::MainLoop::SignalHandleUP
std::unique_ptr< SignalHandle > SignalHandleUP
Definition: MainLoop.h:41
ArchSpec.h
lldb_private::process_linux::NativeProcessLinux::StopRunningThreads
void StopRunningThreads(lldb::tid_t triggering_tid)
Definition: NativeProcessLinux.cpp:1814
lldb_private::process_linux::NativeProcessLinux::m_arch
ArchSpec m_arch
Definition: NativeProcessLinux.h:150
lldb_private::process_linux::NativeProcessLinux::SignalIfAllThreadsStopped
void SignalIfAllThreadsStopped()
Definition: NativeProcessLinux.cpp:1832
lldb_private::ResumeActionList
Definition: Debug.h:33
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::NativeProcessELF
Definition: NativeProcessELF.h:21
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::process_linux::NativeProcessLinux::NotifyTracersProcessWillResume
void NotifyTracersProcessWillResume() override
Notify tracers that the target process will resume.
Definition: NativeProcessLinux.cpp:1675
Error
llvm::Error Error
Definition: UdtRecordCompleter.cpp:30
FileSpec.h
lldb_private::process_linux::NativeProcessLinux::TraceStop
llvm::Error TraceStop(const TraceStopRequest &request) override
Stop tracing a live process or its threads.
Definition: NativeProcessLinux.cpp:1989
lldb_private::process_linux::NativeProcessLinux::Halt
Status Halt() override
Definition: NativeProcessLinux.cpp:963
lldb_private::process_linux::NativeProcessLinux::m_mem_region_cache
std::vector< std::pair< MemoryRegionInfo, FileSpec > > m_mem_region_cache
Definition: NativeProcessLinux.h:154
lldb_private::process_linux::NativeProcessLinux::RemoveBreakpoint
Status RemoveBreakpoint(lldb::addr_t addr, bool hardware=false) override
Definition: NativeProcessLinux.cpp:1497
LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:82
lldb_private::process_linux::NativeProcessLinux::Factory
Definition: NativeProcessLinux.h:43
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::process_linux::NativeProcessLinux::Syscall
llvm::Expected< uint64_t > Syscall(llvm::ArrayRef< uint64_t > args)
Definition: NativeProcessLinux.cpp:1227
lldb_private::process_linux::NativeProcessLinux::NotifyThreadDeath
void NotifyThreadDeath(lldb::tid_t tid)
lldb_private::process_linux::NativeProcessLinux::ReadMemory
Status ReadMemory(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read) override
Definition: NativeProcessLinux.cpp:1527
lldb_private::process_linux::NativeProcessLinux::DeallocateMemory
llvm::Error DeallocateMemory(lldb::addr_t addr) override
Definition: NativeProcessLinux.cpp:1337
lldb_private::process_linux::NativeProcessLinux::m_allocated_memory
llvm::DenseMap< lldb::addr_t, lldb::addr_t > m_allocated_memory
Inferior memory (allocated by us) and its size.
Definition: NativeProcessLinux.h:159
NativeProcessSoftwareSingleStep.h
lldb_private::LineStatus::Status
@ Status
lldb_private::NativeProcessProtocol::Factory
Definition: NativeProcessProtocol.h:274
Debug.h
lldb_private::process_linux::NativeProcessLinux::SetDefaultPtraceOpts
static Status SetDefaultPtraceOpts(const lldb::pid_t)
Definition: NativeProcessLinux.cpp:403
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::process_linux::NativeProcessLinux::GetArchitecture
const ArchSpec & GetArchitecture() const override
Definition: NativeProcessLinux.h:91
lldb_private::process_linux::NativeProcessLinux::ReadMemoryTags
Status ReadMemoryTags(int32_t type, lldb::addr_t addr, size_t len, std::vector< uint8_t > &tags) override
Definition: NativeProcessLinux.cpp:1357
lldb_private::process_linux::NativeProcessLinux::GetMemoryRegionInfo
Status GetMemoryRegionInfo(lldb::addr_t load_addr, MemoryRegionInfo &range_info) override
Definition: NativeProcessLinux.cpp:1086