LLDB  mainline
DynamicLoaderMacOS.cpp
Go to the documentation of this file.
1 //===-- DynamicLoaderMacOS.cpp -----------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "lldb/Core/Debugger.h"
11 #include "lldb/Core/Module.h"
13 #include "lldb/Core/Section.h"
15 #include "lldb/Symbol/ObjectFile.h"
17 #include "lldb/Target/ABI.h"
18 #include "lldb/Target/StackFrame.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Target/Thread.h"
21 #include "lldb/Utility/Log.h"
22 #include "lldb/Utility/State.h"
23 
24 #include "DynamicLoaderDarwin.h"
25 #include "DynamicLoaderMacOS.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 // Create an instance of this class. This function is filled into the plugin
31 // info class that gets handed out by the plugin factory and allows the lldb to
32 // instantiate an instance of this class.
34  bool force) {
35  bool create = force;
36  if (!create) {
37  create = true;
38  Module *exe_module = process->GetTarget().GetExecutableModulePointer();
39  if (exe_module) {
40  ObjectFile *object_file = exe_module->GetObjectFile();
41  if (object_file) {
42  create = (object_file->GetStrata() == ObjectFile::eStrataUser);
43  }
44  }
45 
46  if (create) {
47  const llvm::Triple &triple_ref =
48  process->GetTarget().GetArchitecture().GetTriple();
49  switch (triple_ref.getOS()) {
50  case llvm::Triple::Darwin:
51  case llvm::Triple::MacOSX:
52  case llvm::Triple::IOS:
53  case llvm::Triple::TvOS:
54  case llvm::Triple::WatchOS:
55  // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
56  create = triple_ref.getVendor() == llvm::Triple::Apple;
57  break;
58  default:
59  create = false;
60  break;
61  }
62  }
63  }
64 
65  if (!UseDYLDSPI(process)) {
66  create = false;
67  }
68 
69  if (create)
70  return new DynamicLoaderMacOS(process);
71  return NULL;
72 }
73 
74 // Constructor
76  : DynamicLoaderDarwin(process), m_image_infos_stop_id(UINT32_MAX),
77  m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
78  m_maybe_image_infos_address(LLDB_INVALID_ADDRESS) {}
79 
80 // Destructor
84 }
85 
87  std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
88  bool did_exec = false;
89  if (m_process) {
90  // If we are stopped after an exec, we will have only one thread...
91  if (m_process->GetThreadList().GetSize() == 1) {
92  // Maybe we still have an image infos address around? If so see
93  // if that has changed, and if so we have exec'ed.
95  lldb::addr_t image_infos_address = m_process->GetImageInfoAddress();
96  if (image_infos_address != m_maybe_image_infos_address) {
97  // We don't really have to reset this here, since we are going to
98  // call DoInitialImageFetch right away to handle the exec. But in
99  // case anybody looks at it in the meantime, it can't hurt.
100  m_maybe_image_infos_address = image_infos_address;
101  did_exec = true;
102  }
103  }
104 
105  if (!did_exec) {
106  // See if we are stopped at '_dyld_start'
107  ThreadSP thread_sp(m_process->GetThreadList().GetThreadAtIndex(0));
108  if (thread_sp) {
109  lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
110  if (frame_sp) {
111  const Symbol *symbol =
112  frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
113  if (symbol) {
114  if (symbol->GetName() == "_dyld_start")
115  did_exec = true;
116  }
117  }
118  }
119  }
120  }
121  }
122 
123  if (did_exec) {
124  m_libpthread_module_wp.reset();
126  }
127  return did_exec;
128 }
129 
130 // Clear out the state of this class.
132  std::lock_guard<std::recursive_mutex> guard(m_mutex);
133 
136 
138 }
139 
140 // Check if we have found DYLD yet
143 }
144 
149  }
150 }
151 
152 // Try and figure out where dyld is by first asking the Process if it knows
153 // (which currently calls down in the lldb::Process to get the DYLD info
154 // (available on SnowLeopard only). If that fails, then check in the default
155 // addresses.
158 
159  // Remove any binaries we pre-loaded in the Target before
160  // launching/attaching. If the same binaries are present in the process,
161  // we'll get them from the shared module cache, we won't need to re-load them
162  // from disk.
163  UnloadAllImages();
164 
165  StructuredData::ObjectSP all_image_info_json_sp(
167  ImageInfo::collection image_infos;
168  if (all_image_info_json_sp.get() &&
169  all_image_info_json_sp->GetAsDictionary() &&
170  all_image_info_json_sp->GetAsDictionary()->HasKey("images") &&
171  all_image_info_json_sp->GetAsDictionary()
172  ->GetValueForKey("images")
173  ->GetAsArray()) {
174  if (JSONImageInformationIntoImageInfo(all_image_info_json_sp,
175  image_infos)) {
176  if (log)
177  log->Printf("Initial module fetch: Adding %" PRId64 " modules.\n",
178  (uint64_t)image_infos.size());
179 
181  AddModulesUsingImageInfos(image_infos);
182  }
183  }
184 
187 }
188 
190 
191 // Static callback function that gets called when our DYLD notification
192 // breakpoint gets hit. We update all of our image infos and then let our super
193 // class DynamicLoader class decide if we should stop or not (based on global
194 // preference).
196  StoppointCallbackContext *context,
197  lldb::user_id_t break_id,
198  lldb::user_id_t break_loc_id) {
199  // Let the event know that the images have changed
200  // DYLD passes three arguments to the notification breakpoint.
201  // Arg1: enum dyld_notify_mode mode - 0 = adding, 1 = removing, 2 = remove
202  // all Arg2: unsigned long icount - Number of shared libraries
203  // added/removed Arg3: uint64_t mach_headers[] - Array of load addresses
204  // of binaries added/removed
205 
206  DynamicLoaderMacOS *dyld_instance = (DynamicLoaderMacOS *)baton;
207 
208  ExecutionContext exe_ctx(context->exe_ctx_ref);
209  Process *process = exe_ctx.GetProcessPtr();
210 
211  // This is a sanity check just in case this dyld_instance is an old dyld
212  // plugin's breakpoint still lying around.
213  if (process != dyld_instance->m_process)
214  return false;
215 
216  if (dyld_instance->m_image_infos_stop_id != UINT32_MAX &&
217  process->GetStopID() < dyld_instance->m_image_infos_stop_id) {
218  return false;
219  }
220 
221  const lldb::ABISP &abi = process->GetABI();
222  if (abi) {
223  // Build up the value array to store the three arguments given above, then
224  // get the values from the ABI:
225 
226  ClangASTContext *clang_ast_context =
228  ValueList argument_values;
229 
230  Value mode_value; // enum dyld_notify_mode { dyld_notify_adding=0,
231  // dyld_notify_removing=1, dyld_notify_remove_all=2 };
232  Value count_value; // unsigned long count
233  Value headers_value; // uint64_t machHeaders[] (aka void*)
234 
235  CompilerType clang_void_ptr_type =
236  clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
237  CompilerType clang_uint32_type =
238  clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
239  lldb::eEncodingUint, 32);
240  CompilerType clang_uint64_type =
241  clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
242  lldb::eEncodingUint, 32);
243 
244  mode_value.SetValueType(Value::eValueTypeScalar);
245  mode_value.SetCompilerType(clang_uint32_type);
246 
247  if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 4) {
248  count_value.SetValueType(Value::eValueTypeScalar);
249  count_value.SetCompilerType(clang_uint32_type);
250  } else {
251  count_value.SetValueType(Value::eValueTypeScalar);
252  count_value.SetCompilerType(clang_uint64_type);
253  }
254 
255  headers_value.SetValueType(Value::eValueTypeScalar);
256  headers_value.SetCompilerType(clang_void_ptr_type);
257 
258  argument_values.PushValue(mode_value);
259  argument_values.PushValue(count_value);
260  argument_values.PushValue(headers_value);
261 
262  if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
263  uint32_t dyld_mode =
264  argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
265  if (dyld_mode != static_cast<uint32_t>(-1)) {
266  // Okay the mode was right, now get the number of elements, and the
267  // array of new elements...
268  uint32_t image_infos_count =
269  argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
270  if (image_infos_count != static_cast<uint32_t>(-1)) {
271  addr_t header_array =
272  argument_values.GetValueAtIndex(2)->GetScalar().ULongLong(-1);
273  if (header_array != static_cast<uint64_t>(-1)) {
274  std::vector<addr_t> image_load_addresses;
275  for (uint64_t i = 0; i < image_infos_count; i++) {
276  Status error;
277  addr_t addr = process->ReadUnsignedIntegerFromMemory(
278  header_array + (8 * i), 8, LLDB_INVALID_ADDRESS, error);
279  if (addr != LLDB_INVALID_ADDRESS) {
280  image_load_addresses.push_back(addr);
281  }
282  }
283  if (dyld_mode == 0) {
284  // dyld_notify_adding
285  dyld_instance->AddBinaries(image_load_addresses);
286  } else if (dyld_mode == 1) {
287  // dyld_notify_removing
288  dyld_instance->UnloadImages(image_load_addresses);
289  } else if (dyld_mode == 2) {
290  // dyld_notify_remove_all
291  dyld_instance->UnloadAllImages();
292  }
293  }
294  }
295  }
296  }
297  } else {
298  process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
299  "No ABI plugin located for triple %s -- shared libraries will not be "
300  "registered!\n",
301  process->GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
302  }
303 
304  // Return true to stop the target, false to just let the target run
305  return dyld_instance->GetStopWhenImagesChange();
306 }
307 
309  const std::vector<lldb::addr_t> &load_addresses) {
311  ImageInfo::collection image_infos;
312 
313  if (log)
314  log->Printf("Adding %" PRId64 " modules.", (uint64_t)load_addresses.size());
315  StructuredData::ObjectSP binaries_info_sp =
316  m_process->GetLoadedDynamicLibrariesInfos(load_addresses);
317  if (binaries_info_sp.get() && binaries_info_sp->GetAsDictionary() &&
318  binaries_info_sp->GetAsDictionary()->HasKey("images") &&
319  binaries_info_sp->GetAsDictionary()
320  ->GetValueForKey("images")
321  ->GetAsArray() &&
322  binaries_info_sp->GetAsDictionary()
323  ->GetValueForKey("images")
324  ->GetAsArray()
325  ->GetSize() == load_addresses.size()) {
326  if (JSONImageInformationIntoImageInfo(binaries_info_sp, image_infos)) {
328  AddModulesUsingImageInfos(image_infos);
329  }
331  }
332 }
333 
334 // Dump the _dyld_all_image_infos members and all current image infos that we
335 // have parsed to the file handle provided.
337  if (log == NULL)
338  return;
339 }
340 
343  ConstString g_symbol_name("_dyld_debugger_notification");
344  const Symbol *symbol = nullptr;
345  ModuleSP dyld_sp(GetDYLDModule());
346  if (dyld_sp) {
347  symbol = dyld_sp->FindFirstSymbolWithNameAndType(g_symbol_name,
349  }
350  if (symbol &&
351  (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
352  addr_t symbol_address =
354  if (symbol_address != LLDB_INVALID_ADDRESS) {
355  bool internal = true;
356  bool hardware = false;
357  Breakpoint *breakpoint =
359  .CreateBreakpoint(symbol_address, internal, hardware)
360  .get();
362  true);
363  breakpoint->SetBreakpointKind("shared-library-event");
364  m_break_id = breakpoint->GetID();
365  }
366  }
367  }
369 }
370 
371 addr_t
373  SymbolContext sc;
374  SymbolVendor *sym_vendor = module->GetSymbolVendor();
375  Target &target = m_process->GetTarget();
376  if (sym_vendor) {
377  Symtab *symtab = sym_vendor->GetSymtab();
378  if (symtab) {
379  std::vector<uint32_t> match_indexes;
380  ConstString g_symbol_name("_dyld_global_lock_held");
381  uint32_t num_matches = 0;
382  num_matches =
383  symtab->AppendSymbolIndexesWithName(g_symbol_name, match_indexes);
384  if (num_matches == 1) {
385  Symbol *symbol = symtab->SymbolAtIndex(match_indexes[0]);
386  if (symbol &&
387  (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
388  return symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
389  }
390  }
391  }
392  }
393  return LLDB_INVALID_ADDRESS;
394 }
395 
396 // Look for this symbol:
397 //
398 // int __attribute__((visibility("hidden"))) _dyld_global_lock_held =
399 // 0;
400 //
401 // in libdyld.dylib.
403  Status error;
404  addr_t symbol_address = LLDB_INVALID_ADDRESS;
405  Target &target = m_process->GetTarget();
406  const ModuleList &target_modules = target.GetImages();
407  std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
408  const size_t num_modules = target_modules.GetSize();
409  ConstString g_libdyld_name("libdyld.dylib");
410 
411  // Find any modules named "libdyld.dylib" and look for the symbol there first
412  for (size_t i = 0; i < num_modules; i++) {
413  Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i);
414  if (module_pointer) {
415  if (module_pointer->GetFileSpec().GetFilename() == g_libdyld_name) {
416  symbol_address = GetDyldLockVariableAddressFromModule(module_pointer);
417  if (symbol_address != LLDB_INVALID_ADDRESS)
418  break;
419  }
420  }
421  }
422 
423  // Search through all modules looking for the symbol in them
424  if (symbol_address == LLDB_INVALID_ADDRESS) {
425  for (size_t i = 0; i < num_modules; i++) {
426  Module *module_pointer =
427  target_modules.GetModulePointerAtIndexUnlocked(i);
428  if (module_pointer) {
429  addr_t symbol_address =
430  GetDyldLockVariableAddressFromModule(module_pointer);
431  if (symbol_address != LLDB_INVALID_ADDRESS)
432  break;
433  }
434  }
435  }
436 
437  // Default assumption is that it is OK to load images. Only say that we
438  // cannot load images if we find the symbol in libdyld and it indicates that
439  // we cannot.
440 
441  if (symbol_address != LLDB_INVALID_ADDRESS) {
442  {
443  int lock_held =
444  m_process->ReadUnsignedIntegerFromMemory(symbol_address, 4, 0, error);
445  if (lock_held != 0) {
446  error.SetErrorString("dyld lock held - unsafe to load images.");
447  }
448  }
449  } else {
450  // If we were unable to find _dyld_global_lock_held in any modules, or it
451  // is not loaded into memory yet, we may be at process startup (sitting at
452  // _dyld_start) - so we should not allow dlopen calls. But if we found more
453  // than one module then we are clearly past _dyld_start so in that case
454  // we'll default to "it's safe".
455  if (num_modules <= 1)
456  error.SetErrorString("could not find the dyld library or "
457  "the dyld lock symbol");
458  }
459  return error;
460 }
461 
463  lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache,
464  LazyBool &private_shared_cache) {
465  base_address = LLDB_INVALID_ADDRESS;
466  uuid.Clear();
467  using_shared_cache = eLazyBoolCalculate;
468  private_shared_cache = eLazyBoolCalculate;
469 
470  if (m_process) {
472  StructuredData::Dictionary *info_dict = nullptr;
473  if (info.get() && info->GetAsDictionary()) {
474  info_dict = info->GetAsDictionary();
475  }
476 
477  // {"shared_cache_base_address":140735683125248,"shared_cache_uuid
478  // ":"DDB8D70C-
479  // C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
480 
481  if (info_dict && info_dict->HasKey("shared_cache_uuid") &&
482  info_dict->HasKey("no_shared_cache") &&
483  info_dict->HasKey("shared_cache_base_address")) {
484  base_address = info_dict->GetValueForKey("shared_cache_base_address")
485  ->GetIntegerValue(LLDB_INVALID_ADDRESS);
486  std::string uuid_str =
487  info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue();
488  if (!uuid_str.empty())
489  uuid.SetFromStringRef(uuid_str);
490  if (!info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue())
491  using_shared_cache = eLazyBoolYes;
492  else
493  using_shared_cache = eLazyBoolNo;
494  if (info_dict->GetValueForKey("shared_cache_private_cache")
495  ->GetBooleanValue())
496  private_shared_cache = eLazyBoolYes;
497  else
498  private_shared_cache = eLazyBoolNo;
499 
500  return true;
501  }
502  }
503  return false;
504 }
505 
507  PluginManager::RegisterPlugin(GetPluginNameStatic(),
509 }
510 
512  PluginManager::UnregisterPlugin(CreateInstance);
513 }
514 
516  static ConstString g_name("macos-dyld");
517  return g_name;
518 }
519 
521  return "Dynamic loader plug-in that watches for shared library loads/unloads "
522  "in MacOSX user processes.";
523 }
524 
525 // PluginInterface protocol
527  return GetPluginNameStatic();
528 }
529 
Address & GetAddressRef()
Definition: Symbol.h:56
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:369
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:940
void AddBinaries(const std::vector< lldb::addr_t > &load_addresses)
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
const ArchSpec & GetArchitecture() const
Definition: Target.h:941
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:531
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:742
bool AddModulesUsingImageInfos(ImageInfo::collection &image_infos)
CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size) override
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:78
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1251
Thread & GetThreadRef() const
Returns a reference to the thread object.
ThreadList & GetThreadList()
Definition: Process.h:2045
bool GetStopWhenImagesChange() const
Get whether the process should stop when images change.
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:58
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:456
Value * GetValueAtIndex(size_t idx)
Definition: Value.cpp:701
void SetValueType(ValueType value_type)
Definition: Value.h:154
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
lldb::StreamSP GetAsyncErrorStream()
Definition: Debugger.cpp:1153
static lldb_private::ConstString GetPluginNameStatic()
DynamicLoaderMacOS(lldb_private::Process *process)
lldb_private::Address m_pthread_getspecific_addr
static lldb_private::DynamicLoader * CreateInstance(lldb_private::Process *process, bool force)
void UpdateSpecialBinariesFromNewImageInfos(ImageInfo::collection &image_infos)
Module * GetExecutableModulePointer()
Definition: Target.cpp:1394
void UnloadImages(const std::vector< lldb::addr_t > &solib_addresses)
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
lldb::addr_t GetDyldLockVariableAddressFromModule(lldb_private::Module *module)
size_t SetFromStringRef(llvm::StringRef str, uint32_t num_uuid_bytes=16)
Definition: UUID.cpp:92
void ClearNotificationBreakpoint() override
bool GetSharedCacheInformation(lldb::addr_t &base_address, lldb_private::UUID &uuid, lldb_private::LazyBool &using_shared_cache, lldb_private::LazyBool &private_shared_cache) override
Get information about the shared cache for a process, if possible.
virtual SymbolVendor * GetSymbolVendor(bool can_create=true, lldb_private::Stream *feedback_strm=nullptr)
Get the symbol vendor interface for the current architecture.
Definition: Module.cpp:1047
static bool NotifyBreakpointHit(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:421
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:90
uint32_t GetPluginVersion() override
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
uint64_t user_id_t
Definition: lldb-types.h:84
Module * GetModulePointerAtIndexUnlocked(size_t idx) const
Get the module pointer for the module at index idx without acquiring the ModuleList mutex...
Definition: ModuleList.cpp:320
uint32_t GetStopID() const
Definition: Process.h:1337
bool DidSetNotificationBreakpoint() override
A collection class for Module objects.
Definition: ModuleList.h:91
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name, std::vector< uint32_t > &matches)
Definition: Symtab.cpp:626
Process * m_process
The process that this dynamic loader plug-in is tracking.
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:109
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
ObjectSP GetValueForKey(llvm::StringRef key) const
bool ProcessDidExec() override
Called after attaching a process.
const lldb::ABISP & GetABI()
Definition: Process.cpp:1541
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:1566
lldb::addr_t GetOpcodeLoadAddress(Target *target, AddressClass addr_class=AddressClass::eInvalid) const
Get the load address as an opcode load address.
Definition: Address.cpp:349
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
void PutToLog(lldb_private::Log *log) const
bool ValueIsAddress() const
Definition: Symbol.cpp:114
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
Process * GetProcessPtr() const
Returns a pointer to the process object.
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:343
bool HasKey(llvm::StringRef key) const
unsigned int UInt(unsigned int fail_value=0) const
Definition: Scalar.cpp:1452
CompilerType GetPointerType() const
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:203
bool NeedToDoInitialImageFetch() override
lldb::user_id_t m_break_id
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:64
ClangASTContext * GetScratchClangASTContext(bool create_on_demand=true)
Definition: Target.cpp:2299
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:899
#define LIBLLDB_LOG_DYNAMIC_LOADER
Definition: Logging.h:17
std::recursive_mutex m_mutex
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1194
uint64_t addr_t
Definition: lldb-types.h:83
void Clear()
Definition: UUID.h:58
size_t GetSize() const
Gets the size of the module list.
Definition: ModuleList.cpp:611
void DoInitialImageFetch() override
A uniqued constant string class.
Definition: ConstString.h:38
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:61
Definition: SBAddress.h:15
ConstString GetName() const
Definition: Symbol.cpp:494
std::shared_ptr< Object > ObjectSP
lldb_private::Status CanLoadImage() override
Ask if it is ok to try and load or unload an shared library (image).
lldb_private::ConstString GetPluginName() override
virtual lldb_private::StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address, lldb::addr_t image_count)
Retrieve the list of shared libraries that are loaded for this process This method is used on pre-mac...
Definition: Process.h:1270
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:49
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:82
void SetCompilerType(const CompilerType &compiler_type)
Definition: Value.cpp:268
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
const Scalar & GetScalar() const
Definition: Value.h:178
std::recursive_mutex & GetMutex() const
Definition: ModuleList.h:214
bool JSONImageInformationIntoImageInfo(lldb_private::StructuredData::ObjectSP image_details, ImageInfo::collection &image_infos)
virtual lldb::addr_t GetImageInfoAddress()
Get the image information address for the current process.
Definition: Process.cpp:1539
static const char * GetPluginDescriptionStatic()
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:2150
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:51
std::recursive_mutex & GetMutex() const
bool SetNotificationBreakpoint() override
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
CompilerType GetBasicType(lldb::BasicType type)
virtual lldb_private::StructuredData::ObjectSP GetSharedCacheInfo()
Definition: Process.h:1295
lldb::addr_t m_maybe_image_infos_address
virtual Symtab * GetSymtab()
Debugger & GetDebugger()
Definition: Target.h:974
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:325
An error handling class.
Definition: Status.h:44
void Clear()
Clear the object&#39;s state.
Definition: Address.h:189
void PushValue(const Value &value)
Definition: Value.cpp:697