1 //===-- DynamicLoaderMacOS.cpp -----------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Breakpoint/StoppointCallbackContext.h"
11 #include "lldb/Core/Debugger.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Core/Section.h"
15 #include "lldb/Symbol/ClangASTContext.h"
16 #include "lldb/Symbol/ObjectFile.h"
17 #include "lldb/Symbol/SymbolVendor.h"
18 #include "lldb/Target/ABI.h"
19 #include "lldb/Target/StackFrame.h"
20 #include "lldb/Target/Target.h"
21 #include "lldb/Target/Thread.h"
22 #include "lldb/Utility/Log.h"
23 #include "lldb/Utility/State.h"
24 
25 #include "DynamicLoaderDarwin.h"
26 #include "DynamicLoaderMacOS.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 //----------------------------------------------------------------------
32 // Create an instance of this class. This function is filled into the plugin
33 // info class that gets handed out by the plugin factory and allows the lldb to
34 // instantiate an instance of this class.
35 //----------------------------------------------------------------------
36 DynamicLoader *DynamicLoaderMacOS::CreateInstance(Process *process,
37                                                   bool force) {
38   bool create = force;
39   if (!create) {
40     create = true;
41     Module *exe_module = process->GetTarget().GetExecutableModulePointer();
42     if (exe_module) {
43       ObjectFile *object_file = exe_module->GetObjectFile();
44       if (object_file) {
45         create = (object_file->GetStrata() == ObjectFile::eStrataUser);
46       }
47     }
48 
49     if (create) {
50       const llvm::Triple &triple_ref =
51           process->GetTarget().GetArchitecture().GetTriple();
52       switch (triple_ref.getOS()) {
53       case llvm::Triple::Darwin:
54       case llvm::Triple::MacOSX:
55       case llvm::Triple::IOS:
56       case llvm::Triple::TvOS:
57       case llvm::Triple::WatchOS:
58       // NEED_BRIDGEOS_TRIPLE case llvm::Triple::BridgeOS:
59         create = triple_ref.getVendor() == llvm::Triple::Apple;
60         break;
61       default:
62         create = false;
63         break;
64       }
65     }
66   }
67 
68   if (UseDYLDSPI(process) == false) {
69     create = false;
70   }
71 
72   if (create)
73     return new DynamicLoaderMacOS(process);
74   return NULL;
75 }
76 
77 //----------------------------------------------------------------------
78 // Constructor
79 //----------------------------------------------------------------------
80 DynamicLoaderMacOS::DynamicLoaderMacOS(Process *process)
81     : DynamicLoaderDarwin(process), m_image_infos_stop_id(UINT32_MAX),
82       m_break_id(LLDB_INVALID_BREAK_ID), m_mutex() {}
83 
84 //----------------------------------------------------------------------
85 // Destructor
86 //----------------------------------------------------------------------
87 DynamicLoaderMacOS::~DynamicLoaderMacOS() {
88   if (LLDB_BREAK_ID_IS_VALID(m_break_id))
89     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
90 }
91 
92 bool DynamicLoaderMacOS::ProcessDidExec() {
93   std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
94   bool did_exec = false;
95   if (m_process) {
96     // If we are stopped after an exec, we will have only one thread...
97     if (m_process->GetThreadList().GetSize() == 1) {
98       // See if we are stopped at '_dyld_start'
99       ThreadSP thread_sp(m_process->GetThreadList().GetThreadAtIndex(0));
100       if (thread_sp) {
101         lldb::StackFrameSP frame_sp(thread_sp->GetStackFrameAtIndex(0));
102         if (frame_sp) {
103           const Symbol *symbol =
104               frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol;
105           if (symbol) {
106             if (symbol->GetName() == ConstString("_dyld_start"))
107               did_exec = true;
108           }
109         }
110       }
111     }
112   }
113 
114   if (did_exec) {
115     m_libpthread_module_wp.reset();
116     m_pthread_getspecific_addr.Clear();
117   }
118   return did_exec;
119 }
120 
121 //----------------------------------------------------------------------
122 // Clear out the state of this class.
123 //----------------------------------------------------------------------
124 void DynamicLoaderMacOS::DoClear() {
125   std::lock_guard<std::recursive_mutex> guard(m_mutex);
126 
127   if (LLDB_BREAK_ID_IS_VALID(m_break_id))
128     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
129 
130   m_break_id = LLDB_INVALID_BREAK_ID;
131 }
132 
133 //----------------------------------------------------------------------
134 // Check if we have found DYLD yet
135 //----------------------------------------------------------------------
136 bool DynamicLoaderMacOS::DidSetNotificationBreakpoint() {
137   return LLDB_BREAK_ID_IS_VALID(m_break_id);
138 }
139 
140 void DynamicLoaderMacOS::ClearNotificationBreakpoint() {
141   if (LLDB_BREAK_ID_IS_VALID(m_break_id)) {
142     m_process->GetTarget().RemoveBreakpointByID(m_break_id);
143     m_break_id = LLDB_INVALID_BREAK_ID;
144   }
145 }
146 
147 //----------------------------------------------------------------------
148 // Try and figure out where dyld is by first asking the Process if it knows
149 // (which currently calls down in the lldb::Process to get the DYLD info
150 // (available on SnowLeopard only). If that fails, then check in the default
151 // addresses.
152 //----------------------------------------------------------------------
153 void DynamicLoaderMacOS::DoInitialImageFetch() {
154   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
155 
156   // Remove any binaries we pre-loaded in the Target before
157   // launching/attaching. If the same binaries are present in the process,
158   // we'll get them from the shared module cache, we won't need to re-load them
159   // from disk.
160   UnloadAllImages();
161 
162   StructuredData::ObjectSP all_image_info_json_sp(
163       m_process->GetLoadedDynamicLibrariesInfos());
164   ImageInfo::collection image_infos;
165   if (all_image_info_json_sp.get() &&
166       all_image_info_json_sp->GetAsDictionary() &&
167       all_image_info_json_sp->GetAsDictionary()->HasKey("images") &&
168       all_image_info_json_sp->GetAsDictionary()
169           ->GetValueForKey("images")
170           ->GetAsArray()) {
171     if (JSONImageInformationIntoImageInfo(all_image_info_json_sp,
172                                           image_infos)) {
173       if (log)
174         log->Printf("Initial module fetch:  Adding %" PRId64 " modules.\n",
175                     (uint64_t)image_infos.size());
176 
177       UpdateSpecialBinariesFromNewImageInfos(image_infos);
178       AddModulesUsingImageInfos(image_infos);
179     }
180   }
181 
182   m_dyld_image_infos_stop_id = m_process->GetStopID();
183 }
184 
185 bool DynamicLoaderMacOS::NeedToDoInitialImageFetch() { return true; }
186 
187 //----------------------------------------------------------------------
188 // Static callback function that gets called when our DYLD notification
189 // breakpoint gets hit. We update all of our image infos and then let our super
190 // class DynamicLoader class decide if we should stop or not (based on global
191 // preference).
192 //----------------------------------------------------------------------
193 bool DynamicLoaderMacOS::NotifyBreakpointHit(void *baton,
194                                              StoppointCallbackContext *context,
195                                              lldb::user_id_t break_id,
196                                              lldb::user_id_t break_loc_id) {
197   // Let the event know that the images have changed
198   // DYLD passes three arguments to the notification breakpoint.
199   // Arg1: enum dyld_notify_mode mode - 0 = adding, 1 = removing, 2 = remove
200   // all Arg2: unsigned long icount        - Number of shared libraries
201   // added/removed Arg3: uint64_t mach_headers[]     - Array of load addresses
202   // of binaries added/removed
203 
204   DynamicLoaderMacOS *dyld_instance = (DynamicLoaderMacOS *)baton;
205 
206   ExecutionContext exe_ctx(context->exe_ctx_ref);
207   Process *process = exe_ctx.GetProcessPtr();
208 
209   // This is a sanity check just in case this dyld_instance is an old dyld
210   // plugin's breakpoint still lying around.
211   if (process != dyld_instance->m_process)
212     return false;
213 
214   if (dyld_instance->m_image_infos_stop_id != UINT32_MAX &&
215       process->GetStopID() < dyld_instance->m_image_infos_stop_id) {
216     return false;
217   }
218 
219   const lldb::ABISP &abi = process->GetABI();
220   if (abi) {
221     // Build up the value array to store the three arguments given above, then
222     // get the values from the ABI:
223 
224     ClangASTContext *clang_ast_context =
225         process->GetTarget().GetScratchClangASTContext();
226     ValueList argument_values;
227 
228     Value mode_value;    // enum dyld_notify_mode { dyld_notify_adding=0,
229                          // dyld_notify_removing=1, dyld_notify_remove_all=2 };
230     Value count_value;   // unsigned long count
231     Value headers_value; // uint64_t machHeaders[] (aka void*)
232 
233     CompilerType clang_void_ptr_type =
234         clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
235     CompilerType clang_uint32_type =
236         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
237             lldb::eEncodingUint, 32);
238     CompilerType clang_uint64_type =
239         clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
240             lldb::eEncodingUint, 32);
241 
242     mode_value.SetValueType(Value::eValueTypeScalar);
243     mode_value.SetCompilerType(clang_uint32_type);
244 
245     if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 4) {
246       count_value.SetValueType(Value::eValueTypeScalar);
247       count_value.SetCompilerType(clang_uint32_type);
248     } else {
249       count_value.SetValueType(Value::eValueTypeScalar);
250       count_value.SetCompilerType(clang_uint64_type);
251     }
252 
253     headers_value.SetValueType(Value::eValueTypeScalar);
254     headers_value.SetCompilerType(clang_void_ptr_type);
255 
256     argument_values.PushValue(mode_value);
257     argument_values.PushValue(count_value);
258     argument_values.PushValue(headers_value);
259 
260     if (abi->GetArgumentValues(exe_ctx.GetThreadRef(), argument_values)) {
261       uint32_t dyld_mode =
262           argument_values.GetValueAtIndex(0)->GetScalar().UInt(-1);
263       if (dyld_mode != static_cast<uint32_t>(-1)) {
264         // Okay the mode was right, now get the number of elements, and the
265         // array of new elements...
266         uint32_t image_infos_count =
267             argument_values.GetValueAtIndex(1)->GetScalar().UInt(-1);
268         if (image_infos_count != static_cast<uint32_t>(-1)) {
269           addr_t header_array =
270               argument_values.GetValueAtIndex(2)->GetScalar().ULongLong(-1);
271           if (header_array != static_cast<uint64_t>(-1)) {
272             std::vector<addr_t> image_load_addresses;
273             for (uint64_t i = 0; i < image_infos_count; i++) {
274               Status error;
275               addr_t addr = process->ReadUnsignedIntegerFromMemory(
276                   header_array + (8 * i), 8, LLDB_INVALID_ADDRESS, error);
277               if (addr != LLDB_INVALID_ADDRESS) {
278                 image_load_addresses.push_back(addr);
279               }
280             }
281             if (dyld_mode == 0) {
282               // dyld_notify_adding
283               dyld_instance->AddBinaries(image_load_addresses);
284             } else if (dyld_mode == 1) {
285               // dyld_notify_removing
286               dyld_instance->UnloadImages(image_load_addresses);
287             } else if (dyld_mode == 2) {
288               // dyld_notify_remove_all
289               dyld_instance->UnloadAllImages();
290             }
291           }
292         }
293       }
294     }
295   } else {
296     process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf(
297         "No ABI plugin located for triple %s -- shared libraries will not be "
298         "registered!\n",
299         process->GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
300   }
301 
302   // Return true to stop the target, false to just let the target run
303   return dyld_instance->GetStopWhenImagesChange();
304 }
305 
306 void DynamicLoaderMacOS::AddBinaries(
307     const std::vector<lldb::addr_t> &load_addresses) {
308   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
309   ImageInfo::collection image_infos;
310 
311   if (log)
312     log->Printf("Adding %" PRId64 " modules.", (uint64_t)load_addresses.size());
313   StructuredData::ObjectSP binaries_info_sp =
314       m_process->GetLoadedDynamicLibrariesInfos(load_addresses);
315   if (binaries_info_sp.get() && binaries_info_sp->GetAsDictionary() &&
316       binaries_info_sp->GetAsDictionary()->HasKey("images") &&
317       binaries_info_sp->GetAsDictionary()
318           ->GetValueForKey("images")
319           ->GetAsArray() &&
320       binaries_info_sp->GetAsDictionary()
321               ->GetValueForKey("images")
322               ->GetAsArray()
323               ->GetSize() == load_addresses.size()) {
324     if (JSONImageInformationIntoImageInfo(binaries_info_sp, image_infos)) {
325       UpdateSpecialBinariesFromNewImageInfos(image_infos);
326       AddModulesUsingImageInfos(image_infos);
327     }
328     m_dyld_image_infos_stop_id = m_process->GetStopID();
329   }
330 }
331 
332 // Dump the _dyld_all_image_infos members and all current image infos that we
333 // have parsed to the file handle provided.
334 //----------------------------------------------------------------------
335 void DynamicLoaderMacOS::PutToLog(Log *log) const {
336   if (log == NULL)
337     return;
338 }
339 
340 bool DynamicLoaderMacOS::SetNotificationBreakpoint() {
341   if (m_break_id == LLDB_INVALID_BREAK_ID) {
342     ConstString g_symbol_name("_dyld_debugger_notification");
343     const Symbol *symbol = nullptr;
344     ModuleSP dyld_sp(GetDYLDModule());
345     if (dyld_sp) {
346       symbol = dyld_sp->FindFirstSymbolWithNameAndType(g_symbol_name,
347                                                        eSymbolTypeCode);
348     }
349     if (symbol &&
350         (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
351       addr_t symbol_address =
352           symbol->GetAddressRef().GetOpcodeLoadAddress(&m_process->GetTarget());
353       if (symbol_address != LLDB_INVALID_ADDRESS) {
354         bool internal = true;
355         bool hardware = false;
356         Breakpoint *breakpoint =
357             m_process->GetTarget()
358                 .CreateBreakpoint(symbol_address, internal, hardware)
359                 .get();
360         breakpoint->SetCallback(DynamicLoaderMacOS::NotifyBreakpointHit, this,
361                                 true);
362         breakpoint->SetBreakpointKind("shared-library-event");
363         m_break_id = breakpoint->GetID();
364       }
365     }
366   }
367   return m_break_id != LLDB_INVALID_BREAK_ID;
368 }
369 
370 addr_t
371 DynamicLoaderMacOS::GetDyldLockVariableAddressFromModule(Module *module) {
372   SymbolContext sc;
373   SymbolVendor *sym_vendor = module->GetSymbolVendor();
374   Target &target = m_process->GetTarget();
375   if (sym_vendor) {
376     Symtab *symtab = sym_vendor->GetSymtab();
377     if (symtab) {
378       std::vector<uint32_t> match_indexes;
379       ConstString g_symbol_name("_dyld_global_lock_held");
380       uint32_t num_matches = 0;
381       num_matches =
382           symtab->AppendSymbolIndexesWithName(g_symbol_name, match_indexes);
383       if (num_matches == 1) {
384         Symbol *symbol = symtab->SymbolAtIndex(match_indexes[0]);
385         if (symbol &&
386             (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) {
387           return symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
388         }
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.
401 Status DynamicLoaderMacOS::CanLoadImage() {
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 
461 bool DynamicLoaderMacOS::GetSharedCacheInformation(
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) {
470     StructuredData::ObjectSP info = m_process->GetSharedCacheInfo();
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 =
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           false)
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 
506 void DynamicLoaderMacOS::Initialize() {
507   PluginManager::RegisterPlugin(GetPluginNameStatic(),
508                                 GetPluginDescriptionStatic(), CreateInstance);
509 }
510 
511 void DynamicLoaderMacOS::Terminate() {
512   PluginManager::UnregisterPlugin(CreateInstance);
513 }
514 
515 lldb_private::ConstString DynamicLoaderMacOS::GetPluginNameStatic() {
516   static ConstString g_name("macos-dyld");
517   return g_name;
518 }
519 
520 const char *DynamicLoaderMacOS::GetPluginDescriptionStatic() {
521   return "Dynamic loader plug-in that watches for shared library loads/unloads "
522          "in MacOSX user processes.";
523 }
524 
525 //------------------------------------------------------------------
526 // PluginInterface protocol
527 //------------------------------------------------------------------
528 lldb_private::ConstString DynamicLoaderMacOS::GetPluginName() {
529   return GetPluginNameStatic();
530 }
531 
532 uint32_t DynamicLoaderMacOS::GetPluginVersion() { return 1; }
533