LLDB  mainline
NativeThreadListDarwin.cpp
Go to the documentation of this file.
1 //===-- NativeThreadListDarwin.cpp ------------------------------------*- C++
2 //-*-===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Created by Greg Clayton on 6/19/07.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "NativeThreadListDarwin.h"
15 
16 // C includes
17 #include <inttypes.h>
18 #include <mach/vm_map.h>
19 #include <sys/sysctl.h>
20 
21 // LLDB includes
22 #include "lldb/Utility/Log.h"
23 #include "lldb/Utility/Status.h"
24 #include "lldb/Utility/Stream.h"
25 #include "lldb/lldb-enumerations.h"
26 
27 #include "NativeProcessDarwin.h"
28 #include "NativeThreadDarwin.h"
29 
30 using namespace lldb;
31 using namespace lldb_private;
32 using namespace lldb_private::process_darwin;
33 
34 NativeThreadListDarwin::NativeThreadListDarwin()
35  : m_threads(), m_threads_mutex(), m_is_64_bit(false) {}
36 
38 
39 // These methods will be accessed directly from NativeThreadDarwin
40 #if 0
41 nub_state_t
42 NativeThreadListDarwin::GetState(nub_thread_t tid)
43 {
44  MachThreadSP thread_sp (GetThreadByID (tid));
45  if (thread_sp)
46  return thread_sp->GetState();
47  return eStateInvalid;
48 }
49 
50 const char *
51 NativeThreadListDarwin::GetName (nub_thread_t tid)
52 {
53  MachThreadSP thread_sp (GetThreadByID (tid));
54  if (thread_sp)
55  return thread_sp->GetName();
56  return NULL;
57 }
58 #endif
59 
60 // TODO: figure out if we need to add this to NativeThreadDarwin yet.
61 #if 0
62 ThreadInfo::QoS
63 NativeThreadListDarwin::GetRequestedQoS (nub_thread_t tid, nub_addr_t tsd, uint64_t dti_qos_class_index)
64 {
65  MachThreadSP thread_sp (GetThreadByID (tid));
66  if (thread_sp)
67  return thread_sp->GetRequestedQoS(tsd, dti_qos_class_index);
68  return ThreadInfo::QoS();
69 }
70 
71 nub_addr_t
72 NativeThreadListDarwin::GetPThreadT (nub_thread_t tid)
73 {
74  MachThreadSP thread_sp (GetThreadByID (tid));
75  if (thread_sp)
76  return thread_sp->GetPThreadT();
77  return INVALID_NUB_ADDRESS;
78 }
79 
80 nub_addr_t
81 NativeThreadListDarwin::GetDispatchQueueT (nub_thread_t tid)
82 {
83  MachThreadSP thread_sp (GetThreadByID (tid));
84  if (thread_sp)
85  return thread_sp->GetDispatchQueueT();
86  return INVALID_NUB_ADDRESS;
87 }
88 
89 nub_addr_t
90 NativeThreadListDarwin::GetTSDAddressForThread (nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset, uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size)
91 {
92  MachThreadSP thread_sp (GetThreadByID (tid));
93  if (thread_sp)
94  return thread_sp->GetTSDAddressForThread(plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset, plo_pthread_tsd_entry_size);
95  return INVALID_NUB_ADDRESS;
96 }
97 #endif
98 
99 // TODO implement these
100 #if 0
101 nub_thread_t
102 NativeThreadListDarwin::SetCurrentThread(nub_thread_t tid)
103 {
104  MachThreadSP thread_sp (GetThreadByID (tid));
105  if (thread_sp)
106  {
107  m_current_thread = thread_sp;
108  return tid;
109  }
110  return INVALID_NUB_THREAD;
111 }
112 
113 
114 bool
115 NativeThreadListDarwin::GetThreadStoppedReason(nub_thread_t tid, struct DNBThreadStopInfo *stop_info) const
116 {
117  MachThreadSP thread_sp (GetThreadByID (tid));
118  if (thread_sp)
119  return thread_sp->GetStopException().GetStopInfo(stop_info);
120  return false;
121 }
122 
123 bool
124 NativeThreadListDarwin::GetIdentifierInfo (nub_thread_t tid, thread_identifier_info_data_t *ident_info)
125 {
126  thread_t mach_port_number = GetMachPortNumberByThreadID (tid);
127 
128  mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
129  return ::thread_info (mach_port_number, THREAD_IDENTIFIER_INFO, (thread_info_t)ident_info, &count) == KERN_SUCCESS;
130 }
131 
132 void
133 NativeThreadListDarwin::DumpThreadStoppedReason (nub_thread_t tid) const
134 {
135  MachThreadSP thread_sp (GetThreadByID (tid));
136  if (thread_sp)
137  thread_sp->GetStopException().DumpStopReason();
138 }
139 
140 const char *
141 NativeThreadListDarwin::GetThreadInfo (nub_thread_t tid) const
142 {
143  MachThreadSP thread_sp (GetThreadByID (tid));
144  if (thread_sp)
145  return thread_sp->GetBasicInfoAsString();
146  return NULL;
147 }
148 
149 #endif
150 
153  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
154  for (auto thread_sp : m_threads) {
155  if (thread_sp && (thread_sp->GetID() == tid))
156  return thread_sp;
157  }
158  return NativeThreadDarwinSP();
159 }
160 
162  ::thread_t mach_port_number) const {
163  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
164  for (auto thread_sp : m_threads) {
165  if (thread_sp && (thread_sp->GetMachPortNumber() == mach_port_number))
166  return thread_sp;
167  }
168  return NativeThreadDarwinSP();
169 }
170 
172  ::thread_t mach_port_number) const {
173  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
174  for (auto thread_sp : m_threads) {
175  if (thread_sp && (thread_sp->GetMachPortNumber() == mach_port_number))
176  return thread_sp->GetID();
177  }
178  return LLDB_INVALID_THREAD_ID;
179 }
180 
181 // TODO implement
182 #if 0
183 thread_t
184 NativeThreadListDarwin::GetMachPortNumberByThreadID (nub_thread_t globally_unique_id) const
185 {
186  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
187  MachThreadSP thread_sp;
188  const size_t num_threads = m_threads.size();
189  for (size_t idx = 0; idx < num_threads; ++idx)
190  {
191  if (m_threads[idx]->ThreadID() == globally_unique_id)
192  {
193  return m_threads[idx]->MachPortNumber();
194  }
195  }
196  return 0;
197 }
198 
199 bool
200 NativeThreadListDarwin::GetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *reg_value ) const
201 {
202  MachThreadSP thread_sp (GetThreadByID (tid));
203  if (thread_sp)
204  return thread_sp->GetRegisterValue(set, reg, reg_value);
205 
206  return false;
207 }
208 
209 bool
210 NativeThreadListDarwin::SetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *reg_value ) const
211 {
212  MachThreadSP thread_sp (GetThreadByID (tid));
213  if (thread_sp)
214  return thread_sp->SetRegisterValue(set, reg, reg_value);
215 
216  return false;
217 }
218 
219 nub_size_t
220 NativeThreadListDarwin::GetRegisterContext (nub_thread_t tid, void *buf, size_t buf_len)
221 {
222  MachThreadSP thread_sp (GetThreadByID (tid));
223  if (thread_sp)
224  return thread_sp->GetRegisterContext (buf, buf_len);
225  return 0;
226 }
227 
228 nub_size_t
229 NativeThreadListDarwin::SetRegisterContext (nub_thread_t tid, const void *buf, size_t buf_len)
230 {
231  MachThreadSP thread_sp (GetThreadByID (tid));
232  if (thread_sp)
233  return thread_sp->SetRegisterContext (buf, buf_len);
234  return 0;
235 }
236 
237 uint32_t
238 NativeThreadListDarwin::SaveRegisterState (nub_thread_t tid)
239 {
240  MachThreadSP thread_sp (GetThreadByID (tid));
241  if (thread_sp)
242  return thread_sp->SaveRegisterState ();
243  return 0;
244 }
245 
246 bool
247 NativeThreadListDarwin::RestoreRegisterState (nub_thread_t tid, uint32_t save_id)
248 {
249  MachThreadSP thread_sp (GetThreadByID (tid));
250  if (thread_sp)
251  return thread_sp->RestoreRegisterState (save_id);
252  return 0;
253 }
254 #endif
255 
257  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
258  return static_cast<size_t>(m_threads.size());
259 }
260 
261 // TODO implement
262 #if 0
263 nub_thread_t
264 NativeThreadListDarwin::ThreadIDAtIndex (nub_size_t idx) const
265 {
266  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
267  if (idx < m_threads.size())
268  return m_threads[idx]->ThreadID();
269  return INVALID_NUB_THREAD;
270 }
271 
272 nub_thread_t
273 NativeThreadListDarwin::CurrentThreadID ( )
274 {
275  MachThreadSP thread_sp;
276  CurrentThread(thread_sp);
277  if (thread_sp.get())
278  return thread_sp->ThreadID();
279  return INVALID_NUB_THREAD;
280 }
281 
282 #endif
283 
285  auto thread_sp = GetThreadByMachPortNumber(exc.thread_port);
286  if (thread_sp) {
287  thread_sp->NotifyException(exc);
288  return true;
289  }
290  return false;
291 }
292 
294  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
295  m_threads.clear();
296 }
297 
299  bool update,
300  collection *new_threads) {
302 
303  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
304  if (log)
305  log->Printf("NativeThreadListDarwin::%s() (pid = %" PRIu64 ", update = "
306  "%u) process stop count = %u",
307  __FUNCTION__, process.GetID(), update, process.GetStopID());
308 
309  if (process.GetStopID() == 0) {
310  // On our first stop, we'll record details like 32/64 bitness and select
311  // the proper architecture implementation.
312  //
313  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, (int)process.GetID()};
314 
315  struct kinfo_proc processInfo;
316  size_t bufsize = sizeof(processInfo);
317  if ((sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo,
318  &bufsize, NULL, 0) == 0) &&
319  (bufsize > 0)) {
320  if (processInfo.kp_proc.p_flag & P_LP64)
321  m_is_64_bit = true;
322  }
323 
324 // TODO implement architecture selection and abstraction.
325 #if 0
326 #if defined(__i386__) || defined(__x86_64__)
327  if (m_is_64_bit)
328  DNBArchProtocol::SetArchitecture(CPU_TYPE_X86_64);
329  else
330  DNBArchProtocol::SetArchitecture(CPU_TYPE_I386);
331 #elif defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
332  if (m_is_64_bit)
333  DNBArchProtocol::SetArchitecture(CPU_TYPE_ARM64);
334  else
335  DNBArchProtocol::SetArchitecture(CPU_TYPE_ARM);
336 #endif
337 #endif
338  }
339 
340  if (m_threads.empty() || update) {
341  thread_array_t thread_list = nullptr;
342  mach_msg_type_number_t thread_list_count = 0;
343  task_t task = process.GetTask();
344 
345  Status error;
346  auto mach_err = ::task_threads(task, &thread_list, &thread_list_count);
347  error.SetError(mach_err, eErrorTypeMachKernel);
348  if (error.Fail()) {
349  if (log)
350  log->Printf("::task_threads(task = 0x%4.4x, thread_list => %p, "
351  "thread_list_count => %u) failed: %u (%s)",
352  task, thread_list, thread_list_count, error.GetError(),
353  error.AsCString());
354  return 0;
355  }
356 
357  if (thread_list_count > 0) {
358  collection currThreads;
359  size_t idx;
360  // Iterator through the current thread list and see which threads we
361  // already have in our list (keep them), which ones we don't (add them),
362  // and which ones are not around anymore (remove them).
363  for (idx = 0; idx < thread_list_count; ++idx) {
364  // Get the Mach thread port.
365  const ::thread_t mach_port_num = thread_list[idx];
366 
367  // Get the unique thread id for the mach port number.
368  uint64_t unique_thread_id =
370  mach_port_num);
371 
372  // Retrieve the thread if it exists.
373  auto thread_sp = GetThreadByID(unique_thread_id);
374  if (thread_sp) {
375  // We are already tracking it. Keep the existing native thread
376  // instance.
377  currThreads.push_back(thread_sp);
378  } else {
379  // We don't have a native thread instance for this thread. Create it
380  // now.
381  thread_sp.reset(new NativeThreadDarwin(
382  &process, m_is_64_bit, unique_thread_id, mach_port_num));
383 
384  // Add the new thread regardless of its is user ready state. Make
385  // sure the thread is ready to be displayed and shown to users before
386  // we add this thread to our list...
387  if (thread_sp->IsUserReady()) {
388  if (new_threads)
389  new_threads->push_back(thread_sp);
390 
391  currThreads.push_back(thread_sp);
392  }
393  }
394  }
395 
396  m_threads.swap(currThreads);
397  m_current_thread.reset();
398 
399  // Free the vm memory given to us by ::task_threads()
400  vm_size_t thread_list_size =
401  (vm_size_t)(thread_list_count * sizeof(::thread_t));
402  ::vm_deallocate(::mach_task_self(), (vm_address_t)thread_list,
403  thread_list_size);
404  }
405  }
406  return static_cast<uint32_t>(m_threads.size());
407 }
408 
409 // TODO implement
410 #if 0
411 
412 void
413 NativeThreadListDarwin::CurrentThread (MachThreadSP& thread_sp)
414 {
415  // locker will keep a mutex locked until it goes out of scope
416  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
417  if (m_current_thread.get() == NULL)
418  {
419  // Figure out which thread is going to be our current thread. This is
420  // currently done by finding the first thread in the list that has a
421  // valid exception.
422  const size_t num_threads = m_threads.size();
423  for (uint32_t idx = 0; idx < num_threads; ++idx)
424  {
425  if (m_threads[idx]->GetStopException().IsValid())
426  {
428  break;
429  }
430  }
431  }
432  thread_sp = m_current_thread;
433 }
434 
435 #endif
436 
438  bool first = true;
439 
440  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
441  for (auto thread_sp : m_threads) {
442  if (thread_sp) {
443  // Handle newlines between thread entries.
444  if (first)
445  first = false;
446  else
447  stream.PutChar('\n');
448  thread_sp->Dump(stream);
449  }
450  }
451 }
452 
454  NativeProcessDarwin &process, const ResumeActionList &thread_actions) {
455  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
456 
457  // Update our thread list, because sometimes libdispatch or the kernel will
458  // spawn threads while a task is suspended.
460 
461 // TODO implement this.
462 #if 0
463  // First figure out if we were planning on running only one thread, and if
464  // so, force that thread to resume.
465  bool run_one_thread;
466  thread_t solo_thread = THREAD_NULL;
467  if ((thread_actions.GetSize() > 0) &&
468  (thread_actions.NumActionsWithState(eStateStepping) +
469  thread_actions.NumActionsWithState (eStateRunning) == 1))
470  {
471  run_one_thread = true;
472  const DNBThreadResumeAction *action_ptr = thread_actions.GetFirst();
473  size_t num_actions = thread_actions.GetSize();
474  for (size_t i = 0; i < num_actions; i++, action_ptr++)
475  {
476  if (action_ptr->state == eStateStepping || action_ptr->state == eStateRunning)
477  {
478  solo_thread = action_ptr->tid;
479  break;
480  }
481  }
482  }
483  else
484  run_one_thread = false;
485 #endif
486 
487  UpdateThreadList(process, true, &new_threads);
488 
489 #if 0
490  DNBThreadResumeAction resume_new_threads = { -1U, eStateRunning, 0, INVALID_NUB_ADDRESS };
491  // If we are planning to run only one thread, any new threads should be
492  // suspended.
493  if (run_one_thread)
494  resume_new_threads.state = eStateSuspended;
495 
496  const size_t num_new_threads = new_threads.size();
497  const size_t num_threads = m_threads.size();
498  for (uint32_t idx = 0; idx < num_threads; ++idx)
499  {
500  MachThread *thread = m_threads[idx].get();
501  bool handled = false;
502  for (uint32_t new_idx = 0; new_idx < num_new_threads; ++new_idx)
503  {
504  if (thread == new_threads[new_idx].get())
505  {
506  thread->ThreadWillResume(&resume_new_threads);
507  handled = true;
508  break;
509  }
510  }
511 
512  if (!handled)
513  {
514  const DNBThreadResumeAction *thread_action = thread_actions.GetActionForThread (thread->ThreadID(), true);
515  // There must always be a thread action for every thread.
516  assert (thread_action);
517  bool others_stopped = false;
518  if (solo_thread == thread->ThreadID())
519  others_stopped = true;
520  thread->ThreadWillResume (thread_action, others_stopped);
521  }
522  }
523 
524  if (new_threads.size())
525  {
526  for (uint32_t idx = 0; idx < num_new_threads; ++idx)
527  {
528  DNBLogThreadedIf (LOG_THREAD, "NativeThreadListDarwin::ProcessWillResume (pid = %4.4x) stop-id=%u, resuming newly discovered thread: 0x%8.8" PRIx64 ", thread-is-user-ready=%i)",
529  process->ProcessID(),
530  process->StopCount(),
531  new_threads[idx]->ThreadID(),
532  new_threads[idx]->IsUserReady());
533  }
534  }
535 #endif
536 }
537 
539  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
540 
541  // Update our thread list.
542  UpdateThreadList(process, true);
543 
544  for (auto thread_sp : m_threads) {
545  if (thread_sp)
546  thread_sp->ThreadDidStop();
547  }
548  return (uint32_t)m_threads.size();
549 }
550 
551 // Check each thread in our thread list to see if we should notify our client
552 // of the current halt in execution.
553 //
554 // Breakpoints can have callback functions associated with them than can return
555 // true to stop, or false to continue executing the inferior.
556 //
557 // RETURNS
558 // true if we should stop and notify our clients
559 // false if we should resume our child process and skip notification
560 bool NativeThreadListDarwin::ShouldStop(bool &step_more) {
561  std::lock_guard<std::recursive_mutex> locker(m_threads_mutex);
562  for (auto thread_sp : m_threads) {
563  if (thread_sp && thread_sp->ShouldStop(step_more))
564  return true;
565  }
566  return false;
567 }
568 
569 // Implement.
570 #if 0
571 
572 void
573 NativeThreadListDarwin::NotifyBreakpointChanged (const DNBBreakpoint *bp)
574 {
575  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
576  const size_t num_threads = m_threads.size();
577  for (uint32_t idx = 0; idx < num_threads; ++idx)
578  {
579  m_threads[idx]->NotifyBreakpointChanged(bp);
580  }
581 }
582 
583 
584 uint32_t
585 NativeThreadListDarwin::EnableHardwareBreakpoint (const DNBBreakpoint* bp) const
586 {
587  if (bp != NULL)
588  {
589  const size_t num_threads = m_threads.size();
590  for (uint32_t idx = 0; idx < num_threads; ++idx)
592  }
593  return INVALID_NUB_HW_INDEX;
594 }
595 
596 bool
597 NativeThreadListDarwin::DisableHardwareBreakpoint (const DNBBreakpoint* bp) const
598 {
599  if (bp != NULL)
600  {
601  const size_t num_threads = m_threads.size();
602  for (uint32_t idx = 0; idx < num_threads; ++idx)
604  }
605  return false;
606 }
607 
608 // DNBWatchpointSet() -> MachProcess::CreateWatchpoint() ->
609 // MachProcess::EnableWatchpoint() ->
610 // NativeThreadListDarwin::EnableHardwareWatchpoint().
611 uint32_t
612 NativeThreadListDarwin::EnableHardwareWatchpoint (const DNBBreakpoint* wp) const
613 {
614  uint32_t hw_index = INVALID_NUB_HW_INDEX;
615  if (wp != NULL)
616  {
617  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
618  const size_t num_threads = m_threads.size();
619  // On Mac OS X we have to prime the control registers for new threads.
620  // We do this using the control register data for the first thread, for
621  // lack of a better way of choosing.
622  bool also_set_on_task = true;
623  for (uint32_t idx = 0; idx < num_threads; ++idx)
624  {
625  if ((hw_index = m_threads[idx]->EnableHardwareWatchpoint(wp, also_set_on_task)) == INVALID_NUB_HW_INDEX)
626  {
627  // We know that idx failed for some reason. Let's rollback the
628  // transaction for [0, idx).
629  for (uint32_t i = 0; i < idx; ++i)
630  m_threads[i]->RollbackTransForHWP();
631  return INVALID_NUB_HW_INDEX;
632  }
633  also_set_on_task = false;
634  }
635  // Notify each thread to commit the pending transaction.
636  for (uint32_t idx = 0; idx < num_threads; ++idx)
637  m_threads[idx]->FinishTransForHWP();
638 
639  }
640  return hw_index;
641 }
642 
643 bool
644 NativeThreadListDarwin::DisableHardwareWatchpoint (const DNBBreakpoint* wp) const
645 {
646  if (wp != NULL)
647  {
648  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
649  const size_t num_threads = m_threads.size();
650 
651  // On Mac OS X we have to prime the control registers for new threads.
652  // We do this using the control register data for the first thread, for
653  // lack of a better way of choosing.
654  bool also_set_on_task = true;
655  for (uint32_t idx = 0; idx < num_threads; ++idx)
656  {
657  if (!m_threads[idx]->DisableHardwareWatchpoint(wp, also_set_on_task))
658  {
659  // We know that idx failed for some reason. Let's rollback the
660  // transaction for [0, idx).
661  for (uint32_t i = 0; i < idx; ++i)
662  m_threads[i]->RollbackTransForHWP();
663  return false;
664  }
665  also_set_on_task = false;
666  }
667  // Notify each thread to commit the pending transaction.
668  for (uint32_t idx = 0; idx < num_threads; ++idx)
669  m_threads[idx]->FinishTransForHWP();
670 
671  return true;
672  }
673  return false;
674 }
675 
676 uint32_t
677 NativeThreadListDarwin::NumSupportedHardwareWatchpoints () const
678 {
679  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
680  const size_t num_threads = m_threads.size();
681  // Use an arbitrary thread to retrieve the number of supported hardware
682  // watchpoints.
683  if (num_threads)
684  return m_threads[0]->NumSupportedHardwareWatchpoints();
685  return 0;
686 }
687 
688 uint32_t
690 {
691  PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
692  uint32_t should_stop = false;
693  const size_t num_threads = m_threads.size();
694  for (uint32_t idx = 0; !should_stop && idx < num_threads; ++idx)
695  {
696  if (m_threads[idx]->GetStopException().SoftSignal () == signo)
697  return idx;
698  }
699  return UINT32_MAX;
700 }
701 
702 #endif
uint32_t EnableHardwareWatchpoint(const NativeBreakpointDarwin *wp) const
const char * GetThreadInfo(lldb::tid_t tid) const
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
NativeThreadDarwinSP GetThreadByID(lldb::tid_t tid) const
Manages communication with the inferior (debugee) process.
uint32_t EnableHardwareBreakpoint(const NativeBreakpointDarwin *bp) const
static uint64_t GetGloballyUniqueThreadIDForMachPortID(::thread_t mach_port_id)
const ResumeAction * GetActionForThread(lldb::tid_t tid, bool default_ok) const
Definition: Debug.h:76
size_t NumActionsWithState(lldb::StateType state) const
Definition: Debug.h:88
void NotifyBreakpointChanged(const NativeBreakpointDarwin *bp)
uint32_t UpdateThreadList(NativeProcessDarwin &process, bool update, collection *num_threads=nullptr)
bool DisableHardwareWatchpoint(const NativeBreakpointDarwin *wp) const
#define UINT32_MAX
Definition: lldb-defines.h:31
void ProcessWillResume(NativeProcessDarwin &process, const ResumeActionList &thread_actions)
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
#define LIBLLDB_LOG_THREAD
Definition: Logging.h:16
const ResumeAction * GetFirst() const
Definition: Debug.h:119
Mach kernel error codes.
uint64_t tid_t
Definition: lldb-types.h:86
NativeThreadDarwinSP GetThreadByMachPortNumber(::thread_t mach_port_number) const
Process or thread is in the process of stepping and can not be examined.
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
pthread_t thread_t
Definition: lldb-types.h:58
size_t PutChar(char ch)
Definition: Stream.cpp:103
std::shared_ptr< NativeThreadDarwin > NativeThreadDarwinSP
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:93
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
bool DisableHardwareBreakpoint(const NativeBreakpointDarwin *bp) const
int void SetError(ValueType err, lldb::ErrorType type)
Set accesssor with an error value and type.
Definition: Status.cpp:216
Definition: SBAddress.h:15
thread_t GetMachPortNumberByThreadID(lldb::tid_t globally_unique_id) const
size_t GetSize() const
Definition: Debug.h:121
#define CPU_TYPE_ARM64
unsigned int mach_task_self()
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
ValueType GetError() const
Access the error value.
Definition: Status.cpp:174
size_t GetThreadIndexForThreadStoppedWithSignal(const int signo) const
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
#define KERN_SUCCESS
Constants returned by various RegisterContextDarwin_*** functions.
lldb::tid_t GetThreadIDByMachPortNumber(::thread_t mach_port_number) const
An error handling class.
Definition: Status.h:44
Process or thread is running and can&#39;t be examined.