| //===-- DynamicLoaderMacOS.cpp -----------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/Breakpoint/StoppointCallbackContext.h" |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/Log.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Core/Section.h" |
| #include "lldb/Core/State.h" |
| #include "lldb/Symbol/ClangASTContext.h" |
| #include "lldb/Symbol/SymbolVendor.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Target/ABI.h" |
| #include "lldb/Target/Target.h" |
| #include "lldb/Target/Thread.h" |
| #include "lldb/Target/StackFrame.h" |
| |
| #include "DynamicLoaderMacOS.h" |
| #include "DynamicLoaderDarwin.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| |
| //---------------------------------------------------------------------- |
| // Create an instance of this class. This function is filled into |
| // the plugin info class that gets handed out by the plugin factory and |
| // allows the lldb to instantiate an instance of this class. |
| //---------------------------------------------------------------------- |
| DynamicLoader * |
| DynamicLoaderMacOS::CreateInstance (Process* process, bool force) |
| { |
| bool create = force; |
| if (!create) |
| { |
| create = true; |
| Module* exe_module = process->GetTarget().GetExecutableModulePointer(); |
| if (exe_module) |
| { |
| ObjectFile *object_file = exe_module->GetObjectFile(); |
| if (object_file) |
| { |
| create = (object_file->GetStrata() == ObjectFile::eStrataUser); |
| } |
| } |
| |
| if (create) |
| { |
| const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple(); |
| switch (triple_ref.getOS()) |
| { |
| case llvm::Triple::Darwin: |
| case llvm::Triple::MacOSX: |
| case llvm::Triple::IOS: |
| case llvm::Triple::TvOS: |
| case llvm::Triple::WatchOS: |
| create = triple_ref.getVendor() == llvm::Triple::Apple; |
| break; |
| default: |
| create = false; |
| break; |
| } |
| } |
| } |
| |
| if (UseDYLDSPI (process) == false) |
| { |
| create = false; |
| } |
| |
| if (create) |
| return new DynamicLoaderMacOS (process); |
| return NULL; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Constructor |
| //---------------------------------------------------------------------- |
| DynamicLoaderMacOS::DynamicLoaderMacOS (Process* process) : |
| DynamicLoaderDarwin(process), |
| m_image_infos_stop_id (UINT32_MAX), |
| m_break_id(LLDB_INVALID_BREAK_ID), |
| m_mutex() |
| { |
| } |
| |
| //---------------------------------------------------------------------- |
| // Destructor |
| //---------------------------------------------------------------------- |
| DynamicLoaderMacOS::~DynamicLoaderMacOS() |
| { |
| if (LLDB_BREAK_ID_IS_VALID(m_break_id)) |
| m_process->GetTarget().RemoveBreakpointByID (m_break_id); |
| } |
| |
| bool |
| DynamicLoaderMacOS::ProcessDidExec () |
| { |
| std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex()); |
| bool did_exec = false; |
| if (m_process) |
| { |
| // If we are stopped after an exec, we will have only one thread... |
| if (m_process->GetThreadList().GetSize() == 1) |
| { |
| // See if we are stopped at '_dyld_start' |
| ThreadSP thread_sp (m_process->GetThreadList().GetThreadAtIndex(0)); |
| if (thread_sp) |
| { |
| lldb::StackFrameSP frame_sp (thread_sp->GetStackFrameAtIndex(0)); |
| if (frame_sp) |
| { |
| const Symbol *symbol = frame_sp->GetSymbolContext(eSymbolContextSymbol).symbol; |
| if (symbol) |
| { |
| if (symbol->GetName() == ConstString("_dyld_start")) |
| did_exec = true; |
| } |
| } |
| } |
| |
| } |
| } |
| |
| if (did_exec) |
| { |
| m_libpthread_module_wp.reset(); |
| m_pthread_getspecific_addr.Clear(); |
| } |
| return did_exec; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Clear out the state of this class. |
| //---------------------------------------------------------------------- |
| void |
| DynamicLoaderMacOS::DoClear () |
| { |
| std::lock_guard<std::recursive_mutex> guard(m_mutex); |
| |
| if (LLDB_BREAK_ID_IS_VALID(m_break_id)) |
| m_process->GetTarget().RemoveBreakpointByID (m_break_id); |
| |
| m_break_id = LLDB_INVALID_BREAK_ID; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Check if we have found DYLD yet |
| //---------------------------------------------------------------------- |
| bool |
| DynamicLoaderMacOS::DidSetNotificationBreakpoint() |
| { |
| return LLDB_BREAK_ID_IS_VALID (m_break_id); |
| } |
| |
| void |
| DynamicLoaderMacOS::ClearNotificationBreakpoint () |
| { |
| if (LLDB_BREAK_ID_IS_VALID (m_break_id)) |
| { |
| m_process->GetTarget().RemoveBreakpointByID (m_break_id); |
| } |
| } |
| |
| //---------------------------------------------------------------------- |
| // Try and figure out where dyld is by first asking the Process |
| // if it knows (which currently calls down in the lldb::Process |
| // to get the DYLD info (available on SnowLeopard only). If that fails, |
| // then check in the default addresses. |
| //---------------------------------------------------------------------- |
| void |
| DynamicLoaderMacOS::DoInitialImageFetch() |
| { |
| Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER)); |
| |
| StructuredData::ObjectSP all_image_info_json_sp (m_process->GetLoadedDynamicLibrariesInfos ()); |
| ImageInfo::collection image_infos; |
| if (all_image_info_json_sp.get() |
| && all_image_info_json_sp->GetAsDictionary() |
| && all_image_info_json_sp->GetAsDictionary()->HasKey("images") |
| && all_image_info_json_sp->GetAsDictionary()->GetValueForKey("images")->GetAsArray()) |
| { |
| if (JSONImageInformationIntoImageInfo (all_image_info_json_sp, image_infos)) |
| { |
| if (log) |
| log->Printf ("Initial module fetch: Adding %" PRId64 " modules.\n", (uint64_t) image_infos.size()); |
| |
| UpdateSpecialBinariesFromNewImageInfos (image_infos); |
| AddModulesUsingImageInfos (image_infos); |
| } |
| } |
| |
| m_dyld_image_infos_stop_id = m_process->GetStopID(); |
| } |
| |
| bool |
| DynamicLoaderMacOS::NeedToDoInitialImageFetch () |
| { |
| return true; |
| } |
| |
| //---------------------------------------------------------------------- |
| // Static callback function that gets called when our DYLD notification |
| // breakpoint gets hit. We update all of our image infos and then |
| // let our super class DynamicLoader class decide if we should stop |
| // or not (based on global preference). |
| //---------------------------------------------------------------------- |
| bool |
| DynamicLoaderMacOS::NotifyBreakpointHit (void *baton, |
| StoppointCallbackContext *context, |
| lldb::user_id_t break_id, |
| lldb::user_id_t break_loc_id) |
| { |
| // Let the event know that the images have changed |
| // DYLD passes three arguments to the notification breakpoint. |
| // Arg1: enum dyld_notify_mode mode - 0 = adding, 1 = removing, 2 = remove all |
| // Arg2: unsigned long icount - Number of shared libraries added/removed |
| // Arg3: uint64_t mach_headers[] - Array of load addresses of binaries added/removed |
| |
| DynamicLoaderMacOS* dyld_instance = (DynamicLoaderMacOS*) baton; |
| |
| ExecutionContext exe_ctx (context->exe_ctx_ref); |
| Process *process = exe_ctx.GetProcessPtr(); |
| |
| // This is a sanity check just in case this dyld_instance is an old dyld plugin's breakpoint still lying around. |
| if (process != dyld_instance->m_process) |
| return false; |
| |
| if (dyld_instance->m_image_infos_stop_id != UINT32_MAX |
| && process->GetStopID() < dyld_instance->m_image_infos_stop_id) |
| { |
| return false; |
| } |
| |
| const lldb::ABISP &abi = process->GetABI(); |
| if (abi) |
| { |
| // Build up the value array to store the three arguments given above, then get the values from the ABI: |
| |
| ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext(); |
| ValueList argument_values; |
| |
| Value mode_value; // enum dyld_notify_mode { dyld_notify_adding=0, dyld_notify_removing=1, dyld_notify_remove_all=2 }; |
| Value count_value; // unsigned long count |
| Value headers_value; // uint64_t machHeaders[] (aka void*) |
| |
| CompilerType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); |
| CompilerType clang_uint32_type = clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint, 32); |
| CompilerType clang_uint64_type = clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingUint, 32); |
| |
| mode_value.SetValueType (Value::eValueTypeScalar); |
| mode_value.SetCompilerType (clang_uint32_type); |
| |
| if (process->GetTarget().GetArchitecture().GetAddressByteSize() == 4) |
| { |
| count_value.SetValueType (Value::eValueTypeScalar); |
| count_value.SetCompilerType (clang_uint32_type); |
| } |
| else |
| { |
| count_value.SetValueType (Value::eValueTypeScalar); |
| count_value.SetCompilerType (clang_uint64_type); |
| } |
| |
| headers_value.SetValueType (Value::eValueTypeScalar); |
| headers_value.SetCompilerType (clang_void_ptr_type); |
| |
| argument_values.PushValue (mode_value); |
| argument_values.PushValue (count_value); |
| argument_values.PushValue (headers_value); |
| |
| if (abi->GetArgumentValues (exe_ctx.GetThreadRef(), argument_values)) |
| { |
| uint32_t dyld_mode = argument_values.GetValueAtIndex(0)->GetScalar().UInt (-1); |
| if (dyld_mode != static_cast<uint32_t>(-1)) |
| { |
| // Okay the mode was right, now get the number of elements, and the array of new elements... |
| uint32_t image_infos_count = argument_values.GetValueAtIndex(1)->GetScalar().UInt (-1); |
| if (image_infos_count != static_cast<uint32_t>(-1)) |
| { |
| addr_t header_array = argument_values.GetValueAtIndex(2)->GetScalar().ULongLong(-1); |
| if (header_array != static_cast<uint64_t>(-1)) |
| { |
| std::vector<addr_t> image_load_addresses; |
| for (uint64_t i = 0; i < image_infos_count ; i++) |
| { |
| Error error; |
| addr_t addr = process->ReadUnsignedIntegerFromMemory (header_array + (8 * i), 8, LLDB_INVALID_ADDRESS, error); |
| if (addr != LLDB_INVALID_ADDRESS) |
| { |
| image_load_addresses.push_back (addr); |
| } |
| } |
| if (dyld_mode == 0) |
| { |
| // dyld_notify_adding |
| dyld_instance->AddBinaries (image_load_addresses); |
| } |
| else if (dyld_mode == 1) |
| { |
| // dyld_notify_removing |
| dyld_instance->UnloadImages (image_load_addresses); |
| } |
| else if (dyld_mode == 2) |
| { |
| // dyld_notify_remove_all |
| dyld_instance->UnloadAllImages (); |
| } |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| process->GetTarget().GetDebugger().GetAsyncErrorStream()->Printf("No ABI plugin located for triple %s -- shared libraries will not be registered!\n", process->GetTarget().GetArchitecture().GetTriple().getTriple().c_str()); |
| } |
| |
| // Return true to stop the target, false to just let the target run |
| return dyld_instance->GetStopWhenImagesChange(); |
| } |
| |
| void |
| DynamicLoaderMacOS::AddBinaries (const std::vector<lldb::addr_t> &load_addresses) |
| { |
| Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER)); |
| ImageInfo::collection image_infos; |
| |
| if (log) |
| log->Printf ("Adding %" PRId64 " modules.", (uint64_t) load_addresses.size()); |
| StructuredData::ObjectSP binaries_info_sp = m_process->GetLoadedDynamicLibrariesInfos (load_addresses); |
| if (binaries_info_sp.get() |
| && binaries_info_sp->GetAsDictionary() |
| && binaries_info_sp->GetAsDictionary()->HasKey("images") |
| && binaries_info_sp->GetAsDictionary()->GetValueForKey("images")->GetAsArray() |
| && binaries_info_sp->GetAsDictionary()->GetValueForKey("images")->GetAsArray()->GetSize() == load_addresses.size()) |
| { |
| if (JSONImageInformationIntoImageInfo (binaries_info_sp, image_infos)) |
| { |
| UpdateSpecialBinariesFromNewImageInfos (image_infos); |
| AddModulesUsingImageInfos (image_infos); |
| } |
| m_dyld_image_infos_stop_id = m_process->GetStopID(); |
| } |
| } |
| |
| |
| // Dump the _dyld_all_image_infos members and all current image infos |
| // that we have parsed to the file handle provided. |
| //---------------------------------------------------------------------- |
| void |
| DynamicLoaderMacOS::PutToLog(Log *log) const |
| { |
| if (log == NULL) |
| return; |
| } |
| |
| bool |
| DynamicLoaderMacOS::SetNotificationBreakpoint () |
| { |
| if (m_break_id == LLDB_INVALID_BREAK_ID) |
| { |
| ConstString g_symbol_name ("_dyld_debugger_notification"); |
| const Symbol *symbol = nullptr; |
| ModuleSP dyld_sp (GetDYLDModule()); |
| if (dyld_sp) |
| { |
| symbol = dyld_sp->FindFirstSymbolWithNameAndType (g_symbol_name, eSymbolTypeCode); |
| } |
| if (symbol && (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) |
| { |
| addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&m_process->GetTarget()); |
| if (symbol_address != LLDB_INVALID_ADDRESS) |
| { |
| bool internal = true; |
| bool hardware = false; |
| Breakpoint *breakpoint = m_process->GetTarget().CreateBreakpoint(symbol_address, internal, hardware).get(); |
| breakpoint->SetCallback (DynamicLoaderMacOS::NotifyBreakpointHit, this, true); |
| breakpoint->SetBreakpointKind ("shared-library-event"); |
| m_break_id = breakpoint->GetID(); |
| } |
| } |
| } |
| return m_break_id != LLDB_INVALID_BREAK_ID; |
| } |
| |
| |
| addr_t |
| DynamicLoaderMacOS::GetDyldLockVariableAddressFromModule (Module *module) |
| { |
| SymbolContext sc; |
| SymbolVendor *sym_vendor = module->GetSymbolVendor (); |
| Target &target = m_process->GetTarget (); |
| if (sym_vendor) |
| { |
| Symtab *symtab = sym_vendor->GetSymtab(); |
| if (symtab) |
| { |
| std::vector<uint32_t> match_indexes; |
| ConstString g_symbol_name ("_dyld_global_lock_held"); |
| uint32_t num_matches = 0; |
| num_matches = symtab->AppendSymbolIndexesWithName (g_symbol_name, match_indexes); |
| if (num_matches == 1) |
| { |
| Symbol *symbol = symtab->SymbolAtIndex (match_indexes[0]); |
| if (symbol && (symbol->ValueIsAddress() || symbol->GetAddressRef().IsValid())) |
| { |
| return symbol->GetAddressRef().GetOpcodeLoadAddress(&target); |
| } |
| } |
| } |
| } |
| return LLDB_INVALID_ADDRESS; |
| } |
| |
| // Look for this symbol: |
| // |
| // int __attribute__((visibility("hidden"))) _dyld_global_lock_held = 0; |
| // |
| // in libdyld.dylib. |
| Error |
| DynamicLoaderMacOS::CanLoadImage () |
| { |
| Error error; |
| addr_t symbol_address = LLDB_INVALID_ADDRESS; |
| Target &target = m_process->GetTarget (); |
| const ModuleList &target_modules = target.GetImages(); |
| std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex()); |
| const size_t num_modules = target_modules.GetSize(); |
| ConstString g_libdyld_name ("libdyld.dylib"); |
| |
| // Find any modules named "libdyld.dylib" and look for the symbol there first |
| for (size_t i = 0; i < num_modules; i++) |
| { |
| Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked (i); |
| if (module_pointer) |
| { |
| if (module_pointer->GetFileSpec().GetFilename() == g_libdyld_name) |
| { |
| symbol_address = GetDyldLockVariableAddressFromModule (module_pointer); |
| if (symbol_address != LLDB_INVALID_ADDRESS) |
| break; |
| } |
| } |
| } |
| |
| // Search through all modules looking for the symbol in them |
| if (symbol_address == LLDB_INVALID_ADDRESS) |
| { |
| for (size_t i = 0; i < num_modules; i++) |
| { |
| Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked (i); |
| if (module_pointer) |
| { |
| addr_t symbol_address = GetDyldLockVariableAddressFromModule (module_pointer); |
| if (symbol_address != LLDB_INVALID_ADDRESS) |
| break; |
| } |
| } |
| } |
| |
| // Default assumption is that it is OK to load images. |
| // Only say that we cannot load images if we find the symbol in libdyld and it indicates that |
| // we cannot. |
| |
| if (symbol_address != LLDB_INVALID_ADDRESS) |
| { |
| { |
| int lock_held = m_process->ReadUnsignedIntegerFromMemory (symbol_address, 4, 0, error); |
| if (lock_held != 0) |
| { |
| error.SetErrorToGenericError(); |
| } |
| } |
| } |
| else |
| { |
| // If we were unable to find _dyld_global_lock_held in any modules, or it is not loaded into |
| // memory yet, we may be at process startup (sitting at _dyld_start) - so we should not allow |
| // dlopen calls. |
| error.SetErrorToGenericError(); |
| } |
| return error; |
| } |
| |
| void |
| DynamicLoaderMacOS::Initialize() |
| { |
| PluginManager::RegisterPlugin (GetPluginNameStatic(), |
| GetPluginDescriptionStatic(), |
| CreateInstance); |
| } |
| |
| void |
| DynamicLoaderMacOS::Terminate() |
| { |
| PluginManager::UnregisterPlugin (CreateInstance); |
| } |
| |
| |
| lldb_private::ConstString |
| DynamicLoaderMacOS::GetPluginNameStatic() |
| { |
| static ConstString g_name("macos-dyld"); |
| return g_name; |
| } |
| |
| const char * |
| DynamicLoaderMacOS::GetPluginDescriptionStatic() |
| { |
| return "Dynamic loader plug-in that watches for shared library loads/unloads in MacOSX user processes."; |
| } |
| |
| |
| //------------------------------------------------------------------ |
| // PluginInterface protocol |
| //------------------------------------------------------------------ |
| lldb_private::ConstString |
| DynamicLoaderMacOS::GetPluginName() |
| { |
| return GetPluginNameStatic(); |
| } |
| |
| uint32_t |
| DynamicLoaderMacOS::GetPluginVersion() |
| { |
| return 1; |
| } |