1 //===-- DynamicLoaderMacOSXDYLD.cpp ---------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "DynamicLoaderMacOSXDYLD.h"
10 #include "DynamicLoaderDarwin.h"
11 #include "DynamicLoaderMacOS.h"
12 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
13 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
14 #include "lldb/Breakpoint/StoppointCallbackContext.h"
15 #include "lldb/Core/Debugger.h"
16 #include "lldb/Core/Module.h"
17 #include "lldb/Core/ModuleSpec.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/Section.h"
20 #include "lldb/Symbol/Function.h"
21 #include "lldb/Symbol/ObjectFile.h"
22 #include "lldb/Target/ABI.h"
23 #include "lldb/Target/RegisterContext.h"
24 #include "lldb/Target/StackFrame.h"
25 #include "lldb/Target/Target.h"
26 #include "lldb/Target/Thread.h"
27 #include "lldb/Target/ThreadPlanRunToAddress.h"
28 #include "lldb/Utility/DataBuffer.h"
29 #include "lldb/Utility/DataBufferHeap.h"
30 #include "lldb/Utility/Log.h"
31 #include "lldb/Utility/State.h"
32
33 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
34 #ifdef ENABLE_DEBUG_PRINTF
35 #include <stdio.h>
36 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
37 #else
38 #define DEBUG_PRINTF(fmt, ...)
39 #endif
40
41 #ifndef __APPLE__
42 #include "Utility/UuidCompatibility.h"
43 #else
44 #include <uuid/uuid.h>
45 #endif
46
47 using namespace lldb;
48 using namespace lldb_private;
49
LLDB_PLUGIN_DEFINE(DynamicLoaderMacOSXDYLD)50 LLDB_PLUGIN_DEFINE(DynamicLoaderMacOSXDYLD)
51
52 // Create an instance of this class. This function is filled into the plugin
53 // info class that gets handed out by the plugin factory and allows the lldb to
54 // instantiate an instance of this class.
55 DynamicLoader *DynamicLoaderMacOSXDYLD::CreateInstance(Process *process,
56 bool force) {
57 bool create = force;
58 if (!create) {
59 create = true;
60 Module *exe_module = process->GetTarget().GetExecutableModulePointer();
61 if (exe_module) {
62 ObjectFile *object_file = exe_module->GetObjectFile();
63 if (object_file) {
64 create = (object_file->GetStrata() == ObjectFile::eStrataUser);
65 }
66 }
67
68 if (create) {
69 const llvm::Triple &triple_ref =
70 process->GetTarget().GetArchitecture().GetTriple();
71 switch (triple_ref.getOS()) {
72 case llvm::Triple::Darwin:
73 case llvm::Triple::MacOSX:
74 case llvm::Triple::IOS:
75 case llvm::Triple::TvOS:
76 case llvm::Triple::WatchOS:
77 // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
78 create = triple_ref.getVendor() == llvm::Triple::Apple;
79 break;
80 default:
81 create = false;
82 break;
83 }
84 }
85 }
86
87 if (UseDYLDSPI(process)) {
88 create = false;
89 }
90
91 if (create)
92 return new DynamicLoaderMacOSXDYLD(process);
93 return nullptr;
94 }
95
96 // Constructor
DynamicLoaderMacOSXDYLD(Process * process)97 DynamicLoaderMacOSXDYLD::DynamicLoaderMacOSXDYLD(Process *process)
98 : DynamicLoaderDarwin(process),
99 m_dyld_all_image_infos_addr(LLDB_INVALID_ADDRESS),
100 m_dyld_all_image_infos(), m_dyld_all_image_infos_stop_id(UINT32_MAX),
101 m_break_id(LLDB_INVALID_BREAK_ID), m_mutex(),
102 m_process_image_addr_is_all_images_infos(false) {}
103
104 // Destructor
~DynamicLoaderMacOSXDYLD()105 DynamicLoaderMacOSXDYLD::~DynamicLoaderMacOSXDYLD() {
106 if (LLDB_BREAK_ID_IS_VALID(m_break_id))
107 m_process->GetTarget().RemoveBreakpointByID(m_break_id);
108 }
109
ProcessDidExec()110 bool DynamicLoaderMacOSXDYLD::ProcessDidExec() {
111 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
112 bool did_exec = false;
113 if (m_process) {
114 // If we are stopped after an exec, we will have only one thread...
115 if (m_process->GetThreadList().GetSize() == 1) {
116 // We know if a process has exec'ed if our "m_dyld_all_image_infos_addr"
117 // value differs from the Process' image info address. When a process
118 // execs itself it might cause a change if ASLR is enabled.
119 const addr_t shlib_addr = m_process->GetImageInfoAddress();
120 if (m_process_image_addr_is_all_images_infos &&
121 shlib_addr != m_dyld_all_image_infos_addr) {
122 // The image info address from the process is the
123 // 'dyld_all_image_infos' address and it has changed.
124 did_exec = true;
125 } else if (!m_process_image_addr_is_all_images_infos &&
126 shlib_addr == m_dyld.address) {
127 // The image info address from the process is the mach_header address
128 // for dyld and it has changed.
129 did_exec = true;
130 } else {
131 // ASLR might be disabled and dyld could have ended up in the same
132 // location. We should try and detect if we are stopped at
133 // '_dyld_start'
134 ThreadSP thread_sp(m_process->GetThreadList().GetThreadAtIndex(0));
135 if (thread_sp) {
136 lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
137 if (frame_sp) {
138 const Symbol *symbol =
139 frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
140 if (symbol) {
141 if (symbol->GetName() == "_dyld_start")
142 did_exec = true;
143 }
144 }
145 }
146 }
147
148 if (did_exec) {
149 m_libpthread_module_wp.reset();
150 m_pthread_getspecific_addr.Clear();
151 }
152 }
153 }
154 return did_exec;
155 }
156
157 // Clear out the state of this class.
DoClear()158 void DynamicLoaderMacOSXDYLD::DoClear() {
159 std::lock_guard<std::recursive_mutex> guard(m_mutex);
160
161 if (LLDB_BREAK_ID_IS_VALID(m_break_id))
162 m_process->GetTarget().RemoveBreakpointByID(m_break_id);
163
164 m_dyld_all_image_infos_addr = LLDB_INVALID_ADDRESS;
165 m_dyld_all_image_infos.Clear();
166 m_break_id = LLDB_INVALID_BREAK_ID;
167 }
168
169 // Check if we have found DYLD yet
DidSetNotificationBreakpoint()170 bool DynamicLoaderMacOSXDYLD::DidSetNotificationBreakpoint() {
171 return LLDB_BREAK_ID_IS_VALID(m_break_id);
172 }
173
ClearNotificationBreakpoint()174 void DynamicLoaderMacOSXDYLD::ClearNotificationBreakpoint() {
175 if (LLDB_BREAK_ID_IS_VALID(m_break_id)) {
176 m_process->GetTarget().RemoveBreakpointByID(m_break_id);
177 }
178 }
179
180 // Try and figure out where dyld is by first asking the Process if it knows
181 // (which currently calls down in the lldb::Process to get the DYLD info
182 // (available on SnowLeopard only). If that fails, then check in the default
183 // addresses.
DoInitialImageFetch()184 void DynamicLoaderMacOSXDYLD::DoInitialImageFetch() {
185 if (m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS) {
186 // Check the image info addr as it might point to the mach header for dyld,
187 // or it might point to the dyld_all_image_infos struct
188 const addr_t shlib_addr = m_process->GetImageInfoAddress();
189 if (shlib_addr != LLDB_INVALID_ADDRESS) {
190 ByteOrder byte_order =
191 m_process->GetTarget().GetArchitecture().GetByteOrder();
192 uint8_t buf[4];
193 DataExtractor data(buf, sizeof(buf), byte_order, 4);
194 Status error;
195 if (m_process->ReadMemory(shlib_addr, buf, 4, error) == 4) {
196 lldb::offset_t offset = 0;
197 uint32_t magic = data.GetU32(&offset);
198 switch (magic) {
199 case llvm::MachO::MH_MAGIC:
200 case llvm::MachO::MH_MAGIC_64:
201 case llvm::MachO::MH_CIGAM:
202 case llvm::MachO::MH_CIGAM_64:
203 m_process_image_addr_is_all_images_infos = false;
204 ReadDYLDInfoFromMemoryAndSetNotificationCallback(shlib_addr);
205 return;
206
207 default:
208 break;
209 }
210 }
211 // Maybe it points to the all image infos?
212 m_dyld_all_image_infos_addr = shlib_addr;
213 m_process_image_addr_is_all_images_infos = true;
214 }
215 }
216
217 if (m_dyld_all_image_infos_addr != LLDB_INVALID_ADDRESS) {
218 if (ReadAllImageInfosStructure()) {
219 if (m_dyld_all_image_infos.dyldImageLoadAddress != LLDB_INVALID_ADDRESS)
220 ReadDYLDInfoFromMemoryAndSetNotificationCallback(
221 m_dyld_all_image_infos.dyldImageLoadAddress);
222 else
223 ReadDYLDInfoFromMemoryAndSetNotificationCallback(
224 m_dyld_all_image_infos_addr & 0xfffffffffff00000ull);
225 return;
226 }
227 }
228
229 // Check some default values
230 Module *executable = m_process->GetTarget().GetExecutableModulePointer();
231
232 if (executable) {
233 const ArchSpec &exe_arch = executable->GetArchitecture();
234 if (exe_arch.GetAddressByteSize() == 8) {
235 ReadDYLDInfoFromMemoryAndSetNotificationCallback(0x7fff5fc00000ull);
236 } else if (exe_arch.GetMachine() == llvm::Triple::arm ||
237 exe_arch.GetMachine() == llvm::Triple::thumb ||
238 exe_arch.GetMachine() == llvm::Triple::aarch64 ||
239 exe_arch.GetMachine() == llvm::Triple::aarch64_32) {
240 ReadDYLDInfoFromMemoryAndSetNotificationCallback(0x2fe00000);
241 } else {
242 ReadDYLDInfoFromMemoryAndSetNotificationCallback(0x8fe00000);
243 }
244 }
245 return;
246 }
247
248 // Assume that dyld is in memory at ADDR and try to parse it's load commands
ReadDYLDInfoFromMemoryAndSetNotificationCallback(lldb::addr_t addr)249 bool DynamicLoaderMacOSXDYLD::ReadDYLDInfoFromMemoryAndSetNotificationCallback(
250 lldb::addr_t addr) {
251 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
252 DataExtractor data; // Load command data
253 static ConstString g_dyld_all_image_infos("dyld_all_image_infos");
254 if (ReadMachHeader(addr, &m_dyld.header, &data)) {
255 if (m_dyld.header.filetype == llvm::MachO::MH_DYLINKER) {
256 m_dyld.address = addr;
257 ModuleSP dyld_module_sp;
258 if (ParseLoadCommands(data, m_dyld, &m_dyld.file_spec)) {
259 if (m_dyld.file_spec) {
260 UpdateDYLDImageInfoFromNewImageInfo(m_dyld);
261 }
262 }
263 dyld_module_sp = GetDYLDModule();
264
265 Target &target = m_process->GetTarget();
266
267 if (m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS &&
268 dyld_module_sp.get()) {
269 const Symbol *symbol = dyld_module_sp->FindFirstSymbolWithNameAndType(
270 g_dyld_all_image_infos, eSymbolTypeData);
271 if (symbol)
272 m_dyld_all_image_infos_addr = symbol->GetLoadAddress(&target);
273 }
274
275 // Update all image infos
276 InitializeFromAllImageInfos();
277
278 // If we didn't have an executable before, but now we do, then the dyld
279 // module shared pointer might be unique and we may need to add it again
280 // (since Target::SetExecutableModule() will clear the images). So append
281 // the dyld module back to the list if it is
282 /// unique!
283 if (dyld_module_sp) {
284 target.GetImages().AppendIfNeeded(dyld_module_sp);
285
286 // At this point we should have read in dyld's module, and so we should
287 // set breakpoints in it:
288 ModuleList modules;
289 modules.Append(dyld_module_sp);
290 target.ModulesDidLoad(modules);
291 SetDYLDModule(dyld_module_sp);
292 }
293
294 return true;
295 }
296 }
297 return false;
298 }
299
NeedToDoInitialImageFetch()300 bool DynamicLoaderMacOSXDYLD::NeedToDoInitialImageFetch() {
301 return m_dyld_all_image_infos_addr == LLDB_INVALID_ADDRESS;
302 }
303
304 // Static callback function that gets called when our DYLD notification
305 // breakpoint gets hit. We update all of our image infos and then let our super
306 // class DynamicLoader class decide if we should stop or not (based on global
307 // preference).
NotifyBreakpointHit(void * baton,StoppointCallbackContext * context,lldb::user_id_t break_id,lldb::user_id_t break_loc_id)308 bool DynamicLoaderMacOSXDYLD::NotifyBreakpointHit(
309 void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
310 lldb::user_id_t break_loc_id) {
311 // Let the event know that the images have changed
312 // DYLD passes three arguments to the notification breakpoint.
313 // Arg1: enum dyld_image_mode mode - 0 = adding, 1 = removing Arg2: uint32_t
314 // infoCount - Number of shared libraries added Arg3: dyld_image_info
315 // info[] - Array of structs of the form:
316 // const struct mach_header
317 // *imageLoadAddress
318 // const char *imageFilePath
319 // uintptr_t imageFileModDate (a time_t)
320
321 DynamicLoaderMacOSXDYLD *dyld_instance = (DynamicLoaderMacOSXDYLD *)baton;
322
323 // First step is to see if we've already initialized the all image infos. If
324 // we haven't then this function will do so and return true. In the course
325 // of initializing the all_image_infos it will read the complete current
326 // state, so we don't need to figure out what has changed from the data
327 // passed in to us.
328
329 ExecutionContext exe_ctx(context->exe_ctx_ref);
330 Process *process = exe_ctx.GetProcessPtr();
331
332 // This is a sanity check just in case this dyld_instance is an old dyld
333 // plugin's breakpoint still lying around.
334 if (process != dyld_instance->m_process)
335 return false;
336
337 if (dyld_instance->InitializeFromAllImageInfos())
338 return dyld_instance->GetStopWhenImagesChange();
339
340 const lldb::ABISP &abi = process->GetABI();
341 if (abi) {
342 // Build up the value array to store the three arguments given above, then
343 // get the values from the ABI:
344
345 TypeSystemClang *clang_ast_context =
346 ScratchTypeSystemClang::GetForTarget(process->GetTarget());
347 if (!clang_ast_context)
348 return false;
349
350 ValueList argument_values;
351 Value input_value;
352
353 CompilerType clang_void_ptr_type =
354 clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
355 CompilerType clang_uint32_type =
356 clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
357 lldb::eEncodingUint, 32);
358 input_value.SetValueType(Value::eValueTypeScalar);
359 input_value.SetCompilerType(clang_uint32_type);
360 // input_value.SetContext (Value::eContextTypeClangType,
361 // clang_uint32_type);
362 argument_values.PushValue(input_value);
363 argument_values.PushValue(input_value);
364 input_value.SetCompilerType(clang_void_ptr_type);
365 // input_value.SetContext (Value::eContextTypeClangType,
366 // clang_void_ptr_type);
367 argument_values.PushValue(input_value);
368
369 if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
370 uint32_t dyld_mode =
371 argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
372 if (dyld_mode != static_cast<uint32_t>(-1)) {
373 // Okay the mode was right, now get the number of elements, and the
374 // array of new elements...
375 uint32_t image_infos_count =
376 argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
377 if (image_infos_count != static_cast<uint32_t>(-1)) {
378 // Got the number added, now go through the array of added elements,
379 // putting out the mach header address, and adding the image. Note,
380 // I'm not putting in logging here, since the AddModules &
381 // RemoveModules functions do all the logging internally.
382
383 lldb::addr_t image_infos_addr =
384 argument_values.GetValueAtIndex(2)->GetScalar().ULongLong();
385 if (dyld_mode == 0) {
386 // This is add:
387 dyld_instance->AddModulesUsingImageInfosAddress(image_infos_addr,
388 image_infos_count);
389 } else {
390 // This is remove:
391 dyld_instance->RemoveModulesUsingImageInfosAddress(
392 image_infos_addr, image_infos_count);
393 }
394 }
395 }
396 }
397 } else {
398 process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
399 "No ABI plugin located for triple %s -- shared libraries will not be "
400 "registered!\n",
401 process->GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
402 }
403
404 // Return true to stop the target, false to just let the target run
405 return dyld_instance->GetStopWhenImagesChange();
406 }
407
ReadAllImageInfosStructure()408 bool DynamicLoaderMacOSXDYLD::ReadAllImageInfosStructure() {
409 std::lock_guard<std::recursive_mutex> guard(m_mutex);
410
411 // the all image infos is already valid for this process stop ID
412 if (m_process->GetStopID() == m_dyld_all_image_infos_stop_id)
413 return true;
414
415 m_dyld_all_image_infos.Clear();
416 if (m_dyld_all_image_infos_addr != LLDB_INVALID_ADDRESS) {
417 ByteOrder byte_order =
418 m_process->GetTarget().GetArchitecture().GetByteOrder();
419 uint32_t addr_size =
420 m_process->GetTarget().GetArchitecture().GetAddressByteSize();
421
422 uint8_t buf[256];
423 DataExtractor data(buf, sizeof(buf), byte_order, addr_size);
424 lldb::offset_t offset = 0;
425
426 const size_t count_v2 = sizeof(uint32_t) + // version
427 sizeof(uint32_t) + // infoArrayCount
428 addr_size + // infoArray
429 addr_size + // notification
430 addr_size + // processDetachedFromSharedRegion +
431 // libSystemInitialized + pad
432 addr_size; // dyldImageLoadAddress
433 const size_t count_v11 = count_v2 + addr_size + // jitInfo
434 addr_size + // dyldVersion
435 addr_size + // errorMessage
436 addr_size + // terminationFlags
437 addr_size + // coreSymbolicationShmPage
438 addr_size + // systemOrderFlag
439 addr_size + // uuidArrayCount
440 addr_size + // uuidArray
441 addr_size + // dyldAllImageInfosAddress
442 addr_size + // initialImageCount
443 addr_size + // errorKind
444 addr_size + // errorClientOfDylibPath
445 addr_size + // errorTargetDylibPath
446 addr_size; // errorSymbol
447 const size_t count_v13 = count_v11 + addr_size + // sharedCacheSlide
448 sizeof(uuid_t); // sharedCacheUUID
449 UNUSED_IF_ASSERT_DISABLED(count_v13);
450 assert(sizeof(buf) >= count_v13);
451
452 Status error;
453 if (m_process->ReadMemory(m_dyld_all_image_infos_addr, buf, 4, error) ==
454 4) {
455 m_dyld_all_image_infos.version = data.GetU32(&offset);
456 // If anything in the high byte is set, we probably got the byte order
457 // incorrect (the process might not have it set correctly yet due to
458 // attaching to a program without a specified file).
459 if (m_dyld_all_image_infos.version & 0xff000000) {
460 // We have guessed the wrong byte order. Swap it and try reading the
461 // version again.
462 if (byte_order == eByteOrderLittle)
463 byte_order = eByteOrderBig;
464 else
465 byte_order = eByteOrderLittle;
466
467 data.SetByteOrder(byte_order);
468 offset = 0;
469 m_dyld_all_image_infos.version = data.GetU32(&offset);
470 }
471 } else {
472 return false;
473 }
474
475 const size_t count =
476 (m_dyld_all_image_infos.version >= 11) ? count_v11 : count_v2;
477
478 const size_t bytes_read =
479 m_process->ReadMemory(m_dyld_all_image_infos_addr, buf, count, error);
480 if (bytes_read == count) {
481 offset = 0;
482 m_dyld_all_image_infos.version = data.GetU32(&offset);
483 m_dyld_all_image_infos.dylib_info_count = data.GetU32(&offset);
484 m_dyld_all_image_infos.dylib_info_addr = data.GetAddress(&offset);
485 m_dyld_all_image_infos.notification = data.GetAddress(&offset);
486 m_dyld_all_image_infos.processDetachedFromSharedRegion =
487 data.GetU8(&offset);
488 m_dyld_all_image_infos.libSystemInitialized = data.GetU8(&offset);
489 // Adjust for padding.
490 offset += addr_size - 2;
491 m_dyld_all_image_infos.dyldImageLoadAddress = data.GetAddress(&offset);
492 if (m_dyld_all_image_infos.version >= 11) {
493 offset += addr_size * 8;
494 uint64_t dyld_all_image_infos_addr = data.GetAddress(&offset);
495
496 // When we started, we were given the actual address of the
497 // all_image_infos struct (probably via TASK_DYLD_INFO) in memory -
498 // this address is stored in m_dyld_all_image_infos_addr and is the
499 // most accurate address we have.
500
501 // We read the dyld_all_image_infos struct from memory; it contains its
502 // own address. If the address in the struct does not match the actual
503 // address, the dyld we're looking at has been loaded at a different
504 // location (slid) from where it intended to load. The addresses in
505 // the dyld_all_image_infos struct are the original, non-slid
506 // addresses, and need to be adjusted. Most importantly the address of
507 // dyld and the notification address need to be adjusted.
508
509 if (dyld_all_image_infos_addr != m_dyld_all_image_infos_addr) {
510 uint64_t image_infos_offset =
511 dyld_all_image_infos_addr -
512 m_dyld_all_image_infos.dyldImageLoadAddress;
513 uint64_t notification_offset =
514 m_dyld_all_image_infos.notification -
515 m_dyld_all_image_infos.dyldImageLoadAddress;
516 m_dyld_all_image_infos.dyldImageLoadAddress =
517 m_dyld_all_image_infos_addr - image_infos_offset;
518 m_dyld_all_image_infos.notification =
519 m_dyld_all_image_infos.dyldImageLoadAddress + notification_offset;
520 }
521 }
522 m_dyld_all_image_infos_stop_id = m_process->GetStopID();
523 return true;
524 }
525 }
526 return false;
527 }
528
AddModulesUsingImageInfosAddress(lldb::addr_t image_infos_addr,uint32_t image_infos_count)529 bool DynamicLoaderMacOSXDYLD::AddModulesUsingImageInfosAddress(
530 lldb::addr_t image_infos_addr, uint32_t image_infos_count) {
531 ImageInfo::collection image_infos;
532 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
533 LLDB_LOGF(log, "Adding %d modules.\n", image_infos_count);
534
535 std::lock_guard<std::recursive_mutex> guard(m_mutex);
536 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
537 if (m_process->GetStopID() == m_dyld_image_infos_stop_id)
538 return true;
539
540 StructuredData::ObjectSP image_infos_json_sp =
541 m_process->GetLoadedDynamicLibrariesInfos(image_infos_addr,
542 image_infos_count);
543 if (image_infos_json_sp.get() && image_infos_json_sp->GetAsDictionary() &&
544 image_infos_json_sp->GetAsDictionary()->HasKey("images") &&
545 image_infos_json_sp->GetAsDictionary()
546 ->GetValueForKey("images")
547 ->GetAsArray() &&
548 image_infos_json_sp->GetAsDictionary()
549 ->GetValueForKey("images")
550 ->GetAsArray()
551 ->GetSize() == image_infos_count) {
552 bool return_value = false;
553 if (JSONImageInformationIntoImageInfo(image_infos_json_sp, image_infos)) {
554 UpdateSpecialBinariesFromNewImageInfos(image_infos);
555 return_value = AddModulesUsingImageInfos(image_infos);
556 }
557 m_dyld_image_infos_stop_id = m_process->GetStopID();
558 return return_value;
559 }
560
561 if (!ReadImageInfos(image_infos_addr, image_infos_count, image_infos))
562 return false;
563
564 UpdateImageInfosHeaderAndLoadCommands(image_infos, image_infos_count, false);
565 bool return_value = AddModulesUsingImageInfos(image_infos);
566 m_dyld_image_infos_stop_id = m_process->GetStopID();
567 return return_value;
568 }
569
RemoveModulesUsingImageInfosAddress(lldb::addr_t image_infos_addr,uint32_t image_infos_count)570 bool DynamicLoaderMacOSXDYLD::RemoveModulesUsingImageInfosAddress(
571 lldb::addr_t image_infos_addr, uint32_t image_infos_count) {
572 ImageInfo::collection image_infos;
573 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
574
575 std::lock_guard<std::recursive_mutex> guard(m_mutex);
576 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
577 if (m_process->GetStopID() == m_dyld_image_infos_stop_id)
578 return true;
579
580 // First read in the image_infos for the removed modules, and their headers &
581 // load commands.
582 if (!ReadImageInfos(image_infos_addr, image_infos_count, image_infos)) {
583 if (log)
584 log->PutCString("Failed reading image infos array.");
585 return false;
586 }
587
588 LLDB_LOGF(log, "Removing %d modules.", image_infos_count);
589
590 ModuleList unloaded_module_list;
591 for (uint32_t idx = 0; idx < image_infos.size(); ++idx) {
592 if (log) {
593 LLDB_LOGF(log, "Removing module at address=0x%16.16" PRIx64 ".",
594 image_infos[idx].address);
595 image_infos[idx].PutToLog(log);
596 }
597
598 // Remove this image_infos from the m_all_image_infos. We do the
599 // comparison by address rather than by file spec because we can have many
600 // modules with the same "file spec" in the case that they are modules
601 // loaded from memory.
602 //
603 // Also copy over the uuid from the old entry to the removed entry so we
604 // can use it to lookup the module in the module list.
605
606 ImageInfo::collection::iterator pos, end = m_dyld_image_infos.end();
607 for (pos = m_dyld_image_infos.begin(); pos != end; pos++) {
608 if (image_infos[idx].address == (*pos).address) {
609 image_infos[idx].uuid = (*pos).uuid;
610
611 // Add the module from this image_info to the "unloaded_module_list".
612 // We'll remove them all at one go later on.
613
614 ModuleSP unload_image_module_sp(
615 FindTargetModuleForImageInfo(image_infos[idx], false, nullptr));
616 if (unload_image_module_sp.get()) {
617 // When we unload, be sure to use the image info from the old list,
618 // since that has sections correctly filled in.
619 UnloadModuleSections(unload_image_module_sp.get(), *pos);
620 unloaded_module_list.AppendIfNeeded(unload_image_module_sp);
621 } else {
622 if (log) {
623 LLDB_LOGF(log, "Could not find module for unloading info entry:");
624 image_infos[idx].PutToLog(log);
625 }
626 }
627
628 // Then remove it from the m_dyld_image_infos:
629
630 m_dyld_image_infos.erase(pos);
631 break;
632 }
633 }
634
635 if (pos == end) {
636 if (log) {
637 LLDB_LOGF(log, "Could not find image_info entry for unloading image:");
638 image_infos[idx].PutToLog(log);
639 }
640 }
641 }
642 if (unloaded_module_list.GetSize() > 0) {
643 if (log) {
644 log->PutCString("Unloaded:");
645 unloaded_module_list.LogUUIDAndPaths(
646 log, "DynamicLoaderMacOSXDYLD::ModulesDidUnload");
647 }
648 m_process->GetTarget().GetImages().Remove(unloaded_module_list);
649 }
650 m_dyld_image_infos_stop_id = m_process->GetStopID();
651 return true;
652 }
653
ReadImageInfos(lldb::addr_t image_infos_addr,uint32_t image_infos_count,ImageInfo::collection & image_infos)654 bool DynamicLoaderMacOSXDYLD::ReadImageInfos(
655 lldb::addr_t image_infos_addr, uint32_t image_infos_count,
656 ImageInfo::collection &image_infos) {
657 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
658 const ByteOrder endian = GetByteOrderFromMagic(m_dyld.header.magic);
659 const uint32_t addr_size = m_dyld.GetAddressByteSize();
660
661 image_infos.resize(image_infos_count);
662 const size_t count = image_infos.size() * 3 * addr_size;
663 DataBufferHeap info_data(count, 0);
664 Status error;
665 const size_t bytes_read = m_process->ReadMemory(
666 image_infos_addr, info_data.GetBytes(), info_data.GetByteSize(), error);
667 if (bytes_read == count) {
668 lldb::offset_t info_data_offset = 0;
669 DataExtractor info_data_ref(info_data.GetBytes(), info_data.GetByteSize(),
670 endian, addr_size);
671 for (size_t i = 0;
672 i < image_infos.size() && info_data_ref.ValidOffset(info_data_offset);
673 i++) {
674 image_infos[i].address = info_data_ref.GetAddress(&info_data_offset);
675 lldb::addr_t path_addr = info_data_ref.GetAddress(&info_data_offset);
676 image_infos[i].mod_date = info_data_ref.GetAddress(&info_data_offset);
677
678 char raw_path[PATH_MAX];
679 m_process->ReadCStringFromMemory(path_addr, raw_path, sizeof(raw_path),
680 error);
681 // don't resolve the path
682 if (error.Success()) {
683 image_infos[i].file_spec.SetFile(raw_path, FileSpec::Style::native);
684 }
685 }
686 return true;
687 } else {
688 return false;
689 }
690 }
691
692 // If we have found where the "_dyld_all_image_infos" lives in memory, read the
693 // current info from it, and then update all image load addresses (or lack
694 // thereof). Only do this if this is the first time we're reading the dyld
695 // infos. Return true if we actually read anything, and false otherwise.
InitializeFromAllImageInfos()696 bool DynamicLoaderMacOSXDYLD::InitializeFromAllImageInfos() {
697 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
698
699 std::lock_guard<std::recursive_mutex> guard(m_mutex);
700 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
701 if (m_process->GetStopID() == m_dyld_image_infos_stop_id ||
702 m_dyld_image_infos.size() != 0)
703 return false;
704
705 if (ReadAllImageInfosStructure()) {
706 // Nothing to load or unload?
707 if (m_dyld_all_image_infos.dylib_info_count == 0)
708 return true;
709
710 if (m_dyld_all_image_infos.dylib_info_addr == 0) {
711 // DYLD is updating the images now. So we should say we have no images,
712 // and then we'll
713 // figure it out when we hit the added breakpoint.
714 return false;
715 } else {
716 if (!AddModulesUsingImageInfosAddress(
717 m_dyld_all_image_infos.dylib_info_addr,
718 m_dyld_all_image_infos.dylib_info_count)) {
719 DEBUG_PRINTF("%s", "unable to read all data for all_dylib_infos.");
720 m_dyld_image_infos.clear();
721 }
722 }
723
724 // Now we have one more bit of business. If there is a library left in the
725 // images for our target that doesn't have a load address, then it must be
726 // something that we were expecting to load (for instance we read a load
727 // command for it) but it didn't in fact load - probably because
728 // DYLD_*_PATH pointed to an equivalent version. We don't want it to stay
729 // in the target's module list or it will confuse us, so unload it here.
730 Target &target = m_process->GetTarget();
731 const ModuleList &target_modules = target.GetImages();
732 ModuleList not_loaded_modules;
733 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
734
735 size_t num_modules = target_modules.GetSize();
736 for (size_t i = 0; i < num_modules; i++) {
737 ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i);
738 if (!module_sp->IsLoadedInTarget(&target)) {
739 if (log) {
740 StreamString s;
741 module_sp->GetDescription(s.AsRawOstream());
742 LLDB_LOGF(log, "Unloading pre-run module: %s.", s.GetData());
743 }
744 not_loaded_modules.Append(module_sp);
745 }
746 }
747
748 if (not_loaded_modules.GetSize() != 0) {
749 target.GetImages().Remove(not_loaded_modules);
750 }
751
752 return true;
753 } else
754 return false;
755 }
756
757 // Read a mach_header at ADDR into HEADER, and also fill in the load command
758 // data into LOAD_COMMAND_DATA if it is non-NULL.
759 //
760 // Returns true if we succeed, false if we fail for any reason.
ReadMachHeader(lldb::addr_t addr,llvm::MachO::mach_header * header,DataExtractor * load_command_data)761 bool DynamicLoaderMacOSXDYLD::ReadMachHeader(lldb::addr_t addr,
762 llvm::MachO::mach_header *header,
763 DataExtractor *load_command_data) {
764 DataBufferHeap header_bytes(sizeof(llvm::MachO::mach_header), 0);
765 Status error;
766 size_t bytes_read = m_process->ReadMemory(addr, header_bytes.GetBytes(),
767 header_bytes.GetByteSize(), error);
768 if (bytes_read == sizeof(llvm::MachO::mach_header)) {
769 lldb::offset_t offset = 0;
770 ::memset(header, 0, sizeof(llvm::MachO::mach_header));
771
772 // Get the magic byte unswapped so we can figure out what we are dealing
773 // with
774 DataExtractor data(header_bytes.GetBytes(), header_bytes.GetByteSize(),
775 endian::InlHostByteOrder(), 4);
776 header->magic = data.GetU32(&offset);
777 lldb::addr_t load_cmd_addr = addr;
778 data.SetByteOrder(
779 DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic(header->magic));
780 switch (header->magic) {
781 case llvm::MachO::MH_MAGIC:
782 case llvm::MachO::MH_CIGAM:
783 data.SetAddressByteSize(4);
784 load_cmd_addr += sizeof(llvm::MachO::mach_header);
785 break;
786
787 case llvm::MachO::MH_MAGIC_64:
788 case llvm::MachO::MH_CIGAM_64:
789 data.SetAddressByteSize(8);
790 load_cmd_addr += sizeof(llvm::MachO::mach_header_64);
791 break;
792
793 default:
794 return false;
795 }
796
797 // Read the rest of dyld's mach header
798 if (data.GetU32(&offset, &header->cputype,
799 (sizeof(llvm::MachO::mach_header) / sizeof(uint32_t)) -
800 1)) {
801 if (load_command_data == nullptr)
802 return true; // We were able to read the mach_header and weren't asked
803 // to read the load command bytes
804
805 DataBufferSP load_cmd_data_sp(new DataBufferHeap(header->sizeofcmds, 0));
806
807 size_t load_cmd_bytes_read =
808 m_process->ReadMemory(load_cmd_addr, load_cmd_data_sp->GetBytes(),
809 load_cmd_data_sp->GetByteSize(), error);
810
811 if (load_cmd_bytes_read == header->sizeofcmds) {
812 // Set the load command data and also set the correct endian swap
813 // settings and the correct address size
814 load_command_data->SetData(load_cmd_data_sp, 0, header->sizeofcmds);
815 load_command_data->SetByteOrder(data.GetByteOrder());
816 load_command_data->SetAddressByteSize(data.GetAddressByteSize());
817 return true; // We successfully read the mach_header and the load
818 // command data
819 }
820
821 return false; // We weren't able to read the load command data
822 }
823 }
824 return false; // We failed the read the mach_header
825 }
826
827 // Parse the load commands for an image
ParseLoadCommands(const DataExtractor & data,ImageInfo & dylib_info,FileSpec * lc_id_dylinker)828 uint32_t DynamicLoaderMacOSXDYLD::ParseLoadCommands(const DataExtractor &data,
829 ImageInfo &dylib_info,
830 FileSpec *lc_id_dylinker) {
831 lldb::offset_t offset = 0;
832 uint32_t cmd_idx;
833 Segment segment;
834 dylib_info.Clear(true);
835
836 for (cmd_idx = 0; cmd_idx < dylib_info.header.ncmds; cmd_idx++) {
837 // Clear out any load command specific data from DYLIB_INFO since we are
838 // about to read it.
839
840 if (data.ValidOffsetForDataOfSize(offset,
841 sizeof(llvm::MachO::load_command))) {
842 llvm::MachO::load_command load_cmd;
843 lldb::offset_t load_cmd_offset = offset;
844 load_cmd.cmd = data.GetU32(&offset);
845 load_cmd.cmdsize = data.GetU32(&offset);
846 switch (load_cmd.cmd) {
847 case llvm::MachO::LC_SEGMENT: {
848 segment.name.SetTrimmedCStringWithLength(
849 (const char *)data.GetData(&offset, 16), 16);
850 // We are putting 4 uint32_t values 4 uint64_t values so we have to use
851 // multiple 32 bit gets below.
852 segment.vmaddr = data.GetU32(&offset);
853 segment.vmsize = data.GetU32(&offset);
854 segment.fileoff = data.GetU32(&offset);
855 segment.filesize = data.GetU32(&offset);
856 // Extract maxprot, initprot, nsects and flags all at once
857 data.GetU32(&offset, &segment.maxprot, 4);
858 dylib_info.segments.push_back(segment);
859 } break;
860
861 case llvm::MachO::LC_SEGMENT_64: {
862 segment.name.SetTrimmedCStringWithLength(
863 (const char *)data.GetData(&offset, 16), 16);
864 // Extract vmaddr, vmsize, fileoff, and filesize all at once
865 data.GetU64(&offset, &segment.vmaddr, 4);
866 // Extract maxprot, initprot, nsects and flags all at once
867 data.GetU32(&offset, &segment.maxprot, 4);
868 dylib_info.segments.push_back(segment);
869 } break;
870
871 case llvm::MachO::LC_ID_DYLINKER:
872 if (lc_id_dylinker) {
873 const lldb::offset_t name_offset =
874 load_cmd_offset + data.GetU32(&offset);
875 const char *path = data.PeekCStr(name_offset);
876 lc_id_dylinker->SetFile(path, FileSpec::Style::native);
877 FileSystem::Instance().Resolve(*lc_id_dylinker);
878 }
879 break;
880
881 case llvm::MachO::LC_UUID:
882 dylib_info.uuid = UUID::fromOptionalData(data.GetData(&offset, 16), 16);
883 break;
884
885 default:
886 break;
887 }
888 // Set offset to be the beginning of the next load command.
889 offset = load_cmd_offset + load_cmd.cmdsize;
890 }
891 }
892
893 // All sections listed in the dyld image info structure will all either be
894 // fixed up already, or they will all be off by a single slide amount that is
895 // determined by finding the first segment that is at file offset zero which
896 // also has bytes (a file size that is greater than zero) in the object file.
897
898 // Determine the slide amount (if any)
899 const size_t num_sections = dylib_info.segments.size();
900 for (size_t i = 0; i < num_sections; ++i) {
901 // Iterate through the object file sections to find the first section that
902 // starts of file offset zero and that has bytes in the file...
903 if ((dylib_info.segments[i].fileoff == 0 &&
904 dylib_info.segments[i].filesize > 0) ||
905 (dylib_info.segments[i].name == "__TEXT")) {
906 dylib_info.slide = dylib_info.address - dylib_info.segments[i].vmaddr;
907 // We have found the slide amount, so we can exit this for loop.
908 break;
909 }
910 }
911 return cmd_idx;
912 }
913
914 // Read the mach_header and load commands for each image that the
915 // _dyld_all_image_infos structure points to and cache the results.
916
UpdateImageInfosHeaderAndLoadCommands(ImageInfo::collection & image_infos,uint32_t infos_count,bool update_executable)917 void DynamicLoaderMacOSXDYLD::UpdateImageInfosHeaderAndLoadCommands(
918 ImageInfo::collection &image_infos, uint32_t infos_count,
919 bool update_executable) {
920 uint32_t exe_idx = UINT32_MAX;
921 // Read any UUID values that we can get
922 for (uint32_t i = 0; i < infos_count; i++) {
923 if (!image_infos[i].UUIDValid()) {
924 DataExtractor data; // Load command data
925 if (!ReadMachHeader(image_infos[i].address, &image_infos[i].header,
926 &data))
927 continue;
928
929 ParseLoadCommands(data, image_infos[i], nullptr);
930
931 if (image_infos[i].header.filetype == llvm::MachO::MH_EXECUTE)
932 exe_idx = i;
933 }
934 }
935
936 Target &target = m_process->GetTarget();
937
938 if (exe_idx < image_infos.size()) {
939 const bool can_create = true;
940 ModuleSP exe_module_sp(FindTargetModuleForImageInfo(image_infos[exe_idx],
941 can_create, nullptr));
942
943 if (exe_module_sp) {
944 UpdateImageLoadAddress(exe_module_sp.get(), image_infos[exe_idx]);
945
946 if (exe_module_sp.get() != target.GetExecutableModulePointer()) {
947 // Don't load dependent images since we are in dyld where we will know
948 // and find out about all images that are loaded. Also when setting the
949 // executable module, it will clear the targets module list, and if we
950 // have an in memory dyld module, it will get removed from the list so
951 // we will need to add it back after setting the executable module, so
952 // we first try and see if we already have a weak pointer to the dyld
953 // module, make it into a shared pointer, then add the executable, then
954 // re-add it back to make sure it is always in the list.
955 ModuleSP dyld_module_sp(GetDYLDModule());
956
957 m_process->GetTarget().SetExecutableModule(exe_module_sp,
958 eLoadDependentsNo);
959
960 if (dyld_module_sp) {
961 if (target.GetImages().AppendIfNeeded(dyld_module_sp)) {
962 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
963
964 // Also add it to the section list.
965 UpdateImageLoadAddress(dyld_module_sp.get(), m_dyld);
966 }
967 }
968 }
969 }
970 }
971 }
972
973 // Dump the _dyld_all_image_infos members and all current image infos that we
974 // have parsed to the file handle provided.
PutToLog(Log * log) const975 void DynamicLoaderMacOSXDYLD::PutToLog(Log *log) const {
976 if (log == nullptr)
977 return;
978
979 std::lock_guard<std::recursive_mutex> guard(m_mutex);
980 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
981 LLDB_LOGF(log,
982 "dyld_all_image_infos = { version=%d, count=%d, addr=0x%8.8" PRIx64
983 ", notify=0x%8.8" PRIx64 " }",
984 m_dyld_all_image_infos.version,
985 m_dyld_all_image_infos.dylib_info_count,
986 (uint64_t)m_dyld_all_image_infos.dylib_info_addr,
987 (uint64_t)m_dyld_all_image_infos.notification);
988 size_t i;
989 const size_t count = m_dyld_image_infos.size();
990 if (count > 0) {
991 log->PutCString("Loaded:");
992 for (i = 0; i < count; i++)
993 m_dyld_image_infos[i].PutToLog(log);
994 }
995 }
996
SetNotificationBreakpoint()997 bool DynamicLoaderMacOSXDYLD::SetNotificationBreakpoint() {
998 DEBUG_PRINTF("DynamicLoaderMacOSXDYLD::%s() process state = %s\n",
999 __FUNCTION__, StateAsCString(m_process->GetState()));
1000 if (m_break_id == LLDB_INVALID_BREAK_ID) {
1001 if (m_dyld_all_image_infos.notification != LLDB_INVALID_ADDRESS) {
1002 Address so_addr;
1003 // Set the notification breakpoint and install a breakpoint callback
1004 // function that will get called each time the breakpoint gets hit. We
1005 // will use this to track when shared libraries get loaded/unloaded.
1006 bool resolved = m_process->GetTarget().ResolveLoadAddress(
1007 m_dyld_all_image_infos.notification, so_addr);
1008 if (!resolved) {
1009 ModuleSP dyld_module_sp = GetDYLDModule();
1010 if (dyld_module_sp) {
1011 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
1012
1013 UpdateImageLoadAddress(dyld_module_sp.get(), m_dyld);
1014 resolved = m_process->GetTarget().ResolveLoadAddress(
1015 m_dyld_all_image_infos.notification, so_addr);
1016 }
1017 }
1018
1019 if (resolved) {
1020 Breakpoint *dyld_break =
1021 m_process->GetTarget().CreateBreakpoint(so_addr, true, false).get();
1022 dyld_break->SetCallback(DynamicLoaderMacOSXDYLD::NotifyBreakpointHit,
1023 this, true);
1024 dyld_break->SetBreakpointKind("shared-library-event");
1025 m_break_id = dyld_break->GetID();
1026 }
1027 }
1028 }
1029 return m_break_id != LLDB_INVALID_BREAK_ID;
1030 }
1031
CanLoadImage()1032 Status DynamicLoaderMacOSXDYLD::CanLoadImage() {
1033 Status error;
1034 // In order for us to tell if we can load a shared library we verify that the
1035 // dylib_info_addr isn't zero (which means no shared libraries have been set
1036 // yet, or dyld is currently mucking with the shared library list).
1037 if (ReadAllImageInfosStructure()) {
1038 // TODO: also check the _dyld_global_lock_held variable in
1039 // libSystem.B.dylib?
1040 // TODO: check the malloc lock?
1041 // TODO: check the objective C lock?
1042 if (m_dyld_all_image_infos.dylib_info_addr != 0)
1043 return error; // Success
1044 }
1045
1046 error.SetErrorString("unsafe to load or unload shared libraries");
1047 return error;
1048 }
1049
GetSharedCacheInformation(lldb::addr_t & base_address,UUID & uuid,LazyBool & using_shared_cache,LazyBool & private_shared_cache)1050 bool DynamicLoaderMacOSXDYLD::GetSharedCacheInformation(
1051 lldb::addr_t &base_address, UUID &uuid, LazyBool &using_shared_cache,
1052 LazyBool &private_shared_cache) {
1053 base_address = LLDB_INVALID_ADDRESS;
1054 uuid.Clear();
1055 using_shared_cache = eLazyBoolCalculate;
1056 private_shared_cache = eLazyBoolCalculate;
1057
1058 if (m_process) {
1059 addr_t all_image_infos = m_process->GetImageInfoAddress();
1060
1061 // The address returned by GetImageInfoAddress may be the address of dyld
1062 // (don't want) or it may be the address of the dyld_all_image_infos
1063 // structure (want). The first four bytes will be either the version field
1064 // (all_image_infos) or a Mach-O file magic constant. Version 13 and higher
1065 // of dyld_all_image_infos is required to get the sharedCacheUUID field.
1066
1067 Status err;
1068 uint32_t version_or_magic =
1069 m_process->ReadUnsignedIntegerFromMemory(all_image_infos, 4, -1, err);
1070 if (version_or_magic != static_cast<uint32_t>(-1) &&
1071 version_or_magic != llvm::MachO::MH_MAGIC &&
1072 version_or_magic != llvm::MachO::MH_CIGAM &&
1073 version_or_magic != llvm::MachO::MH_MAGIC_64 &&
1074 version_or_magic != llvm::MachO::MH_CIGAM_64 &&
1075 version_or_magic >= 13) {
1076 addr_t sharedCacheUUID_address = LLDB_INVALID_ADDRESS;
1077 int wordsize = m_process->GetAddressByteSize();
1078 if (wordsize == 8) {
1079 sharedCacheUUID_address =
1080 all_image_infos + 160; // sharedCacheUUID <mach-o/dyld_images.h>
1081 }
1082 if (wordsize == 4) {
1083 sharedCacheUUID_address =
1084 all_image_infos + 84; // sharedCacheUUID <mach-o/dyld_images.h>
1085 }
1086 if (sharedCacheUUID_address != LLDB_INVALID_ADDRESS) {
1087 uuid_t shared_cache_uuid;
1088 if (m_process->ReadMemory(sharedCacheUUID_address, shared_cache_uuid,
1089 sizeof(uuid_t), err) == sizeof(uuid_t)) {
1090 uuid = UUID::fromOptionalData(shared_cache_uuid, 16);
1091 if (uuid.IsValid()) {
1092 using_shared_cache = eLazyBoolYes;
1093 }
1094 }
1095
1096 if (version_or_magic >= 15) {
1097 // The sharedCacheBaseAddress field is the next one in the
1098 // dyld_all_image_infos struct.
1099 addr_t sharedCacheBaseAddr_address = sharedCacheUUID_address + 16;
1100 Status error;
1101 base_address = m_process->ReadUnsignedIntegerFromMemory(
1102 sharedCacheBaseAddr_address, wordsize, LLDB_INVALID_ADDRESS,
1103 error);
1104 if (error.Fail())
1105 base_address = LLDB_INVALID_ADDRESS;
1106 }
1107
1108 return true;
1109 }
1110
1111 //
1112 // add
1113 // NB: sharedCacheBaseAddress is the next field in dyld_all_image_infos
1114 // after
1115 // sharedCacheUUID -- that is, 16 bytes after it, if we wanted to fetch
1116 // it.
1117 }
1118 }
1119 return false;
1120 }
1121
Initialize()1122 void DynamicLoaderMacOSXDYLD::Initialize() {
1123 PluginManager::RegisterPlugin(GetPluginNameStatic(),
1124 GetPluginDescriptionStatic(), CreateInstance);
1125 DynamicLoaderMacOS::Initialize();
1126 }
1127
Terminate()1128 void DynamicLoaderMacOSXDYLD::Terminate() {
1129 DynamicLoaderMacOS::Terminate();
1130 PluginManager::UnregisterPlugin(CreateInstance);
1131 }
1132
GetPluginNameStatic()1133 lldb_private::ConstString DynamicLoaderMacOSXDYLD::GetPluginNameStatic() {
1134 static ConstString g_name("macosx-dyld");
1135 return g_name;
1136 }
1137
GetPluginDescriptionStatic()1138 const char *DynamicLoaderMacOSXDYLD::GetPluginDescriptionStatic() {
1139 return "Dynamic loader plug-in that watches for shared library loads/unloads "
1140 "in MacOSX user processes.";
1141 }
1142
1143 // PluginInterface protocol
GetPluginName()1144 lldb_private::ConstString DynamicLoaderMacOSXDYLD::GetPluginName() {
1145 return GetPluginNameStatic();
1146 }
1147
GetPluginVersion()1148 uint32_t DynamicLoaderMacOSXDYLD::GetPluginVersion() { return 1; }
1149
AddrByteSize()1150 uint32_t DynamicLoaderMacOSXDYLD::AddrByteSize() {
1151 std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
1152
1153 switch (m_dyld.header.magic) {
1154 case llvm::MachO::MH_MAGIC:
1155 case llvm::MachO::MH_CIGAM:
1156 return 4;
1157
1158 case llvm::MachO::MH_MAGIC_64:
1159 case llvm::MachO::MH_CIGAM_64:
1160 return 8;
1161
1162 default:
1163 break;
1164 }
1165 return 0;
1166 }
1167
GetByteOrderFromMagic(uint32_t magic)1168 lldb::ByteOrder DynamicLoaderMacOSXDYLD::GetByteOrderFromMagic(uint32_t magic) {
1169 switch (magic) {
1170 case llvm::MachO::MH_MAGIC:
1171 case llvm::MachO::MH_MAGIC_64:
1172 return endian::InlHostByteOrder();
1173
1174 case llvm::MachO::MH_CIGAM:
1175 case llvm::MachO::MH_CIGAM_64:
1176 if (endian::InlHostByteOrder() == lldb::eByteOrderBig)
1177 return lldb::eByteOrderLittle;
1178 else
1179 return lldb::eByteOrderBig;
1180
1181 default:
1182 break;
1183 }
1184 return lldb::eByteOrderInvalid;
1185 }
1186