1 | //===-- NativeThreadLinux.cpp ---------------------------------------------===// |
---|---|
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 | #include "NativeThreadLinux.h" |
10 | |
11 | #include <csignal> |
12 | #include <sstream> |
13 | |
14 | #include "NativeProcessLinux.h" |
15 | #include "NativeRegisterContextLinux.h" |
16 | #include "SingleStepCheck.h" |
17 | |
18 | #include "lldb/Host/HostNativeThread.h" |
19 | #include "lldb/Host/linux/Ptrace.h" |
20 | #include "lldb/Host/linux/Support.h" |
21 | #include "lldb/Utility/LLDBAssert.h" |
22 | #include "lldb/Utility/LLDBLog.h" |
23 | #include "lldb/Utility/Log.h" |
24 | #include "lldb/Utility/State.h" |
25 | #include "lldb/lldb-enumerations.h" |
26 | |
27 | #include "llvm/ADT/SmallString.h" |
28 | |
29 | #include "Plugins/Process/POSIX/CrashReason.h" |
30 | #include "Plugins/Process/Utility/MemoryTagManagerAArch64MTE.h" |
31 | |
32 | #include <sys/syscall.h> |
33 | // Try to define a macro to encapsulate the tgkill syscall |
34 | #define tgkill(pid, tid, sig) \ |
35 | syscall(__NR_tgkill, static_cast<::pid_t>(pid), static_cast<::pid_t>(tid), \ |
36 | sig) |
37 | |
38 | using namespace lldb; |
39 | using namespace lldb_private; |
40 | using namespace lldb_private::process_linux; |
41 | |
42 | namespace { |
43 | void LogThreadStopInfo(Log &log, const ThreadStopInfo &stop_info, |
44 | const char *const header) { |
45 | switch (stop_info.reason) { |
46 | case eStopReasonNone: |
47 | log.Printf(format: "%s: %s no stop reason", __FUNCTION__, header); |
48 | return; |
49 | case eStopReasonTrace: |
50 | log.Printf(format: "%s: %s trace, stopping signal 0x%"PRIx32, __FUNCTION__, header, |
51 | stop_info.signo); |
52 | return; |
53 | case eStopReasonBreakpoint: |
54 | log.Printf(format: "%s: %s breakpoint, stopping signal 0x%"PRIx32, __FUNCTION__, |
55 | header, stop_info.signo); |
56 | return; |
57 | case eStopReasonWatchpoint: |
58 | log.Printf(format: "%s: %s watchpoint, stopping signal 0x%"PRIx32, __FUNCTION__, |
59 | header, stop_info.signo); |
60 | return; |
61 | case eStopReasonSignal: |
62 | log.Printf(format: "%s: %s signal 0x%02"PRIx32, __FUNCTION__, header, |
63 | stop_info.signo); |
64 | return; |
65 | case eStopReasonException: |
66 | log.Printf(format: "%s: %s exception type 0x%02"PRIx64, __FUNCTION__, header, |
67 | stop_info.details.exception.type); |
68 | return; |
69 | case eStopReasonExec: |
70 | log.Printf(format: "%s: %s exec, stopping signal 0x%"PRIx32, __FUNCTION__, header, |
71 | stop_info.signo); |
72 | return; |
73 | case eStopReasonPlanComplete: |
74 | log.Printf(format: "%s: %s plan complete", __FUNCTION__, header); |
75 | return; |
76 | case eStopReasonThreadExiting: |
77 | log.Printf(format: "%s: %s thread exiting", __FUNCTION__, header); |
78 | return; |
79 | case eStopReasonInstrumentation: |
80 | log.Printf(format: "%s: %s instrumentation", __FUNCTION__, header); |
81 | return; |
82 | case eStopReasonProcessorTrace: |
83 | log.Printf(format: "%s: %s processor trace", __FUNCTION__, header); |
84 | return; |
85 | case eStopReasonHistoryBoundary: |
86 | log.Printf(format: "%s: %s history boundary", __FUNCTION__, header); |
87 | return; |
88 | default: |
89 | log.Printf(format: "%s: %s invalid stop reason %"PRIu32, __FUNCTION__, header, |
90 | static_cast<uint32_t>(stop_info.reason)); |
91 | } |
92 | } |
93 | } |
94 | |
95 | NativeThreadLinux::NativeThreadLinux(NativeProcessLinux &process, |
96 | lldb::tid_t tid) |
97 | : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid), |
98 | m_stop_info(), |
99 | m_reg_context_up( |
100 | NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux( |
101 | target_arch: process.GetArchitecture(), native_thread&: *this)), |
102 | m_stop_description() {} |
103 | |
104 | std::string NativeThreadLinux::GetName() { |
105 | NativeProcessLinux &process = GetProcess(); |
106 | |
107 | auto BufferOrError = getProcFile(pid: process.GetID(), tid: GetID(), file: "comm"); |
108 | if (!BufferOrError) |
109 | return ""; |
110 | return std::string(BufferOrError.get()->getBuffer().rtrim(Char: '\n')); |
111 | } |
112 | |
113 | lldb::StateType NativeThreadLinux::GetState() { return m_state; } |
114 | |
115 | bool NativeThreadLinux::GetStopReason(ThreadStopInfo &stop_info, |
116 | std::string &description) { |
117 | Log *log = GetLog(mask: LLDBLog::Thread); |
118 | |
119 | description.clear(); |
120 | |
121 | switch (m_state) { |
122 | case eStateStopped: |
123 | case eStateCrashed: |
124 | case eStateExited: |
125 | case eStateSuspended: |
126 | case eStateUnloaded: |
127 | if (log) |
128 | LogThreadStopInfo(log&: *log, stop_info: m_stop_info, header: "m_stop_info in thread:"); |
129 | stop_info = m_stop_info; |
130 | description = m_stop_description; |
131 | if (log) |
132 | LogThreadStopInfo(log&: *log, stop_info, header: "returned stop_info:"); |
133 | |
134 | return true; |
135 | |
136 | case eStateInvalid: |
137 | case eStateConnected: |
138 | case eStateAttaching: |
139 | case eStateLaunching: |
140 | case eStateRunning: |
141 | case eStateStepping: |
142 | case eStateDetached: |
143 | if (log) { |
144 | LLDB_LOGF(log, |
145 | "NativeThreadLinux::%s tid %"PRIu64 |
146 | " in state %s cannot answer stop reason", |
147 | __FUNCTION__, GetID(), StateAsCString(m_state)); |
148 | } |
149 | return false; |
150 | } |
151 | llvm_unreachable("unhandled StateType!"); |
152 | } |
153 | |
154 | Status NativeThreadLinux::SetWatchpoint(lldb::addr_t addr, size_t size, |
155 | uint32_t watch_flags, bool hardware) { |
156 | if (!hardware) |
157 | return Status::FromErrorString(str: "not implemented"); |
158 | if (m_state == eStateLaunching) |
159 | return Status(); |
160 | Status error = RemoveWatchpoint(addr); |
161 | if (error.Fail()) |
162 | return error; |
163 | uint32_t wp_index = |
164 | m_reg_context_up->SetHardwareWatchpoint(addr, size, watch_flags); |
165 | if (wp_index == LLDB_INVALID_INDEX32) |
166 | return Status::FromErrorString(str: "Setting hardware watchpoint failed."); |
167 | m_watchpoint_index_map.insert(x: {addr, wp_index}); |
168 | return Status(); |
169 | } |
170 | |
171 | Status NativeThreadLinux::RemoveWatchpoint(lldb::addr_t addr) { |
172 | auto wp = m_watchpoint_index_map.find(x: addr); |
173 | if (wp == m_watchpoint_index_map.end()) |
174 | return Status(); |
175 | uint32_t wp_index = wp->second; |
176 | m_watchpoint_index_map.erase(position: wp); |
177 | if (m_reg_context_up->ClearHardwareWatchpoint(hw_index: wp_index)) |
178 | return Status(); |
179 | return Status::FromErrorString(str: "Clearing hardware watchpoint failed."); |
180 | } |
181 | |
182 | Status NativeThreadLinux::SetHardwareBreakpoint(lldb::addr_t addr, |
183 | size_t size) { |
184 | if (m_state == eStateLaunching) |
185 | return Status(); |
186 | |
187 | Status error = RemoveHardwareBreakpoint(addr); |
188 | if (error.Fail()) |
189 | return error; |
190 | |
191 | uint32_t bp_index = m_reg_context_up->SetHardwareBreakpoint(addr, size); |
192 | |
193 | if (bp_index == LLDB_INVALID_INDEX32) |
194 | return Status::FromErrorString(str: "Setting hardware breakpoint failed."); |
195 | |
196 | m_hw_break_index_map.insert(x: {addr, bp_index}); |
197 | return Status(); |
198 | } |
199 | |
200 | Status NativeThreadLinux::RemoveHardwareBreakpoint(lldb::addr_t addr) { |
201 | auto bp = m_hw_break_index_map.find(x: addr); |
202 | if (bp == m_hw_break_index_map.end()) |
203 | return Status(); |
204 | |
205 | uint32_t bp_index = bp->second; |
206 | if (m_reg_context_up->ClearHardwareBreakpoint(hw_idx: bp_index)) { |
207 | m_hw_break_index_map.erase(position: bp); |
208 | return Status(); |
209 | } |
210 | |
211 | return Status::FromErrorString(str: "Clearing hardware breakpoint failed."); |
212 | } |
213 | |
214 | Status NativeThreadLinux::Resume(uint32_t signo) { |
215 | const StateType new_state = StateType::eStateRunning; |
216 | MaybeLogStateChange(new_state); |
217 | m_state = new_state; |
218 | |
219 | m_stop_info.reason = StopReason::eStopReasonNone; |
220 | m_stop_description.clear(); |
221 | |
222 | // If watchpoints have been set, but none on this thread, then this is a new |
223 | // thread. So set all existing watchpoints. |
224 | if (m_watchpoint_index_map.empty()) { |
225 | NativeProcessLinux &process = GetProcess(); |
226 | |
227 | const auto &watchpoint_map = process.GetWatchpointMap(); |
228 | m_reg_context_up->ClearAllHardwareWatchpoints(); |
229 | for (const auto &pair : watchpoint_map) { |
230 | const auto &wp = pair.second; |
231 | SetWatchpoint(addr: wp.m_addr, size: wp.m_size, watch_flags: wp.m_watch_flags, hardware: wp.m_hardware); |
232 | } |
233 | } |
234 | |
235 | // Set all active hardware breakpoint on all threads. |
236 | if (m_hw_break_index_map.empty()) { |
237 | NativeProcessLinux &process = GetProcess(); |
238 | |
239 | const auto &hw_breakpoint_map = process.GetHardwareBreakpointMap(); |
240 | m_reg_context_up->ClearAllHardwareBreakpoints(); |
241 | for (const auto &pair : hw_breakpoint_map) { |
242 | const auto &bp = pair.second; |
243 | SetHardwareBreakpoint(addr: bp.m_addr, size: bp.m_size); |
244 | } |
245 | } |
246 | |
247 | intptr_t data = 0; |
248 | |
249 | if (signo != LLDB_INVALID_SIGNAL_NUMBER) |
250 | data = signo; |
251 | |
252 | return NativeProcessLinux::PtraceWrapper(req: PTRACE_CONT, pid: GetID(), addr: nullptr, |
253 | data: reinterpret_cast<void *>(data)); |
254 | } |
255 | |
256 | Status NativeThreadLinux::SingleStep(uint32_t signo) { |
257 | const StateType new_state = StateType::eStateStepping; |
258 | MaybeLogStateChange(new_state); |
259 | m_state = new_state; |
260 | m_stop_info.reason = StopReason::eStopReasonNone; |
261 | |
262 | if(!m_step_workaround) { |
263 | // If we already hava a workaround inplace, don't reset it. Otherwise, the |
264 | // destructor of the existing instance will run after the new instance has |
265 | // fetched the cpu mask, and the thread will end up with the wrong mask. |
266 | m_step_workaround = SingleStepWorkaround::Get(tid: m_tid); |
267 | } |
268 | |
269 | intptr_t data = 0; |
270 | if (signo != LLDB_INVALID_SIGNAL_NUMBER) |
271 | data = signo; |
272 | |
273 | // If hardware single-stepping is not supported, we just do a continue. The |
274 | // breakpoint on the next instruction has been setup in |
275 | // NativeProcessLinux::Resume. |
276 | return NativeProcessLinux::PtraceWrapper( |
277 | req: GetProcess().SupportHardwareSingleStepping() ? PTRACE_SINGLESTEP |
278 | : PTRACE_CONT, |
279 | pid: m_tid, addr: nullptr, data: reinterpret_cast<void *>(data)); |
280 | } |
281 | |
282 | void NativeThreadLinux::SetStoppedBySignal(uint32_t signo, |
283 | const siginfo_t *info) { |
284 | Log *log = GetLog(mask: LLDBLog::Thread); |
285 | LLDB_LOGF(log, "NativeThreadLinux::%s called with signal 0x%02"PRIx32, |
286 | __FUNCTION__, signo); |
287 | |
288 | SetStopped(); |
289 | |
290 | m_stop_info.reason = StopReason::eStopReasonSignal; |
291 | m_stop_info.signo = signo; |
292 | |
293 | m_stop_description.clear(); |
294 | if (info) { |
295 | switch (signo) { |
296 | case SIGSEGV: |
297 | case SIGBUS: |
298 | case SIGFPE: |
299 | case SIGILL: |
300 | m_stop_description = GetCrashReasonString(info: *info); |
301 | #ifndef SEGV_MTESERR |
302 | #define SEGV_MTESERR 9 |
303 | #endif |
304 | if (info->si_signo == SIGSEGV && info->si_code == SEGV_MTESERR) |
305 | AnnotateSyncTagCheckFault( |
306 | fault_addr: reinterpret_cast<lldb::addr_t>(info->si_addr)); |
307 | break; |
308 | } |
309 | } |
310 | } |
311 | |
312 | void NativeThreadLinux::AnnotateSyncTagCheckFault(lldb::addr_t fault_addr) { |
313 | int32_t allocation_tag_type = 0; |
314 | switch (GetProcess().GetArchitecture().GetMachine()) { |
315 | // aarch64_32 deliberately not here because there's no 32 bit MTE |
316 | case llvm::Triple::aarch64: |
317 | case llvm::Triple::aarch64_be: |
318 | allocation_tag_type = MemoryTagManagerAArch64MTE::eMTE_allocation; |
319 | break; |
320 | default: |
321 | return; |
322 | } |
323 | |
324 | auto details = |
325 | GetRegisterContext().GetMemoryTaggingDetails(type: allocation_tag_type); |
326 | if (!details) { |
327 | llvm::consumeError(Err: details.takeError()); |
328 | return; |
329 | } |
330 | |
331 | // We assume that the stop description is currently: |
332 | // signal SIGSEGV: sync tag check fault (fault address=<addr>) |
333 | // Remove the closing ) |
334 | m_stop_description.pop_back(); |
335 | |
336 | std::stringstream ss; |
337 | std::unique_ptr<MemoryTagManager> manager(std::move(details->manager)); |
338 | |
339 | ss << " logical tag=0x"<< std::hex << manager->GetLogicalTag(addr: fault_addr); |
340 | |
341 | std::vector<uint8_t> allocation_tag_data; |
342 | // The fault address may not be granule aligned. ReadMemoryTags will granule |
343 | // align any range you give it, potentially making it larger. |
344 | // To prevent this set len to 1. This always results in a range that is at |
345 | // most 1 granule in size and includes fault_addr. |
346 | Status status = GetProcess().ReadMemoryTags(type: allocation_tag_type, addr: fault_addr, |
347 | len: 1, tags&: allocation_tag_data); |
348 | |
349 | if (status.Success()) { |
350 | llvm::Expected<std::vector<lldb::addr_t>> allocation_tag = |
351 | manager->UnpackTagsData(tags: allocation_tag_data, granules: 1); |
352 | if (allocation_tag) { |
353 | ss << " allocation tag=0x"<< std::hex << allocation_tag->front() << ")"; |
354 | } else { |
355 | llvm::consumeError(Err: allocation_tag.takeError()); |
356 | ss << ")"; |
357 | } |
358 | } else |
359 | ss << ")"; |
360 | |
361 | m_stop_description += ss.str(); |
362 | } |
363 | |
364 | bool NativeThreadLinux::IsStopped(int *signo) { |
365 | if (!StateIsStoppedState(state: m_state, must_exist: false)) |
366 | return false; |
367 | |
368 | // If we are stopped by a signal, return the signo. |
369 | if (signo && m_state == StateType::eStateStopped && |
370 | m_stop_info.reason == StopReason::eStopReasonSignal) { |
371 | *signo = m_stop_info.signo; |
372 | } |
373 | |
374 | // Regardless, we are stopped. |
375 | return true; |
376 | } |
377 | |
378 | void NativeThreadLinux::SetStopped() { |
379 | if (m_state == StateType::eStateStepping) |
380 | m_step_workaround.reset(); |
381 | |
382 | // On every stop, clear any cached register data structures |
383 | GetRegisterContext().InvalidateAllRegisters(); |
384 | |
385 | const StateType new_state = StateType::eStateStopped; |
386 | MaybeLogStateChange(new_state); |
387 | m_state = new_state; |
388 | m_stop_description.clear(); |
389 | } |
390 | |
391 | void NativeThreadLinux::SetStoppedByExec() { |
392 | Log *log = GetLog(mask: LLDBLog::Thread); |
393 | LLDB_LOGF(log, "NativeThreadLinux::%s()", __FUNCTION__); |
394 | |
395 | SetStopped(); |
396 | |
397 | m_stop_info.reason = StopReason::eStopReasonExec; |
398 | m_stop_info.signo = SIGSTOP; |
399 | } |
400 | |
401 | void NativeThreadLinux::SetStoppedByBreakpoint() { |
402 | SetStopped(); |
403 | |
404 | m_stop_info.reason = StopReason::eStopReasonBreakpoint; |
405 | m_stop_info.signo = SIGTRAP; |
406 | m_stop_description.clear(); |
407 | } |
408 | |
409 | void NativeThreadLinux::SetStoppedByWatchpoint(uint32_t wp_index) { |
410 | SetStopped(); |
411 | |
412 | lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid"); |
413 | |
414 | std::ostringstream ostr; |
415 | ostr << m_reg_context_up->GetWatchpointAddress(wp_index) << " "; |
416 | ostr << wp_index; |
417 | |
418 | /* |
419 | * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For |
420 | * example: |
421 | * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at |
422 | * 'm', then |
423 | * watch exception is generated even when 'n' is read/written. To handle this |
424 | * case, |
425 | * find the base address of the load/store instruction and append it in the |
426 | * stop-info |
427 | * packet. |
428 | */ |
429 | ostr << " "<< m_reg_context_up->GetWatchpointHitAddress(wp_index); |
430 | |
431 | m_stop_description = ostr.str(); |
432 | |
433 | m_stop_info.reason = StopReason::eStopReasonWatchpoint; |
434 | m_stop_info.signo = SIGTRAP; |
435 | } |
436 | |
437 | bool NativeThreadLinux::IsStoppedAtBreakpoint() { |
438 | return GetState() == StateType::eStateStopped && |
439 | m_stop_info.reason == StopReason::eStopReasonBreakpoint; |
440 | } |
441 | |
442 | bool NativeThreadLinux::IsStoppedAtWatchpoint() { |
443 | return GetState() == StateType::eStateStopped && |
444 | m_stop_info.reason == StopReason::eStopReasonWatchpoint; |
445 | } |
446 | |
447 | void NativeThreadLinux::SetStoppedByTrace() { |
448 | SetStopped(); |
449 | |
450 | m_stop_info.reason = StopReason::eStopReasonTrace; |
451 | m_stop_info.signo = SIGTRAP; |
452 | } |
453 | |
454 | void NativeThreadLinux::SetStoppedByFork(bool is_vfork, lldb::pid_t child_pid) { |
455 | SetStopped(); |
456 | |
457 | m_stop_info.reason = |
458 | is_vfork ? StopReason::eStopReasonVFork : StopReason::eStopReasonFork; |
459 | m_stop_info.signo = SIGTRAP; |
460 | m_stop_info.details.fork.child_pid = child_pid; |
461 | m_stop_info.details.fork.child_tid = child_pid; |
462 | m_stop_description = std::to_string(val: child_pid); |
463 | m_stop_description += " "; |
464 | m_stop_description += std::to_string(val: child_pid); |
465 | } |
466 | |
467 | void NativeThreadLinux::SetStoppedByVForkDone() { |
468 | SetStopped(); |
469 | |
470 | m_stop_info.reason = StopReason::eStopReasonVForkDone; |
471 | m_stop_info.signo = SIGTRAP; |
472 | } |
473 | |
474 | void NativeThreadLinux::SetStoppedWithNoReason() { |
475 | SetStopped(); |
476 | |
477 | m_stop_info.reason = StopReason::eStopReasonNone; |
478 | m_stop_info.signo = 0; |
479 | } |
480 | |
481 | void NativeThreadLinux::SetStoppedByProcessorTrace( |
482 | llvm::StringRef description) { |
483 | SetStopped(); |
484 | |
485 | m_stop_info.reason = StopReason::eStopReasonProcessorTrace; |
486 | m_stop_info.signo = 0; |
487 | m_stop_description = description.str(); |
488 | } |
489 | |
490 | void NativeThreadLinux::SetExited() { |
491 | const StateType new_state = StateType::eStateExited; |
492 | MaybeLogStateChange(new_state); |
493 | m_state = new_state; |
494 | |
495 | m_stop_info.reason = StopReason::eStopReasonThreadExiting; |
496 | } |
497 | |
498 | Status NativeThreadLinux::RequestStop() { |
499 | Log *log = GetLog(mask: LLDBLog::Thread); |
500 | |
501 | NativeProcessLinux &process = GetProcess(); |
502 | |
503 | lldb::pid_t pid = process.GetID(); |
504 | lldb::tid_t tid = GetID(); |
505 | |
506 | LLDB_LOGF(log, |
507 | "NativeThreadLinux::%s requesting thread stop(pid: %"PRIu64 |
508 | ", tid: %"PRIu64 ")", |
509 | __FUNCTION__, pid, tid); |
510 | |
511 | Status err; |
512 | errno = 0; |
513 | if (::tgkill(pid, tid, SIGSTOP) != 0) { |
514 | err = Status::FromErrno(); |
515 | LLDB_LOGF(log, |
516 | "NativeThreadLinux::%s tgkill(%"PRIu64 ", %"PRIu64 |
517 | ", SIGSTOP) failed: %s", |
518 | __FUNCTION__, pid, tid, err.AsCString()); |
519 | } |
520 | |
521 | return err; |
522 | } |
523 | |
524 | void NativeThreadLinux::MaybeLogStateChange(lldb::StateType new_state) { |
525 | Log *log = GetLog(mask: LLDBLog::Thread); |
526 | // If we're not logging, we're done. |
527 | if (!log) |
528 | return; |
529 | |
530 | // If this is a state change to the same state, we're done. |
531 | lldb::StateType old_state = m_state; |
532 | if (new_state == old_state) |
533 | return; |
534 | |
535 | LLDB_LOG(log, "pid={0}, tid={1}: changing from state {2} to {3}", |
536 | m_process.GetID(), GetID(), old_state, new_state); |
537 | } |
538 | |
539 | NativeProcessLinux &NativeThreadLinux::GetProcess() { |
540 | return static_cast<NativeProcessLinux &>(m_process); |
541 | } |
542 | |
543 | const NativeProcessLinux &NativeThreadLinux::GetProcess() const { |
544 | return static_cast<const NativeProcessLinux &>(m_process); |
545 | } |
546 | |
547 | llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> |
548 | NativeThreadLinux::GetSiginfo() const { |
549 | auto siginfo_buf = |
550 | llvm::WritableMemoryBuffer::getNewUninitMemBuffer(Size: sizeof(siginfo_t)); |
551 | Status error = |
552 | GetProcess().GetSignalInfo(tid: GetID(), siginfo: siginfo_buf->getBufferStart()); |
553 | if (!error.Success()) |
554 | return error.ToError(); |
555 | return std::move(siginfo_buf); |
556 | } |
557 |
Definitions
- LogThreadStopInfo
- NativeThreadLinux
- GetName
- GetState
- GetStopReason
- SetWatchpoint
- RemoveWatchpoint
- SetHardwareBreakpoint
- RemoveHardwareBreakpoint
- Resume
- SingleStep
- SetStoppedBySignal
- AnnotateSyncTagCheckFault
- IsStopped
- SetStopped
- SetStoppedByExec
- SetStoppedByBreakpoint
- SetStoppedByWatchpoint
- IsStoppedAtBreakpoint
- IsStoppedAtWatchpoint
- SetStoppedByTrace
- SetStoppedByFork
- SetStoppedByVForkDone
- SetStoppedWithNoReason
- SetStoppedByProcessorTrace
- SetExited
- RequestStop
- MaybeLogStateChange
- GetProcess
- GetProcess
Update your C++ knowledge – Modern C++11/14/17 Training
Find out more