LLDB  mainline
DynamicLoaderMacOS.cpp
Go to the documentation of this file.
1 //===-- DynamicLoaderMacOS.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 
10 #include "lldb/Core/Debugger.h"
11 #include "lldb/Core/Module.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Symbol/ObjectFile.h"
16 #include "lldb/Target/ABI.h"
17 #include "lldb/Target/StackFrame.h"
18 #include "lldb/Target/Target.h"
19 #include "lldb/Target/Thread.h"
20 #include "lldb/Utility/Log.h"
21 #include "lldb/Utility/State.h"
22 
23 #include "DynamicLoaderDarwin.h"
24 #include "DynamicLoaderMacOS.h"
25 
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 // Create an instance of this class. This function is filled into the plugin
32 // info class that gets handed out by the plugin factory and allows the lldb to
33 // instantiate an instance of this class.
35  bool force) {
36  bool create = force;
37  if (!create) {
38  create = true;
39  Module *exe_module = process->GetTarget().GetExecutableModulePointer();
40  if (exe_module) {
41  ObjectFile *object_file = exe_module->GetObjectFile();
42  if (object_file) {
43  create = (object_file->GetStrata() == ObjectFile::eStrataUser);
44  }
45  }
46 
47  if (create) {
48  const llvm::Triple &triple_ref =
49  process->GetTarget().GetArchitecture().GetTriple();
50  switch (triple_ref.getOS()) {
51  case llvm::Triple::Darwin:
52  case llvm::Triple::MacOSX:
53  case llvm::Triple::IOS:
54  case llvm::Triple::TvOS:
55  case llvm::Triple::WatchOS:
56  // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
57  create = triple_ref.getVendor() == llvm::Triple::Apple;
58  break;
59  default:
60  create = false;
61  break;
62  }
63  }
64  }
65 
66  if (!UseDYLDSPI(process)) {
67  create = false;
68  }
69 
70  if (create)
71  return new DynamicLoaderMacOS(process);
72  return nullptr;
73 }
74 
75 // Constructor
77  : DynamicLoaderDarwin(process), m_image_infos_stop_id(UINT32_MAX),
78  m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
79  m_maybe_image_infos_address(LLDB_INVALID_ADDRESS) {}
80 
81 // Destructor
85 }
86 
88  std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
89  bool did_exec = false;
90  if (m_process) {
91  // If we are stopped after an exec, we will have only one thread...
92  if (m_process->GetThreadList().GetSize() == 1) {
93  // Maybe we still have an image infos address around? If so see
94  // if that has changed, and if so we have exec'ed.
96  lldb::addr_t image_infos_address = m_process->GetImageInfoAddress();
97  if (image_infos_address != m_maybe_image_infos_address) {
98  // We don't really have to reset this here, since we are going to
99  // call DoInitialImageFetch right away to handle the exec. But in
100  // case anybody looks at it in the meantime, it can't hurt.
101  m_maybe_image_infos_address = image_infos_address;
102  did_exec = true;
103  }
104  }
105 
106  if (!did_exec) {
107  // See if we are stopped at '_dyld_start'
108  ThreadSP thread_sp(m_process->GetThreadList().GetThreadAtIndex(0));
109  if (thread_sp) {
110  lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
111  if (frame_sp) {
112  const Symbol *symbol =
113  frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
114  if (symbol) {
115  if (symbol->GetName() == "_dyld_start")
116  did_exec = true;
117  }
118  }
119  }
120  }
121  }
122  }
123 
124  if (did_exec) {
125  m_libpthread_module_wp.reset();
127  }
128  return did_exec;
129 }
130 
131 // Clear out the state of this class.
133  std::lock_guard<std::recursive_mutex> guard(m_mutex);
134 
137 
139 }
140 
141 // Check if we have found DYLD yet
144 }
145 
150  }
151 }
152 
153 // Try and figure out where dyld is by first asking the Process if it knows
154 // (which currently calls down in the lldb::Process to get the DYLD info
155 // (available on SnowLeopard only). If that fails, then check in the default
156 // addresses.
159 
160  // Remove any binaries we pre-loaded in the Target before
161  // launching/attaching. If the same binaries are present in the process,
162  // we'll get them from the shared module cache, we won't need to re-load them
163  // from disk.
164  UnloadAllImages();
165 
166  StructuredData::ObjectSP all_image_info_json_sp(
168  ImageInfo::collection image_infos;
169  if (all_image_info_json_sp.get() &&
170  all_image_info_json_sp->GetAsDictionary() &&
171  all_image_info_json_sp->GetAsDictionary()->HasKey("images") &&
172  all_image_info_json_sp->GetAsDictionary()
173  ->GetValueForKey("images")
174  ->GetAsArray()) {
175  if (JSONImageInformationIntoImageInfo(all_image_info_json_sp,
176  image_infos)) {
177  LLDB_LOGF(log, "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  TypeSystemClang *clang_ast_context =
227  TypeSystemClang::GetScratch(process->GetTarget());
228  if (!clang_ast_context)
229  return false;
230 
231  ValueList argument_values;
232 
233  Value mode_value; // enum dyld_notify_mode { dyld_notify_adding=0,
234  // dyld_notify_removing=1, dyld_notify_remove_all=2 };
235  Value count_value; // unsigned long count
236  Value headers_value; // uint64_t machHeaders[] (aka void*)
237 
238  CompilerType clang_void_ptr_type =
239  clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
240  CompilerType clang_uint32_type =
241  clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
242  lldb::eEncodingUint, 32);
243  CompilerType clang_uint64_type =
244  clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
245  lldb::eEncodingUint, 32);
246 
247  mode_value.SetValueType(Value::eValueTypeScalar);
248  mode_value.SetCompilerType(clang_uint32_type);
249 
250  if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 4) {
251  count_value.SetValueType(Value::eValueTypeScalar);
252  count_value.SetCompilerType(clang_uint32_type);
253  } else {
254  count_value.SetValueType(Value::eValueTypeScalar);
255  count_value.SetCompilerType(clang_uint64_type);
256  }
257 
258  headers_value.SetValueType(Value::eValueTypeScalar);
259  headers_value.SetCompilerType(clang_void_ptr_type);
260 
261  argument_values.PushValue(mode_value);
262  argument_values.PushValue(count_value);
263  argument_values.PushValue(headers_value);
264 
265  if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
266  uint32_t dyld_mode =
267  argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
268  if (dyld_mode != static_cast<uint32_t>(-1)) {
269  // Okay the mode was right, now get the number of elements, and the
270  // array of new elements...
271  uint32_t image_infos_count =
272  argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
273  if (image_infos_count != static_cast<uint32_t>(-1)) {
274  addr_t header_array =
275  argument_values.GetValueAtIndex(2)->GetScalar().ULongLong(-1);
276  if (header_array != static_cast<uint64_t>(-1)) {
277  std::vector<addr_t> image_load_addresses;
278  for (uint64_t i = 0; i < image_infos_count; i++) {
279  Status error;
280  addr_t addr = process->ReadUnsignedIntegerFromMemory(
281  header_array + (8 * i), 8, LLDB_INVALID_ADDRESS, error);
282  if (addr != LLDB_INVALID_ADDRESS) {
283  image_load_addresses.push_back(addr);
284  }
285  }
286  if (dyld_mode == 0) {
287  // dyld_notify_adding
288  dyld_instance->AddBinaries(image_load_addresses);
289  } else if (dyld_mode == 1) {
290  // dyld_notify_removing
291  dyld_instance->UnloadImages(image_load_addresses);
292  } else if (dyld_mode == 2) {
293  // dyld_notify_remove_all
294  dyld_instance->UnloadAllImages();
295  }
296  }
297  }
298  }
299  }
300  } else {
301  process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
302  "No ABI plugin located for triple %s -- shared libraries will not be "
303  "registered!\n",
304  process->GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
305  }
306 
307  // Return true to stop the target, false to just let the target run
308  return dyld_instance->GetStopWhenImagesChange();
309 }
310 
312  const std::vector<lldb::addr_t> &load_addresses) {
314  ImageInfo::collection image_infos;
315 
316  LLDB_LOGF(log, "Adding %" PRId64 " modules.",
317  (uint64_t)load_addresses.size());
318  StructuredData::ObjectSP binaries_info_sp =
319  m_process->GetLoadedDynamicLibrariesInfos(load_addresses);
320  if (binaries_info_sp.get() && binaries_info_sp->GetAsDictionary() &&
321  binaries_info_sp->GetAsDictionary()->HasKey("images") &&
322  binaries_info_sp->GetAsDictionary()
323  ->GetValueForKey("images")
324  ->GetAsArray() &&
325  binaries_info_sp->GetAsDictionary()
326  ->GetValueForKey("images")
327  ->GetAsArray()
328  ->GetSize() == load_addresses.size()) {
329  if (JSONImageInformationIntoImageInfo(binaries_info_sp, image_infos)) {
331  AddModulesUsingImageInfos(image_infos);
332  }
334  }
335 }
336 
337 // Dump the _dyld_all_image_infos members and all current image infos that we
338 // have parsed to the file handle provided.
340  if (log == nullptr)
341  return;
342 }
343 
346  ConstString g_symbol_name("_dyld_debugger_notification");
347  const Symbol *symbol = nullptr;
348  ModuleSP dyld_sp(GetDYLDModule());
349  if (dyld_sp) {
350  symbol = dyld_sp->FindFirstSymbolWithNameAndType(g_symbol_name,
352  }
353  if (symbol &&
354  (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
355  addr_t symbol_address =
357  if (symbol_address != LLDB_INVALID_ADDRESS) {
358  bool internal = true;
359  bool hardware = false;
360  Breakpoint *breakpoint =
362  .CreateBreakpoint(symbol_address, internal, hardware)
363  .get();
365  true);
366  breakpoint->SetBreakpointKind("shared-library-event");
367  m_break_id = breakpoint->GetID();
368  }
369  }
370  }
372 }
373 
374 addr_t
376  SymbolContext sc;
377  Target &target = m_process->GetTarget();
378  if (Symtab *symtab = module->GetSymtab()) {
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  return LLDB_INVALID_ADDRESS;
393 }
394 
395 // Look for this symbol:
396 //
397 // int __attribute__((visibility("hidden"))) _dyld_global_lock_held =
398 // 0;
399 //
400 // in libdyld.dylib.
402  Status error;
403  addr_t symbol_address = LLDB_INVALID_ADDRESS;
404  Target &target = m_process->GetTarget();
405  const ModuleList &target_modules = target.GetImages();
406  std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
407  const size_t num_modules = target_modules.GetSize();
408  ConstString g_libdyld_name("libdyld.dylib");
409 
410  // Find any modules named "libdyld.dylib" and look for the symbol there first
411  for (size_t i = 0; i < num_modules; i++) {
412  Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i);
413  if (module_pointer) {
414  if (module_pointer->GetFileSpec().GetFilename() == g_libdyld_name) {
415  symbol_address = GetDyldLockVariableAddressFromModule(module_pointer);
416  if (symbol_address != LLDB_INVALID_ADDRESS)
417  break;
418  }
419  }
420  }
421 
422  // Search through all modules looking for the symbol in them
423  if (symbol_address == LLDB_INVALID_ADDRESS) {
424  for (size_t i = 0; i < num_modules; i++) {
425  Module *module_pointer =
426  target_modules.GetModulePointerAtIndexUnlocked(i);
427  if (module_pointer) {
428  addr_t symbol_address =
429  GetDyldLockVariableAddressFromModule(module_pointer);
430  if (symbol_address != LLDB_INVALID_ADDRESS)
431  break;
432  }
433  }
434  }
435 
436  // Default assumption is that it is OK to load images. Only say that we
437  // cannot load images if we find the symbol in libdyld and it indicates that
438  // we cannot.
439 
440  if (symbol_address != LLDB_INVALID_ADDRESS) {
441  {
442  int lock_held =
443  m_process->ReadUnsignedIntegerFromMemory(symbol_address, 4, 0, error);
444  if (lock_held != 0) {
445  error.SetErrorString("dyld lock held - unsafe to load images.");
446  }
447  }
448  } else {
449  // If we were unable to find _dyld_global_lock_held in any modules, or it
450  // is not loaded into memory yet, we may be at process startup (sitting at
451  // _dyld_start) - so we should not allow dlopen calls. But if we found more
452  // than one module then we are clearly past _dyld_start so in that case
453  // we'll default to "it's safe".
454  if (num_modules <= 1)
455  error.SetErrorString("could not find the dyld library or "
456  "the dyld lock symbol");
457  }
458  return error;
459 }
460 
462  lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache,
463  LazyBool &private_shared_cache) {
464  base_address = LLDB_INVALID_ADDRESS;
465  uuid.Clear();
466  using_shared_cache = eLazyBoolCalculate;
467  private_shared_cache = eLazyBoolCalculate;
468 
469  if (m_process) {
471  StructuredData::Dictionary *info_dict = nullptr;
472  if (info.get() && info->GetAsDictionary()) {
473  info_dict = info->GetAsDictionary();
474  }
475 
476  // {"shared_cache_base_address":140735683125248,"shared_cache_uuid
477  // ":"DDB8D70C-
478  // C9A2-3561-B2C8-BE48A4F33F96","no_shared_cache":false,"shared_cache_private_cache":false}
479 
480  if (info_dict && info_dict->HasKey("shared_cache_uuid") &&
481  info_dict->HasKey("no_shared_cache") &&
482  info_dict->HasKey("shared_cache_base_address")) {
483  base_address = info_dict->GetValueForKey("shared_cache_base_address")
484  ->GetIntegerValue(LLDB_INVALID_ADDRESS);
485  std::string uuid_str = std::string(
486  info_dict->GetValueForKey("shared_cache_uuid")->GetStringValue());
487  if (!uuid_str.empty())
488  uuid.SetFromStringRef(uuid_str);
489  if (!info_dict->GetValueForKey("no_shared_cache")->GetBooleanValue())
490  using_shared_cache = eLazyBoolYes;
491  else
492  using_shared_cache = eLazyBoolNo;
493  if (info_dict->GetValueForKey("shared_cache_private_cache")
494  ->GetBooleanValue())
495  private_shared_cache = eLazyBoolYes;
496  else
497  private_shared_cache = eLazyBoolNo;
498 
499  return true;
500  }
501  }
502  return false;
503 }
504 
506  PluginManager::RegisterPlugin(GetPluginNameStatic(),
508 }
509 
511  PluginManager::UnregisterPlugin(CreateInstance);
512 }
513 
515  static ConstString g_name("macos-dyld");
516  return g_name;
517 }
518 
520  return "Dynamic loader plug-in that watches for shared library loads/unloads "
521  "in MacOSX user processes.";
522 }
523 
524 // PluginInterface protocol
526  return GetPluginNameStatic();
527 }
528 
Address & GetAddressRef()
Definition: Symbol.h:57
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:341
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:916
void AddBinaries(const std::vector< lldb::addr_t > &load_addresses)
A class that represents a running process on the host machine.
const ArchSpec & GetArchitecture() const
Definition: Target.h:942
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:465
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
A TypeSystem implementation based on Clang.
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:730
bool AddModulesUsingImageInfos(ImageInfo::collection &image_infos)
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:1225
Thread & GetThreadRef() const
Returns a reference to the thread object.
ThreadList & GetThreadList()
Definition: Process.h:2067
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:441
Value * GetValueAtIndex(size_t idx)
Definition: Value.cpp:705
void SetValueType(ValueType value_type)
Definition: Value.h:144
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
lldb::StreamSP GetAsyncErrorStream()
Definition: Debugger.cpp:1045
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:1356
void UnloadImages(const std::vector< lldb::addr_t > &solib_addresses)
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:434
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.
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:433
CompilerType GetBasicType(lldb::BasicType type)
#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:336
uint32_t GetStopID() const
Definition: Process.h:1357
CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size) override
bool DidSetNotificationBreakpoint() override
A collection class for Module objects.
Definition: ModuleList.h:71
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:75
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:1581
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:1611
lldb::addr_t GetOpcodeLoadAddress(Target *target, AddressClass addr_class=AddressClass::eInvalid) const
Get the load address as an opcode load address.
Definition: Address.cpp:367
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:242
unsigned integer
void PutToLog(lldb_private::Log *log) const
bool ValueIsAddress() const
Definition: Symbol.cpp:118
A plug-in interface definition class for debugging a process.
Definition: Process.h:362
Process * GetProcessPtr() const
Returns a pointer to the process object.
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:332
bool HasKey(llvm::StringRef key) const
unsigned int UInt(unsigned int fail_value=0) const
Definition: Scalar.cpp:1491
CompilerType GetPointerType() const
Return a new CompilerType that is a pointer to this type.
Symtab * GetSymtab()
Definition: Module.cpp:1040
bool NeedToDoInitialImageFetch() override
lldb::user_id_t m_break_id
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:900
#define LIBLLDB_LOG_DYNAMIC_LOADER
Definition: Logging.h:17
#define LLDB_LOGF(log,...)
Definition: Log.h:249
std::recursive_mutex m_mutex
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1208
uint64_t addr_t
Definition: lldb-types.h:83
void Clear()
Definition: UUID.h:55
size_t GetSize() const
Gets the size of the module list.
Definition: ModuleList.cpp:584
void DoInitialImageFetch() override
A uniqued constant string class.
Definition: ConstString.h:40
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
Definition: SBAddress.h:15
ConstString GetName() const
Definition: Symbol.cpp:499
Represents a generic type in a programming language.
Definition: CompilerType.h:33
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:1284
#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:168
std::recursive_mutex & GetMutex() const
Definition: ModuleList.h:192
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:1579
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:2204
#define LLDB_BREAK_ID_IS_VALID(bid)
Definition: lldb-defines.h:51
std::recursive_mutex & GetMutex() const
bool SetNotificationBreakpoint() override
virtual lldb_private::StructuredData::ObjectSP GetSharedCacheInfo()
Definition: Process.h:1309
lldb::addr_t m_maybe_image_infos_address
Debugger & GetDebugger()
Definition: Target.h:975
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:323
An error handling class.
Definition: Status.h:44
void Clear()
Clear the object&#39;s state.
Definition: Address.h:178
void PushValue(const Value &value)
Definition: Value.cpp:701