LLDB  mainline
SystemRuntimeMacOSX.cpp
Go to the documentation of this file.
1 //===-- SystemRuntimeMacOSX.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 
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/ModuleSpec.h"
15 #include "lldb/Core/Section.h"
16 #include "lldb/Symbol/ObjectFile.h"
18 #include "lldb/Target/Process.h"
20 #include "lldb/Target/Queue.h"
21 #include "lldb/Target/QueueList.h"
22 #include "lldb/Target/Target.h"
23 #include "lldb/Target/Thread.h"
26 #include "lldb/Utility/FileSpec.h"
27 #include "lldb/Utility/LLDBLog.h"
28 #include "lldb/Utility/Log.h"
30 
31 #include "SystemRuntimeMacOSX.h"
32 
33 #include <memory>
34 
35 using namespace lldb;
36 using namespace lldb_private;
37 
39 
40 // Create an instance of this class. This function is filled into the plugin
41 // info class that gets handed out by the plugin factory and allows the lldb to
42 // instantiate an instance of this class.
43 SystemRuntime *SystemRuntimeMacOSX::CreateInstance(Process *process) {
44  bool create = false;
45  if (!create) {
46  create = true;
47  Module *exe_module = process->GetTarget().GetExecutableModulePointer();
48  if (exe_module) {
49  ObjectFile *object_file = exe_module->GetObjectFile();
50  if (object_file) {
51  create = (object_file->GetStrata() == ObjectFile::eStrataUser);
52  }
53  }
54 
55  if (create) {
56  const llvm::Triple &triple_ref =
57  process->GetTarget().GetArchitecture().GetTriple();
58  switch (triple_ref.getOS()) {
59  case llvm::Triple::Darwin:
60  case llvm::Triple::MacOSX:
61  case llvm::Triple::IOS:
62  case llvm::Triple::TvOS:
63  case llvm::Triple::WatchOS:
64  // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
65  create = triple_ref.getVendor() == llvm::Triple::Apple;
66  break;
67  default:
68  create = false;
69  break;
70  }
71  }
72  }
73 
74  if (create)
75  return new SystemRuntimeMacOSX(process);
76  return nullptr;
77 }
78 
79 // Constructor
81  : SystemRuntime(process), m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
82  m_get_queues_handler(process), m_get_pending_items_handler(process),
83  m_get_item_info_handler(process), m_get_thread_item_info_handler(process),
84  m_page_to_free(LLDB_INVALID_ADDRESS), m_page_to_free_size(0),
85  m_lib_backtrace_recording_info(),
86  m_dispatch_queue_offsets_addr(LLDB_INVALID_ADDRESS),
87  m_libdispatch_offsets(),
88  m_libpthread_layout_offsets_addr(LLDB_INVALID_ADDRESS),
89  m_libpthread_offsets(), m_dispatch_tsd_indexes_addr(LLDB_INVALID_ADDRESS),
90  m_libdispatch_tsd_indexes(),
91  m_dispatch_voucher_offsets_addr(LLDB_INVALID_ADDRESS),
92  m_libdispatch_voucher_offsets() {}
93 
94 // Destructor
96 
102 }
103 
104 // Clear out the state of this class.
105 void SystemRuntimeMacOSX::Clear(bool clear_process) {
106  std::lock_guard<std::recursive_mutex> guard(m_mutex);
107 
110 
111  if (clear_process)
112  m_process = nullptr;
114 }
115 
118  std::string dispatch_queue_name;
119  if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0)
120  return "";
121 
124  // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a
125  // thread - deref it to get the address of the dispatch_queue_t structure
126  // for this thread's queue.
127  Status error;
128  addr_t dispatch_queue_addr =
129  m_process->ReadPointerFromMemory(dispatch_qaddr, error);
130  if (error.Success()) {
132  // libdispatch versions 4+, pointer to dispatch name is in the queue
133  // structure.
134  addr_t pointer_to_label_address =
135  dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
136  addr_t label_addr =
137  m_process->ReadPointerFromMemory(pointer_to_label_address, error);
138  if (error.Success()) {
139  m_process->ReadCStringFromMemory(label_addr, dispatch_queue_name,
140  error);
141  }
142  } else {
143  // libdispatch versions 1-3, dispatch name is a fixed width char array
144  // in the queue structure.
145  addr_t label_addr =
146  dispatch_queue_addr + m_libdispatch_offsets.dqo_label;
147  dispatch_queue_name.resize(m_libdispatch_offsets.dqo_label_size, '\0');
148  size_t bytes_read =
149  m_process->ReadMemory(label_addr, &dispatch_queue_name[0],
151  if (bytes_read < m_libdispatch_offsets.dqo_label_size)
152  dispatch_queue_name.erase(bytes_read);
153  }
154  }
155  }
156  return dispatch_queue_name;
157 }
158 
160  addr_t dispatch_qaddr) {
161  addr_t libdispatch_queue_t_address = LLDB_INVALID_ADDRESS;
162  Status error;
163  libdispatch_queue_t_address =
164  m_process->ReadPointerFromMemory(dispatch_qaddr, error);
165  if (!error.Success()) {
166  libdispatch_queue_t_address = LLDB_INVALID_ADDRESS;
167  }
168  return libdispatch_queue_t_address;
169 }
170 
172  if (dispatch_queue_addr == LLDB_INVALID_ADDRESS || dispatch_queue_addr == 0)
173  return eQueueKindUnknown;
174 
179  Status error;
180  uint64_t width = m_process->ReadUnsignedIntegerFromMemory(
181  dispatch_queue_addr + m_libdispatch_offsets.dqo_width,
183  if (error.Success()) {
184  if (width == 1) {
185  kind = eQueueKindSerial;
186  }
187  if (width > 1) {
188  kind = eQueueKindConcurrent;
189  }
190  }
191  }
192  return kind;
193 }
194 
197  StructuredData::Dictionary *dict = dict_sp->GetAsDictionary();
198  if (dict) {
201  dict->AddIntegerItem("plo_pthread_tsd_base_offset",
203  dict->AddIntegerItem(
204  "plo_pthread_tsd_base_address_offset",
206  dict->AddIntegerItem("plo_pthread_tsd_entry_size",
208  }
209 
212  dict->AddIntegerItem("dti_queue_index",
214  dict->AddIntegerItem("dti_voucher_index",
216  dict->AddIntegerItem("dti_qos_class_index",
218  }
219  }
220 }
221 
223  if (thread_sp && thread_sp->GetStackFrameCount() > 0 &&
224  thread_sp->GetFrameWithConcreteFrameIndex(0)) {
225  const SymbolContext sym_ctx(
226  thread_sp->GetFrameWithConcreteFrameIndex(0)->GetSymbolContext(
227  eSymbolContextSymbol));
228  static ConstString g_select_symbol("__select");
229  if (sym_ctx.GetFunctionName() == g_select_symbol) {
230  return false;
231  }
232  }
233  return true;
234 }
235 
239 
240  if (dispatch_qaddr == LLDB_INVALID_ADDRESS || dispatch_qaddr == 0)
241  return queue_id;
242 
245  // dispatch_qaddr is from a thread_info(THREAD_IDENTIFIER_INFO) call for a
246  // thread - deref it to get the address of the dispatch_queue_t structure
247  // for this thread's queue.
248  Status error;
249  uint64_t dispatch_queue_addr =
250  m_process->ReadPointerFromMemory(dispatch_qaddr, error);
251  if (error.Success()) {
252  addr_t serialnum_address =
253  dispatch_queue_addr + m_libdispatch_offsets.dqo_serialnum;
255  serialnum_address, m_libdispatch_offsets.dqo_serialnum_size,
257  if (error.Success()) {
258  queue_id = serialnum;
259  }
260  }
261  }
262 
263  return queue_id;
264 }
265 
268  return;
269 
270  static ConstString g_dispatch_queue_offsets_symbol_name(
271  "dispatch_queue_offsets");
272  const Symbol *dispatch_queue_offsets_symbol = nullptr;
273 
274  // libdispatch symbols were in libSystem.B.dylib up through Mac OS X 10.6
275  // ("Snow Leopard")
276  ModuleSpec libSystem_module_spec(FileSpec("libSystem.B.dylib"));
277  ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
278  libSystem_module_spec));
279  if (module_sp)
280  dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
281  g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
282 
283  // libdispatch symbols are in their own dylib as of Mac OS X 10.7 ("Lion")
284  // and later
285  if (dispatch_queue_offsets_symbol == nullptr) {
286  ModuleSpec libdispatch_module_spec(FileSpec("libdispatch.dylib"));
287  module_sp = m_process->GetTarget().GetImages().FindFirstModule(
288  libdispatch_module_spec);
289  if (module_sp)
290  dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType(
291  g_dispatch_queue_offsets_symbol_name, eSymbolTypeData);
292  }
293  if (dispatch_queue_offsets_symbol)
295  dispatch_queue_offsets_symbol->GetLoadAddress(&m_process->GetTarget());
296 }
297 
300  return;
301 
303 
304  uint8_t memory_buffer[sizeof(struct LibdispatchOffsets)];
305  DataExtractor data(memory_buffer, sizeof(memory_buffer),
308 
309  Status error;
311  sizeof(memory_buffer),
312  error) == sizeof(memory_buffer)) {
313  lldb::offset_t data_offset = 0;
314 
315  // The struct LibdispatchOffsets is a series of uint16_t's - extract them
316  // all in one big go.
317  data.GetU16(&data_offset, &m_libdispatch_offsets.dqo_version,
318  sizeof(struct LibdispatchOffsets) / sizeof(uint16_t));
319  }
320 }
321 
324  return;
325 
326  static ConstString g_libpthread_layout_offsets_symbol_name(
327  "pthread_layout_offsets");
328  const Symbol *libpthread_layout_offsets_symbol = nullptr;
329 
330  ModuleSpec libpthread_module_spec(FileSpec("libsystem_pthread.dylib"));
331  ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
332  libpthread_module_spec));
333  if (module_sp) {
334  libpthread_layout_offsets_symbol =
335  module_sp->FindFirstSymbolWithNameAndType(
336  g_libpthread_layout_offsets_symbol_name, eSymbolTypeData);
337  if (libpthread_layout_offsets_symbol) {
339  libpthread_layout_offsets_symbol->GetLoadAddress(
340  &m_process->GetTarget());
341  }
342  }
343 }
344 
347  return;
348 
350 
352  uint8_t memory_buffer[sizeof(struct LibpthreadOffsets)];
353  DataExtractor data(memory_buffer, sizeof(memory_buffer),
356  Status error;
358  sizeof(memory_buffer),
359  error) == sizeof(memory_buffer)) {
360  lldb::offset_t data_offset = 0;
361 
362  // The struct LibpthreadOffsets is a series of uint16_t's - extract them
363  // all in one big go.
364  data.GetU16(&data_offset, &m_libpthread_offsets.plo_version,
365  sizeof(struct LibpthreadOffsets) / sizeof(uint16_t));
366  }
367  }
368 }
369 
372  return;
373 
374  static ConstString g_libdispatch_tsd_indexes_symbol_name(
375  "dispatch_tsd_indexes");
376  const Symbol *libdispatch_tsd_indexes_symbol = nullptr;
377 
378  ModuleSpec libpthread_module_spec(FileSpec("libdispatch.dylib"));
379  ModuleSP module_sp(m_process->GetTarget().GetImages().FindFirstModule(
380  libpthread_module_spec));
381  if (module_sp) {
382  libdispatch_tsd_indexes_symbol = module_sp->FindFirstSymbolWithNameAndType(
383  g_libdispatch_tsd_indexes_symbol_name, eSymbolTypeData);
384  if (libdispatch_tsd_indexes_symbol) {
386  libdispatch_tsd_indexes_symbol->GetLoadAddress(
387  &m_process->GetTarget());
388  }
389  }
390 }
391 
394  return;
395 
397 
399 
400 // We don't need to check the version number right now, it will be at least 2,
401 // but keep this code around to fetch just the version # for the future where
402 // we need to fetch alternate versions of the struct.
403 #if 0
404  uint16_t dti_version = 2;
405  Address dti_struct_addr;
407  {
408  Status error;
409  uint16_t version = m_process->GetTarget().ReadUnsignedIntegerFromMemory (dti_struct_addr, false, 2, UINT16_MAX, error);
410  if (error.Success() && dti_version != UINT16_MAX)
411  {
412  dti_version = version;
413  }
414  }
415 #endif
416 
417  TypeSystemClangSP scratch_ts_sp =
418  ScratchTypeSystemClang::GetForTarget(m_process->GetTarget());
420  CompilerType uint16 =
421  scratch_ts_sp->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16);
422  CompilerType dispatch_tsd_indexes_s = scratch_ts_sp->CreateRecordType(
424  "__lldb_dispatch_tsd_indexes_s", clang::TTK_Struct,
426 
427  TypeSystemClang::StartTagDeclarationDefinition(dispatch_tsd_indexes_s);
428  TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
429  "dti_version", uint16,
431  TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
432  "dti_queue_index", uint16,
434  TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
435  "dti_voucher_index", uint16,
437  TypeSystemClang::AddFieldToRecordType(dispatch_tsd_indexes_s,
438  "dti_qos_class_index", uint16,
440  TypeSystemClang::CompleteTagDeclarationDefinition(dispatch_tsd_indexes_s);
441 
443  dispatch_tsd_indexes_s);
444 
446  struct_reader.GetField<uint16_t>(ConstString("dti_version"));
448  struct_reader.GetField<uint16_t>(ConstString("dti_queue_index"));
450  struct_reader.GetField<uint16_t>(ConstString("dti_voucher_index"));
452  struct_reader.GetField<uint16_t>(ConstString("dti_qos_class_index"));
453  }
454  }
455 }
456 
458  ConstString type) {
459  ThreadSP originating_thread_sp;
460  if (BacktraceRecordingHeadersInitialized() && type == "libdispatch") {
461  Status error;
462 
463  // real_thread is either an actual, live thread (in which case we need to
464  // call into libBacktraceRecording to find its originator) or it is an
465  // extended backtrace itself, in which case we get the token from it and
466  // call into libBacktraceRecording to find the originator of that token.
467 
468  if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) {
469  originating_thread_sp = GetExtendedBacktraceFromItemRef(
470  real_thread->GetExtendedBacktraceToken());
471  } else {
472  ThreadSP cur_thread_sp(
476  *cur_thread_sp.get(), real_thread->GetID(), m_page_to_free,
480  if (ret.item_buffer_ptr != 0 &&
482  ret.item_buffer_size > 0) {
483  DataBufferHeap data(ret.item_buffer_size, 0);
484  if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(),
485  ret.item_buffer_size, error) &&
486  error.Success()) {
487  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
490  ItemInfo item = ExtractItemInfoFromBuffer(extractor);
491  originating_thread_sp = std::make_shared<HistoryThread>(
493  originating_thread_sp->SetExtendedBacktraceToken(
495  originating_thread_sp->SetQueueName(
496  item.enqueuing_queue_label.c_str());
497  originating_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
498  // originating_thread_sp->SetThreadName
499  // (item.enqueuing_thread_label.c_str());
500  }
503  }
504  }
505  } else if (type == "Application Specific Backtrace") {
506  StructuredData::ObjectSP thread_extended_sp =
507  real_thread->GetExtendedInfo();
508 
509  if (!thread_extended_sp)
510  return {};
511 
512  StructuredData::Array *thread_extended_info =
513  thread_extended_sp->GetAsArray();
514 
515  if (!thread_extended_info || !thread_extended_info->GetSize())
516  return {};
517 
518  std::vector<addr_t> app_specific_backtrace_pcs;
519 
520  auto extract_frame_pc =
521  [&app_specific_backtrace_pcs](StructuredData::Object *obj) -> bool {
522  if (!obj)
523  return false;
524 
526  if (!dict)
527  return false;
528 
530  if (!dict->GetValueForKeyAsInteger("pc", pc))
531  return false;
532 
533  app_specific_backtrace_pcs.push_back(pc);
534 
535  return pc != LLDB_INVALID_ADDRESS;
536  };
537 
538  if (!thread_extended_info->ForEach(extract_frame_pc))
539  return {};
540 
541  originating_thread_sp =
542  std::make_shared<HistoryThread>(*m_process, real_thread->GetIndexID(),
543  app_specific_backtrace_pcs, true);
544  originating_thread_sp->SetQueueName(type.AsCString());
545  }
546  return originating_thread_sp;
547 }
548 
549 ThreadSP
551  ThreadSP return_thread_sp;
552 
554  ThreadSP cur_thread_sp(
556  Status error;
557  ret = m_get_item_info_handler.GetItemInfo(*cur_thread_sp.get(), item_ref,
559  error);
562  if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS &&
563  ret.item_buffer_size > 0) {
564  DataBufferHeap data(ret.item_buffer_size, 0);
565  if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(),
566  ret.item_buffer_size, error) &&
567  error.Success()) {
568  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
571  ItemInfo item = ExtractItemInfoFromBuffer(extractor);
572  return_thread_sp = std::make_shared<HistoryThread>(
574  return_thread_sp->SetExtendedBacktraceToken(item.item_that_enqueued_this);
575  return_thread_sp->SetQueueName(item.enqueuing_queue_label.c_str());
576  return_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
577  // return_thread_sp->SetThreadName
578  // (item.enqueuing_thread_label.c_str());
579 
582  }
583  }
584  return return_thread_sp;
585 }
586 
587 ThreadSP
589  ConstString type) {
590  ThreadSP extended_thread_sp;
591  if (type != "libdispatch")
592  return extended_thread_sp;
593 
594  extended_thread_sp = std::make_shared<HistoryThread>(
595  *m_process, queue_item_sp->GetEnqueueingThreadID(),
596  queue_item_sp->GetEnqueueingBacktrace());
597  extended_thread_sp->SetExtendedBacktraceToken(
598  queue_item_sp->GetItemThatEnqueuedThis());
599  extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str());
600  extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID());
601  // extended_thread_sp->SetThreadName
602  // (queue_item_sp->GetThreadLabel().c_str());
603 
604  return extended_thread_sp;
605 }
606 
607 /* Returns true if we were able to get the version / offset information
608  * out of libBacktraceRecording. false means we were unable to retrieve
609  * this; the queue_info_version field will be 0.
610  */
611 
614  return true;
615 
616  addr_t queue_info_version_address = LLDB_INVALID_ADDRESS;
617  addr_t queue_info_data_offset_address = LLDB_INVALID_ADDRESS;
618  addr_t item_info_version_address = LLDB_INVALID_ADDRESS;
619  addr_t item_info_data_offset_address = LLDB_INVALID_ADDRESS;
620  Target &target = m_process->GetTarget();
621 
622  static ConstString introspection_dispatch_queue_info_version(
623  "__introspection_dispatch_queue_info_version");
624  SymbolContextList sc_list;
626  introspection_dispatch_queue_info_version, eSymbolTypeData, sc_list);
627  if (!sc_list.IsEmpty()) {
628  SymbolContext sc;
629  sc_list.GetContextAtIndex(0, sc);
630  AddressRange addr_range;
631  sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
632  queue_info_version_address =
633  addr_range.GetBaseAddress().GetLoadAddress(&target);
634  }
635  sc_list.Clear();
636 
637  static ConstString introspection_dispatch_queue_info_data_offset(
638  "__introspection_dispatch_queue_info_data_offset");
640  introspection_dispatch_queue_info_data_offset, eSymbolTypeData, sc_list);
641  if (!sc_list.IsEmpty()) {
642  SymbolContext sc;
643  sc_list.GetContextAtIndex(0, sc);
644  AddressRange addr_range;
645  sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
646  queue_info_data_offset_address =
647  addr_range.GetBaseAddress().GetLoadAddress(&target);
648  }
649  sc_list.Clear();
650 
651  static ConstString introspection_dispatch_item_info_version(
652  "__introspection_dispatch_item_info_version");
654  introspection_dispatch_item_info_version, eSymbolTypeData, sc_list);
655  if (!sc_list.IsEmpty()) {
656  SymbolContext sc;
657  sc_list.GetContextAtIndex(0, sc);
658  AddressRange addr_range;
659  sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
660  item_info_version_address =
661  addr_range.GetBaseAddress().GetLoadAddress(&target);
662  }
663  sc_list.Clear();
664 
665  static ConstString introspection_dispatch_item_info_data_offset(
666  "__introspection_dispatch_item_info_data_offset");
668  introspection_dispatch_item_info_data_offset, eSymbolTypeData, sc_list);
669  if (!sc_list.IsEmpty()) {
670  SymbolContext sc;
671  sc_list.GetContextAtIndex(0, sc);
672  AddressRange addr_range;
673  sc.GetAddressRange(eSymbolContextSymbol, 0, false, addr_range);
674  item_info_data_offset_address =
675  addr_range.GetBaseAddress().GetLoadAddress(&target);
676  }
677 
678  if (queue_info_version_address != LLDB_INVALID_ADDRESS &&
679  queue_info_data_offset_address != LLDB_INVALID_ADDRESS &&
680  item_info_version_address != LLDB_INVALID_ADDRESS &&
681  item_info_data_offset_address != LLDB_INVALID_ADDRESS) {
682  Status error;
684  m_process->ReadUnsignedIntegerFromMemory(queue_info_version_address, 2,
685  0, error);
686  if (error.Success()) {
689  queue_info_data_offset_address, 2, 0, error);
690  if (error.Success()) {
692  m_process->ReadUnsignedIntegerFromMemory(item_info_version_address,
693  2, 0, error);
694  if (error.Success()) {
697  item_info_data_offset_address, 2, 0, error);
698  if (!error.Success()) {
700  }
701  } else {
703  }
704  } else {
706  }
707  }
708  }
709 
711 }
712 
713 const std::vector<ConstString> &
715  if (m_types.size() == 0) {
716  m_types.push_back(ConstString("libdispatch"));
717  m_types.push_back(ConstString("Application Specific Backtrace"));
718  // We could have pthread as another type in the future if we have a way of
719  // gathering that information & it's useful to distinguish between them.
720  }
721  return m_types;
722 }
723 
725  lldb_private::QueueList &queue_list) {
728  ThreadSP cur_thread_sp(
730  if (cur_thread_sp) {
731  Status error;
732  queue_info_pointer = m_get_queues_handler.GetCurrentQueues(
733  *cur_thread_sp.get(), m_page_to_free, m_page_to_free_size, error);
736  if (error.Success()) {
737 
738  if (queue_info_pointer.count > 0 &&
739  queue_info_pointer.queues_buffer_size > 0 &&
740  queue_info_pointer.queues_buffer_ptr != 0 &&
741  queue_info_pointer.queues_buffer_ptr != LLDB_INVALID_ADDRESS) {
742  PopulateQueuesUsingLibBTR(queue_info_pointer.queues_buffer_ptr,
743  queue_info_pointer.queues_buffer_size,
744  queue_info_pointer.count, queue_list);
745  }
746  }
747  }
748  }
749 
750  // We either didn't have libBacktraceRecording (and need to create the queues
751  // list based on threads) or we did get the queues list from
752  // libBacktraceRecording but some special queues may not be included in its
753  // information. This is needed because libBacktraceRecording will only list
754  // queues with pending or running items by default - but the magic com.apple
755  // .main-thread queue on thread 1 is always around.
756 
757  for (ThreadSP thread_sp : m_process->Threads()) {
758  if (thread_sp->GetAssociatedWithLibdispatchQueue() != eLazyBoolNo) {
759  if (thread_sp->GetQueueID() != LLDB_INVALID_QUEUE_ID) {
760  if (queue_list.FindQueueByID(thread_sp->GetQueueID()).get() ==
761  nullptr) {
762  QueueSP queue_sp(new Queue(m_process->shared_from_this(),
763  thread_sp->GetQueueID(),
764  thread_sp->GetQueueName()));
765  if (thread_sp->ThreadHasQueueInformation()) {
766  queue_sp->SetKind(thread_sp->GetQueueKind());
767  queue_sp->SetLibdispatchQueueAddress(
768  thread_sp->GetQueueLibdispatchQueueAddress());
769  queue_list.AddQueue(queue_sp);
770  } else {
771  queue_sp->SetKind(
772  GetQueueKind(thread_sp->GetQueueLibdispatchQueueAddress()));
773  queue_sp->SetLibdispatchQueueAddress(
774  thread_sp->GetQueueLibdispatchQueueAddress());
775  queue_list.AddQueue(queue_sp);
776  }
777  }
778  }
779  }
780  }
781 }
782 
783 // Returns either an array of introspection_dispatch_item_info_ref's for the
784 // pending items on a queue or an array introspection_dispatch_item_info_ref's
785 // and code addresses for the pending items on a queue. The information about
786 // each of these pending items then needs to be fetched individually by passing
787 // the ref to libBacktraceRecording.
788 
791  PendingItemsForQueue pending_item_refs = {};
793  ThreadSP cur_thread_sp(
795  if (cur_thread_sp) {
796  Status error;
797  pending_items_pointer = m_get_pending_items_handler.GetPendingItems(
798  *cur_thread_sp.get(), queue, m_page_to_free, m_page_to_free_size,
799  error);
802  if (error.Success()) {
803  if (pending_items_pointer.count > 0 &&
804  pending_items_pointer.items_buffer_size > 0 &&
805  pending_items_pointer.items_buffer_ptr != 0 &&
806  pending_items_pointer.items_buffer_ptr != LLDB_INVALID_ADDRESS) {
807  DataBufferHeap data(pending_items_pointer.items_buffer_size, 0);
808  if (m_process->ReadMemory(
809  pending_items_pointer.items_buffer_ptr, data.GetBytes(),
810  pending_items_pointer.items_buffer_size, error)) {
811  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
814 
815  // We either have an array of
816  // void* item_ref
817  // (old style) or we have a structure returned which looks like
818  //
819  // struct introspection_dispatch_pending_item_info_s {
820  // void *item_ref;
821  // void *function_or_block;
822  // };
823  //
824  // struct introspection_dispatch_pending_items_array_s {
825  // uint32_t version;
826  // uint32_t size_of_item_info;
827  // introspection_dispatch_pending_item_info_s items[];
828  // }
829 
830  offset_t offset = 0;
831  uint64_t i = 0;
832  uint32_t version = extractor.GetU32(&offset);
833  if (version == 1) {
834  pending_item_refs.new_style = true;
835  uint32_t item_size = extractor.GetU32(&offset);
836  uint32_t start_of_array_offset = offset;
837  while (offset < pending_items_pointer.items_buffer_size &&
838  i < pending_items_pointer.count) {
839  offset = start_of_array_offset + (i * item_size);
841  item.item_ref = extractor.GetAddress(&offset);
842  item.code_address = extractor.GetAddress(&offset);
843  pending_item_refs.item_refs_and_code_addresses.push_back(item);
844  i++;
845  }
846  } else {
847  offset = 0;
848  pending_item_refs.new_style = false;
849  while (offset < pending_items_pointer.items_buffer_size &&
850  i < pending_items_pointer.count) {
852  item.item_ref = extractor.GetAddress(&offset);
854  pending_item_refs.item_refs_and_code_addresses.push_back(item);
855  i++;
856  }
857  }
858  }
859  m_page_to_free = pending_items_pointer.items_buffer_ptr;
860  m_page_to_free_size = pending_items_pointer.items_buffer_size;
861  }
862  }
863  }
864  return pending_item_refs;
865 }
866 
869  PendingItemsForQueue pending_item_refs =
871  for (ItemRefAndCodeAddress pending_item :
872  pending_item_refs.item_refs_and_code_addresses) {
873  Address addr;
875  addr);
876  QueueItemSP queue_item_sp(new QueueItem(queue->shared_from_this(),
877  m_process->shared_from_this(),
878  pending_item.item_ref, addr));
879  queue->PushPendingQueueItem(queue_item_sp);
880  }
881  }
882 }
883 
885  addr_t item_ref) {
887 
888  ThreadSP cur_thread_sp(
890  Status error;
891  ret = m_get_item_info_handler.GetItemInfo(*cur_thread_sp.get(), item_ref,
893  error);
896  if (ret.item_buffer_ptr != 0 && ret.item_buffer_ptr != LLDB_INVALID_ADDRESS &&
897  ret.item_buffer_size > 0) {
898  DataBufferHeap data(ret.item_buffer_size, 0);
899  if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(),
900  ret.item_buffer_size, error) &&
901  error.Success()) {
902  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
905  ItemInfo item = ExtractItemInfoFromBuffer(extractor);
907  queue_item->SetEnqueueingThreadID(item.enqueuing_thread_id);
909  queue_item->SetStopID(item.stop_id);
911  queue_item->SetThreadLabel(item.enqueuing_thread_label);
912  queue_item->SetQueueLabel(item.enqueuing_queue_label);
913  queue_item->SetTargetQueueLabel(item.target_queue_label);
914  }
917  }
918 }
919 
921  lldb::addr_t queues_buffer, uint64_t queues_buffer_size, uint64_t count,
922  lldb_private::QueueList &queue_list) {
923  Status error;
924  DataBufferHeap data(queues_buffer_size, 0);
925  Log *log = GetLog(LLDBLog::SystemRuntime);
926  if (m_process->ReadMemory(queues_buffer, data.GetBytes(), queues_buffer_size,
927  error) == queues_buffer_size &&
928  error.Success()) {
929  // We've read the information out of inferior memory; free it on the next
930  // call we make
931  m_page_to_free = queues_buffer;
932  m_page_to_free_size = queues_buffer_size;
933 
934  DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
937  offset_t offset = 0;
938  uint64_t queues_read = 0;
939 
940  // The information about the queues is stored in this format (v1): typedef
941  // struct introspection_dispatch_queue_info_s {
942  // uint32_t offset_to_next;
943  // dispatch_queue_t queue;
944  // uint64_t serialnum; // queue's serialnum in the process, as
945  // provided by libdispatch
946  // uint32_t running_work_items_count;
947  // uint32_t pending_work_items_count;
948  //
949  // char data[]; // Starting here, we have variable-length data:
950  // // char queue_label[];
951  // } introspection_dispatch_queue_info_s;
952 
953  while (queues_read < count && offset < queues_buffer_size) {
954  offset_t start_of_this_item = offset;
955 
956  uint32_t offset_to_next = extractor.GetU32(&offset);
957 
958  offset += 4; // Skip over the 4 bytes of reserved space
959  addr_t queue = extractor.GetAddress(&offset);
960  uint64_t serialnum = extractor.GetU64(&offset);
961  uint32_t running_work_items_count = extractor.GetU32(&offset);
962  uint32_t pending_work_items_count = extractor.GetU32(&offset);
963 
964  // Read the first field of the variable length data
965  offset = start_of_this_item +
967  const char *queue_label = extractor.GetCStr(&offset);
968  if (queue_label == nullptr)
969  queue_label = "";
970 
971  offset_t start_of_next_item = start_of_this_item + offset_to_next;
972  offset = start_of_next_item;
973 
974  LLDB_LOGF(log,
975  "SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR added "
976  "queue with dispatch_queue_t 0x%" PRIx64
977  ", serial number 0x%" PRIx64
978  ", running items %d, pending items %d, name '%s'",
979  queue, serialnum, running_work_items_count,
980  pending_work_items_count, queue_label);
981 
982  QueueSP queue_sp(
983  new Queue(m_process->shared_from_this(), serialnum, queue_label));
984  queue_sp->SetNumRunningWorkItems(running_work_items_count);
985  queue_sp->SetNumPendingWorkItems(pending_work_items_count);
986  queue_sp->SetLibdispatchQueueAddress(queue);
987  queue_sp->SetKind(GetQueueKind(queue));
988  queue_list.AddQueue(queue_sp);
989  queues_read++;
990  }
991  }
992 }
993 
995  lldb_private::DataExtractor &extractor) {
996  ItemInfo item;
997 
998  offset_t offset = 0;
999 
1000  item.item_that_enqueued_this = extractor.GetAddress(&offset);
1001  item.function_or_block = extractor.GetAddress(&offset);
1002  item.enqueuing_thread_id = extractor.GetU64(&offset);
1003  item.enqueuing_queue_serialnum = extractor.GetU64(&offset);
1004  item.target_queue_serialnum = extractor.GetU64(&offset);
1005  item.enqueuing_callstack_frame_count = extractor.GetU32(&offset);
1006  item.stop_id = extractor.GetU32(&offset);
1007 
1009 
1010  for (uint32_t i = 0; i < item.enqueuing_callstack_frame_count; i++) {
1011  item.enqueuing_callstack.push_back(extractor.GetAddress(&offset));
1012  }
1013  item.enqueuing_thread_label = extractor.GetCStr(&offset);
1014  item.enqueuing_queue_label = extractor.GetCStr(&offset);
1015  item.target_queue_label = extractor.GetCStr(&offset);
1016 
1017  return item;
1018 }
1019 
1021  PluginManager::RegisterPlugin(
1023  "System runtime plugin for Mac OS X native libraries.", CreateInstance);
1024 }
1025 
1027  PluginManager::UnregisterPlugin(CreateInstance);
1028 }
SystemRuntimeMacOSX::LibdispatchOffsets::IsValid
bool IsValid()
Definition: SystemRuntimeMacOSX.h:187
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::ObjectFile::GetArchitecture
virtual ArchSpec GetArchitecture()=0
Get the ArchSpec for this object file.
lldb_private::Module::GetObjectFile
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1232
LLDB_BREAK_ID_IS_VALID
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:39
SystemRuntimeMacOSX::LibdispatchTSDIndexes::dti_qos_class_index
uint64_t dti_qos_class_index
Definition: SystemRuntimeMacOSX.h:208
lldb_private::DataBufferHeap::GetByteSize
lldb::offset_t GetByteSize() const override
Definition: DataBufferHeap.cpp:43
lldb_private::QueueItem::SetEnqueueingQueueID
void SetEnqueueingQueueID(lldb::queue_id_t qid)
Definition: QueueItem.h:104
lldb_private::StructuredData::Dictionary
Definition: StructuredData.h:368
SystemRuntimeMacOSX::m_dispatch_queue_offsets_addr
lldb::addr_t m_dispatch_queue_offsets_addr
Definition: SystemRuntimeMacOSX.h:272
SystemRuntimeMacOSX::Clear
void Clear(bool clear_process)
Definition: SystemRuntimeMacOSX.cpp:105
lldb_private::DataExtractor::GetAddress
uint64_t GetAddress(lldb::offset_t *offset_ptr) const
Extract an address from *offset_ptr.
Definition: DataExtractor.cpp:649
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_label
uint16_t dqo_label
Definition: SystemRuntimeMacOSX.h:142
lldb_private::Queue::PushPendingQueueItem
void PushPendingQueueItem(lldb::QueueItemSP item)
Definition: Queue.h:125
lldb_private::Process::ReadMemory
virtual size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, Status &error)
Read of memory from a process.
Definition: Process.cpp:1926
lldb_private::AppleGetQueuesHandler::GetCurrentQueues
GetQueuesReturnInfo GetCurrentQueues(Thread &thread, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the list of queues that exist (with any active or pending items) via a call to introspection_get_...
Definition: AppleGetQueuesHandler.cpp:218
SystemRuntimeMacOSX::m_libdispatch_offsets
struct LibdispatchOffsets m_libdispatch_offsets
Definition: SystemRuntimeMacOSX.h:273
SystemRuntimeMacOSX::m_dispatch_tsd_indexes_addr
lldb::addr_t m_dispatch_tsd_indexes_addr
Definition: SystemRuntimeMacOSX.h:278
ModuleSpec.h
lldb_private::StructuredData::Array
Definition: StructuredData.h:171
SystemRuntimeMacOSX::GetQueueNameFromThreadQAddress
std::string GetQueueNameFromThreadQAddress(lldb::addr_t dispatch_qaddr) override
Get the queue name for a thread given a thread's dispatch_qaddr.
Definition: SystemRuntimeMacOSX.cpp:117
SystemRuntimeMacOSX::GetExtendedBacktraceThread
lldb::ThreadSP GetExtendedBacktraceThread(lldb::ThreadSP thread, lldb_private::ConstString type) override
Return a Thread which shows the origin of this thread's creation.
Definition: SystemRuntimeMacOSX.cpp:457
lldb_private::Symbol
Definition: Symbol.h:20
SystemRuntimeMacOSX::ItemInfo::enqueuing_queue_serialnum
uint64_t enqueuing_queue_serialnum
Definition: SystemRuntimeMacOSX.h:123
lldb_private::QueueItem::SetEnqueueingBacktrace
void SetEnqueueingBacktrace(std::vector< lldb::addr_t > backtrace)
Definition: QueueItem.h:116
lldb_private::SymbolContext::GetAddressRange
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
Definition: SymbolContext.cpp:380
SystemRuntimeMacOSX::LibdispatchTSDIndexes::IsValid
bool IsValid()
Definition: SystemRuntimeMacOSX.h:212
SystemRuntimeMacOSX::m_get_thread_item_info_handler
lldb_private::AppleGetThreadItemInfoHandler m_get_thread_item_info_handler
Definition: SystemRuntimeMacOSX.h:266
SystemRuntimeMacOSX::ReadLibpthreadOffsets
void ReadLibpthreadOffsets()
Definition: SystemRuntimeMacOSX.cpp:345
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:344
lldb_private::Process
Definition: Process.h:338
lldb_private::Process::ClearBreakpointSiteByID
Status ClearBreakpointSiteByID(lldb::user_id_t break_id)
Definition: Process.cpp:1581
Module.h
lldb_private::Process::GetThreadList
ThreadList & GetThreadList()
Definition: Process.h:2095
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1219
StoppointCallbackContext.h
lldb_private::QueueList::AddQueue
void AddQueue(lldb::QueueSP queue)
Add a Queue to the QueueList.
Definition: QueueList.cpp:40
SystemRuntimeMacOSX::LibdispatchTSDIndexes::dti_version
uint16_t dti_version
Definition: SystemRuntimeMacOSX.h:205
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:631
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1258
lldb_private::Module
Definition: Module.h:87
lldb_private::SystemRuntime
Definition: SystemRuntime.h:43
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:192
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
SystemRuntimeMacOSX::ItemRefAndCodeAddress
Definition: SystemRuntimeMacOSX.h:234
lldb_private::Process::IsAlive
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1086
SystemRuntimeMacOSX::SystemRuntimeMacOSX
SystemRuntimeMacOSX(lldb_private::Process *process)
Definition: SystemRuntimeMacOSX.cpp:80
SystemRuntimeMacOSX::ItemInfo::enqueuing_callstack_frame_count
uint32_t enqueuing_callstack_frame_count
Definition: SystemRuntimeMacOSX.h:125
HistoryThread.h
SystemRuntimeMacOSX::PendingItemsForQueue::new_style
bool new_style
Definition: SystemRuntimeMacOSX.h:240
lldb_private::Process::ReadCStringFromMemory
size_t ReadCStringFromMemory(lldb::addr_t vm_addr, char *cstr, size_t cstr_max_len, Status &error)
Read a NULL terminated C string from memory.
Definition: Process.cpp:1992
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:463
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
pc
@ pc
Definition: CompactUnwindInfo.cpp:1250
SystemRuntimeMacOSX::Initialize
static void Initialize()
Definition: SystemRuntimeMacOSX.cpp:1020
SystemRuntimeMacOSX::m_get_pending_items_handler
lldb_private::AppleGetPendingItemsHandler m_get_pending_items_handler
Definition: SystemRuntimeMacOSX.h:264
lldb_private::AppleGetPendingItemsHandler::GetPendingItemsReturnInfo::count
uint64_t count
Definition: AppleGetPendingItemsHandler.h:56
lldb_private::ProcessStructReader
Definition: ProcessStructReader.h:27
SystemRuntimeMacOSX::ItemInfo::enqueuing_thread_id
uint64_t enqueuing_thread_id
Definition: SystemRuntimeMacOSX.h:122
lldb_private::AppleGetThreadItemInfoHandler::GetThreadItemInfoReturnInfo::item_buffer_size
lldb::addr_t item_buffer_size
Definition: AppleGetThreadItemInfoHandler.h:52
lldb_private::Target::ResolveLoadAddress
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
Definition: Target.cpp:3000
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
Section.h
lldb_private::SymbolContextList::Clear
void Clear()
Clear the object's state.
Definition: SymbolContext.cpp:1240
SystemRuntimeMacOSX::LibpthreadOffsets::IsValid
bool IsValid()
Definition: SystemRuntimeMacOSX.h:223
lldb_private::DataExtractor::GetU64
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
Definition: DataExtractor.cpp:474
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:946
lldb_private::QueueItem::SetTargetQueueLabel
void SetTargetQueueLabel(std::string queue_name)
Definition: QueueItem.h:130
lldb_private::AppleGetThreadItemInfoHandler::GetThreadItemInfoReturnInfo
Definition: AppleGetThreadItemInfoHandler.h:49
SystemRuntimeMacOSX::ItemInfo::item_that_enqueued_this
lldb::addr_t item_that_enqueued_this
Definition: SystemRuntimeMacOSX.h:120
Process.h
lldb_private::StructuredData::Dictionary::GetValueForKeyAsInteger
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
Definition: StructuredData.h:429
SystemRuntimeMacOSX::BacktraceRecordingHeadersInitialized
bool BacktraceRecordingHeadersInitialized()
Definition: SystemRuntimeMacOSX.cpp:612
SystemRuntimeMacOSX::GetExtendedBacktraceTypes
const std::vector< lldb_private::ConstString > & GetExtendedBacktraceTypes() override
Return a list of thread origin extended backtraces that may be available.
Definition: SystemRuntimeMacOSX.cpp:714
lldb_private::ModuleList::FindSymbolsWithNameAndType
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list) const
Definition: ModuleList.cpp:509
SystemRuntimeMacOSX
Definition: SystemRuntimeMacOSX.h:31
Target.h
lldb::eQueueKindSerial
@ eQueueKindSerial
Definition: lldb-enumerations.h:970
SystemRuntimeMacOSX::ExtractItemInfoFromBuffer
ItemInfo ExtractItemInfoFromBuffer(lldb_private::DataExtractor &extractor)
Definition: SystemRuntimeMacOSX.cpp:994
lldb::queue_id_t
uint64_t queue_id_t
Definition: lldb-types.h:91
SystemRuntimeMacOSX::PopulatePendingItemsForQueue
void PopulatePendingItemsForQueue(lldb_private::Queue *queue) override
Get the pending work items for a libdispatch Queue.
Definition: SystemRuntimeMacOSX.cpp:867
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::AppleGetThreadItemInfoHandler::GetThreadItemInfoReturnInfo::item_buffer_ptr
lldb::addr_t item_buffer_ptr
Definition: AppleGetThreadItemInfoHandler.h:50
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
SystemRuntimeMacOSX::ItemInfo::target_queue_serialnum
uint64_t target_queue_serialnum
Definition: SystemRuntimeMacOSX.h:124
lldb_private::Target::ReadUnsignedIntegerFromMemory
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory=false)
Definition: Target.cpp:2070
SystemRuntimeMacOSX::ItemInfo::enqueuing_queue_label
std::string enqueuing_queue_label
Definition: SystemRuntimeMacOSX.h:129
lldb_private::QueueItem::SetEnqueueingThreadID
void SetEnqueueingThreadID(lldb::tid_t tid)
Definition: QueueItem.h:100
lldb_private::QueueItem::SetThreadLabel
void SetThreadLabel(std::string thread_name)
Definition: QueueItem.h:122
SystemRuntimeMacOSX::m_mutex
std::recursive_mutex m_mutex
Definition: SystemRuntimeMacOSX.h:105
lldb_private::AppleGetItemInfoHandler::Detach
void Detach()
Definition: AppleGetItemInfoHandler.cpp:104
SystemRuntimeMacOSX::PendingItemsForQueue
Definition: SystemRuntimeMacOSX.h:239
lldb_private::Process::Threads
ThreadList::ThreadIterable Threads()
Definition: Process.h:2103
SystemRuntimeMacOSX::libBacktraceRecording_info::item_info_data_offset
uint16_t item_info_data_offset
Definition: SystemRuntimeMacOSX.h:112
lldb_private::DataExtractor
Definition: DataExtractor.h:48
SystemRuntimeMacOSX::m_page_to_free_size
uint64_t m_page_to_free_size
Definition: SystemRuntimeMacOSX.h:269
Log.h
TypeSystemClang.h
SystemRuntimeMacOSX::ReadLibdispatchOffsetsAddress
void ReadLibdispatchOffsetsAddress()
Definition: SystemRuntimeMacOSX.cpp:266
SystemRuntimeMacOSX::m_break_id
lldb::user_id_t m_break_id
Definition: SystemRuntimeMacOSX.h:104
lldb_private::Runtime::m_process
Process * m_process
Definition: Runtime.h:29
SystemRuntimeMacOSX::LibdispatchTSDIndexes::dti_voucher_index
uint64_t dti_voucher_index
Definition: SystemRuntimeMacOSX.h:207
lldb_private::StructuredData::ObjectSP
std::shared_ptr< Object > ObjectSP
Definition: StructuredData.h:59
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_width_size
uint16_t dqo_width_size
Definition: SystemRuntimeMacOSX.h:149
SystemRuntimeMacOSX::GetPluginNameStatic
static llvm::StringRef GetPluginNameStatic()
Definition: SystemRuntimeMacOSX.h:42
SystemRuntimeMacOSX::PopulateQueuesUsingLibBTR
void PopulateQueuesUsingLibBTR(lldb::addr_t queues_buffer, uint64_t queues_buffer_size, uint64_t count, lldb_private::QueueList &queue_list)
Definition: SystemRuntimeMacOSX.cpp:920
StreamString.h
lldb_private::QueueItem::SetItemThatEnqueuedThis
void SetItemThatEnqueuedThis(lldb::addr_t address_of_item)
Definition: QueueItem.h:94
SystemRuntimeMacOSX::LibpthreadOffsets::plo_pthread_tsd_base_address_offset
uint16_t plo_pthread_tsd_base_address_offset
Definition: SystemRuntimeMacOSX.h:218
SystemRuntimeMacOSX::ReadLibdispatchOffsets
void ReadLibdispatchOffsets()
Definition: SystemRuntimeMacOSX.cpp:298
lldb_private::Process::GetAddressByteSize
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3367
lldb::eEncodingUint
@ eEncodingUint
unsigned integer
Definition: lldb-enumerations.h:149
lldb_private::ConstString
Definition: ConstString.h:39
lldb::eQueueKindUnknown
@ eQueueKindUnknown
Definition: lldb-enumerations.h:969
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::SymbolContext::GetFunctionName
ConstString GetFunctionName(Mangled::NamePreference preference=Mangled::ePreferDemangled) const
Find a name of the innermost function for the symbol context.
Definition: SymbolContext.cpp:650
SystemRuntimeMacOSX::m_libpthread_offsets
struct LibpthreadOffsets m_libpthread_offsets
Definition: SystemRuntimeMacOSX.h:276
lldb_private::ModuleList::FindFirstModule
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Definition: ModuleList.cpp:623
SystemRuntimeMacOSX::LibdispatchOffsets
Definition: SystemRuntimeMacOSX.h:140
lldb_private::AppleGetItemInfoHandler::GetItemInfoReturnInfo::item_buffer_size
lldb::addr_t item_buffer_size
Definition: AppleGetItemInfoHandler.h:51
lldb_private::AppleGetThreadItemInfoHandler::GetThreadItemInfo
GetThreadItemInfoReturnInfo GetThreadItemInfo(Thread &thread, lldb::tid_t thread_id, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the information about a work item by calling __introspection_dispatch_thread_get_item_info.
Definition: AppleGetThreadItemInfoHandler.cpp:218
lldb_private::AppleGetThreadItemInfoHandler::Detach
void Detach()
Definition: AppleGetThreadItemInfoHandler.cpp:113
lldb_private::AppleGetQueuesHandler::Detach
void Detach()
Definition: AppleGetQueuesHandler.cpp:105
SystemRuntimeMacOSX::CompleteQueueItem
void CompleteQueueItem(lldb_private::QueueItem *queue_item, lldb::addr_t item_ref) override
Complete the fields in a QueueItem.
Definition: SystemRuntimeMacOSX.cpp:884
SystemRuntimeMacOSX::LibpthreadOffsets::plo_version
uint16_t plo_version
Definition: SystemRuntimeMacOSX.h:216
SystemRuntimeMacOSX::m_get_item_info_handler
lldb_private::AppleGetItemInfoHandler m_get_item_info_handler
Definition: SystemRuntimeMacOSX.h:265
SystemRuntimeMacOSX::~SystemRuntimeMacOSX
~SystemRuntimeMacOSX() override
Definition: SystemRuntimeMacOSX.cpp:95
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::AppleGetPendingItemsHandler::Detach
void Detach()
Definition: AppleGetPendingItemsHandler.cpp:108
LLDB_INVALID_QUEUE_ID
#define LLDB_INVALID_QUEUE_ID
Definition: lldb-defines.h:88
lldb_private::AppleGetPendingItemsHandler::GetPendingItemsReturnInfo::items_buffer_size
lldb::addr_t items_buffer_size
Definition: AppleGetPendingItemsHandler.h:54
Thread.h
Queue.h
lldb_private::AppleGetQueuesHandler::GetQueuesReturnInfo::queues_buffer_ptr
lldb::addr_t queues_buffer_ptr
Definition: AppleGetQueuesHandler.h:48
ObjectFile.h
lldb_private::AppleGetPendingItemsHandler::GetPendingItemsReturnInfo
Definition: AppleGetPendingItemsHandler.h:50
SystemRuntimeMacOSX::Detach
void Detach() override
Called before detaching from a process.
Definition: SystemRuntimeMacOSX.cpp:97
SystemRuntimeMacOSX::ItemRefAndCodeAddress::item_ref
lldb::addr_t item_ref
Definition: SystemRuntimeMacOSX.h:235
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_serialnum_size
uint16_t dqo_serialnum_size
Definition: SystemRuntimeMacOSX.h:147
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
SystemRuntimeMacOSX::libBacktraceRecording_info::queue_info_data_offset
uint16_t queue_info_data_offset
Definition: SystemRuntimeMacOSX.h:110
SystemRuntimeMacOSX::ItemRefAndCodeAddress::code_address
lldb::addr_t code_address
Definition: SystemRuntimeMacOSX.h:236
lldb::eAccessPublic
@ eAccessPublic
Definition: lldb-enumerations.h:516
lldb_private::QueueList::FindQueueByID
lldb::QueueSP FindQueueByID(lldb::queue_id_t qid)
Find a queue in the QueueList by QueueID.
Definition: QueueList.cpp:47
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_width
uint16_t dqo_width
Definition: SystemRuntimeMacOSX.h:148
SystemRuntimeMacOSX::ReadLibdispatchTSDIndexes
void ReadLibdispatchTSDIndexes()
Definition: SystemRuntimeMacOSX.cpp:392
SystemRuntimeMacOSX::ItemInfo::enqueuing_callstack
std::vector< lldb::addr_t > enqueuing_callstack
Definition: SystemRuntimeMacOSX.h:127
ProcessStructReader.h
lldb_private::StructuredData::Object::GetAsArray
Array * GetAsArray()
Definition: StructuredData.h:85
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
SystemRuntimeMacOSX::LibdispatchTSDIndexes::dti_queue_index
uint64_t dti_queue_index
Definition: SystemRuntimeMacOSX.h:206
SystemRuntimeMacOSX::m_page_to_free
lldb::addr_t m_page_to_free
Definition: SystemRuntimeMacOSX.h:268
lldb_private::AppleGetItemInfoHandler::GetItemInfo
GetItemInfoReturnInfo GetItemInfo(Thread &thread, lldb::addr_t item, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the information about a work item by calling __introspection_dispatch_queue_item_get_info.
Definition: AppleGetItemInfoHandler.cpp:217
lldb_private::Queue
Definition: Queue.h:32
SystemRuntimeMacOSX::Terminate
static void Terminate()
Definition: SystemRuntimeMacOSX.cpp:1026
lldb_private::Status
Definition: Status.h:44
SystemRuntimeMacOSX::PopulateQueueList
void PopulateQueueList(lldb_private::QueueList &queue_list) override
Populate the Process' QueueList with libdispatch / GCD queues that exist.
Definition: SystemRuntimeMacOSX.cpp:724
lldb_private::OptionalClangModuleID
A Clang module ID.
Definition: TypeSystemClang.h:57
SystemRuntimeMacOSX::CreateInstance
static lldb_private::SystemRuntime * CreateInstance(lldb_private::Process *process)
Definition: SystemRuntimeMacOSX.cpp:43
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_version
uint16_t dqo_version
Definition: SystemRuntimeMacOSX.h:141
uint32_t
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
SystemRuntimeMacOSX::SafeToCallFunctionsOnThisThread
bool SafeToCallFunctionsOnThisThread(lldb::ThreadSP thread_sp) override
Determine whether it is safe to run an expression on a given thread.
Definition: SystemRuntimeMacOSX.cpp:222
lldb_private::AppleGetQueuesHandler::GetQueuesReturnInfo::queues_buffer_size
lldb::addr_t queues_buffer_size
Definition: AppleGetQueuesHandler.h:51
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_serialnum
uint16_t dqo_serialnum
Definition: SystemRuntimeMacOSX.h:146
lldb_private::Address
Definition: Address.h:59
lldb_private::AppleGetItemInfoHandler::GetItemInfoReturnInfo::item_buffer_ptr
lldb::addr_t item_buffer_ptr
Definition: AppleGetItemInfoHandler.h:49
lldb_private::ObjectFile::GetStrata
Strata GetStrata()
Definition: ObjectFile.h:643
lldb_private::StructuredData::Object::GetAsDictionary
Dictionary * GetAsDictionary()
Definition: StructuredData.h:91
SystemRuntimeMacOSX::LibpthreadOffsets::plo_pthread_tsd_base_offset
uint16_t plo_pthread_tsd_base_offset
Definition: SystemRuntimeMacOSX.h:217
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
SystemRuntimeMacOSX::GetExtendedBacktraceForQueueItem
lldb::ThreadSP GetExtendedBacktraceForQueueItem(lldb::QueueItemSP queue_item_sp, lldb_private::ConstString type) override
Get the extended backtrace thread for a QueueItem.
Definition: SystemRuntimeMacOSX.cpp:588
SystemRuntimeMacOSX::GetQueueKind
lldb::QueueKind GetQueueKind(lldb::addr_t dispatch_queue_addr) override
Retrieve the Queue kind for the queue at a thread's dispatch_qaddr.
Definition: SystemRuntimeMacOSX.cpp:171
SystemRuntimeMacOSX::m_get_queues_handler
lldb_private::AppleGetQueuesHandler m_get_queues_handler
Definition: SystemRuntimeMacOSX.h:263
uint16_t
lldb_private::SystemRuntime::m_types
std::vector< ConstString > m_types
Definition: SystemRuntime.h:298
lldb_private::DataExtractor::GetU32
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:425
PluginManager.h
lldb_private::AppleGetItemInfoHandler::GetItemInfoReturnInfo
Definition: AppleGetItemInfoHandler.h:48
SystemRuntimeMacOSX::libBacktraceRecording_info::item_info_version
uint16_t item_info_version
Definition: SystemRuntimeMacOSX.h:111
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
SystemRuntimeMacOSX::libBacktraceRecording_info::queue_info_version
uint16_t queue_info_version
Definition: SystemRuntimeMacOSX.h:109
SystemRuntimeMacOSX::ItemInfo
Definition: SystemRuntimeMacOSX.h:119
DataExtractor.h
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:36
lldb_private::SymbolContextList::IsEmpty
bool IsEmpty() const
Definition: SymbolContext.cpp:1276
lldb_private::AppleGetQueuesHandler::GetQueuesReturnInfo
Definition: AppleGetQueuesHandler.h:47
SymbolContext.h
SystemRuntimeMacOSX::m_libdispatch_tsd_indexes
struct LibdispatchTSDIndexes m_libdispatch_tsd_indexes
Definition: SystemRuntimeMacOSX.h:279
lldb::eQueueKindConcurrent
@ eQueueKindConcurrent
Definition: lldb-enumerations.h:971
lldb_private::AppleGetPendingItemsHandler::GetPendingItemsReturnInfo::items_buffer_ptr
lldb::addr_t items_buffer_ptr
Definition: AppleGetPendingItemsHandler.h:51
SystemRuntimeMacOSX::ItemInfo::target_queue_label
std::string target_queue_label
Definition: SystemRuntimeMacOSX.h:130
lldb::eLanguageTypeC
@ eLanguageTypeC
Non-standardized C, such as K&R.
Definition: lldb-enumerations.h:446
lldb_private::QueueItem::SetStopID
void SetStopID(uint32_t stop_id)
Definition: QueueItem.h:112
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
SystemRuntimeMacOSX::LibdispatchOffsets::dqo_label_size
uint16_t dqo_label_size
Definition: SystemRuntimeMacOSX.h:143
lldb_private::DataExtractor::GetCStr
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
Definition: DataExtractor.cpp:784
SystemRuntimeMacOSX::PendingItemsForQueue::item_refs_and_code_addresses
std::vector< ItemRefAndCodeAddress > item_refs_and_code_addresses
Definition: SystemRuntimeMacOSX.h:242
lldb_private::StructuredData::Dictionary::AddIntegerItem
void AddIntegerItem(llvm::StringRef key, uint64_t value)
Definition: StructuredData.h:525
FileSpec.h
SystemRuntimeMacOSX::ItemInfo::function_or_block
lldb::addr_t function_or_block
Definition: SystemRuntimeMacOSX.h:121
SystemRuntimeMacOSX::GetPendingItemRefsForQueue
PendingItemsForQueue GetPendingItemRefsForQueue(lldb::addr_t queue)
Definition: SystemRuntimeMacOSX.cpp:790
lldb_private::QueueItem
Definition: QueueItem.h:32
SystemRuntimeMacOSX::GetQueueIDFromThreadQAddress
lldb::queue_id_t GetQueueIDFromThreadQAddress(lldb::addr_t dispatch_qaddr) override
Get the QueueID for the libdispatch queue given the thread's dispatch_qaddr.
Definition: SystemRuntimeMacOSX.cpp:237
lldb_private::ProcessStructReader::GetField
RetType GetField(ConstString name, RetType fail_value=RetType())
Definition: ProcessStructReader.h:83
lldb_private::QueueList
Definition: QueueList.h:28
SystemRuntimeMacOSX::GetExtendedBacktraceFromItemRef
lldb::ThreadSP GetExtendedBacktraceFromItemRef(lldb::addr_t item_ref)
Definition: SystemRuntimeMacOSX.cpp:550
lldb_private::Process::ReadUnsignedIntegerFromMemory
uint64_t ReadUnsignedIntegerFromMemory(lldb::addr_t load_addr, size_t byte_size, uint64_t fail_value, Status &error)
Reads an unsigned integer of the specified byte size from process memory.
Definition: Process.cpp:2067
lldb_private::Process::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Definition: Process.cpp:3363
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::Log
Definition: Log.h:115
lldb_private::Queue::GetLibdispatchQueueAddress
lldb::addr_t GetLibdispatchQueueAddress() const
Get the dispatch_queue_t structure address for this Queue.
Definition: Queue.cpp:73
lldb_private::Process::ReadPointerFromMemory
lldb::addr_t ReadPointerFromMemory(lldb::addr_t vm_addr, Status &error)
Definition: Process.cpp:2089
SystemRuntimeMacOSX.h
SystemRuntimeMacOSX::ReadLibdispatchTSDIndexesAddress
void ReadLibdispatchTSDIndexesAddress()
Definition: SystemRuntimeMacOSX.cpp:370
lldb_private::StructuredData::Array::GetSize
size_t GetSize() const
Definition: StructuredData.h:186
lldb_private::Symbol::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Definition: Symbol.cpp:493
SystemRuntimeMacOSX::LibpthreadOffsets
Definition: SystemRuntimeMacOSX.h:215
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
SystemRuntimeMacOSX::ItemInfo::stop_id
uint32_t stop_id
Definition: SystemRuntimeMacOSX.h:126
lldb_private::DataBufferHeap
Definition: DataBufferHeap.h:30
SystemRuntimeMacOSX::m_lib_backtrace_recording_info
libBacktraceRecording_info m_lib_backtrace_recording_info
Definition: SystemRuntimeMacOSX.h:270
lldb_private::AppleGetQueuesHandler::GetQueuesReturnInfo::count
uint64_t count
Definition: AppleGetQueuesHandler.h:53
lldb_private::StructuredData::Object
Definition: StructuredData.h:70
SystemRuntimeMacOSX::ItemInfo::enqueuing_thread_label
std::string enqueuing_thread_label
Definition: SystemRuntimeMacOSX.h:128
lldb
Definition: SBAddress.h:15
lldb_private::ThreadList::GetExpressionExecutionThread
lldb::ThreadSP GetExpressionExecutionThread()
Definition: ThreadList.cpp:60
SystemRuntimeMacOSX::AddThreadExtendedInfoPacketHints
void AddThreadExtendedInfoPacketHints(lldb_private::StructuredData::ObjectSP dict) override
Add key-value pairs to the StructuredData dictionary object with information debugserver may need whe...
Definition: SystemRuntimeMacOSX.cpp:195
QueueList.h
lldb::QueueKind
QueueKind
Queue type.
Definition: lldb-enumerations.h:968
lldb_private::QueueItem::SetQueueLabel
void SetQueueLabel(std::string queue_name)
Definition: QueueItem.h:126
LLDBLog.h
lldb_private::StructuredData::Array::ForEach
bool ForEach(std::function< bool(Object *object)> const &foreach_callback) const
Definition: StructuredData.h:178
SystemRuntimeMacOSX::ReadLibpthreadOffsetsAddress
void ReadLibpthreadOffsetsAddress()
Definition: SystemRuntimeMacOSX.cpp:322
lldb_private::ObjectFile
Definition: ObjectFile.h:60
SystemRuntimeMacOSX::GetLibdispatchQueueAddressFromThreadQAddress
lldb::addr_t GetLibdispatchQueueAddressFromThreadQAddress(lldb::addr_t dispatch_qaddr) override
Get the libdispatch_queue_t address for the queue given the thread's dispatch_qaddr.
Definition: SystemRuntimeMacOSX.cpp:159
lldb_private::AppleGetPendingItemsHandler::GetPendingItems
GetPendingItemsReturnInfo GetPendingItems(Thread &thread, lldb::addr_t queue, lldb::addr_t page_to_free, uint64_t page_to_free_size, lldb_private::Status &error)
Get the list of pending items for a given queue via a call to __introspection_dispatch_queue_get_pend...
Definition: AppleGetPendingItemsHandler.cpp:212
DataBufferHeap.h
SystemRuntimeMacOSX::LibpthreadOffsets::plo_pthread_tsd_entry_size
uint16_t plo_pthread_tsd_entry_size
Definition: SystemRuntimeMacOSX.h:219
SystemRuntimeMacOSX::m_libpthread_layout_offsets_addr
lldb::addr_t m_libpthread_layout_offsets_addr
Definition: SystemRuntimeMacOSX.h:275