Add a new DynamicLoader plugin that uses SPI that are in development
for the fall (northern hemisphere) 2016 Darwin platforms to learn
about loaded images, instead of reading dyld internal data structures.
These new SPI don't exist on older releases, and new packets are
needed from debugserver to use them (those changes are already committed).
I had to change the minimum deployment target for debugserver in the xcode
project file to macOS 10.10 so that debugserver will use the
[[NSProcessInfo processInfo] operatingSystemVersion]
call in MachProcess::GetOSVersionNumbers to get the operarting system
version # -- this API is only available in macOS 10.10 and newer
("OS X Yosemite", released Oct 2014). If we have many people building
llvm.org lldb on older systems still, we can back off on this for the
llvm.org sources.
There should be no change in behavior with this commit, either to
older darwin systems or newer darwin systems.
For now the new DynamicLoader plugin is never activated - I'm forcing
the old plugin to be used in DynamicLoaderDarwin::UseDYLDSPI.
I'll remove that unconditional use of the old plugin soon, so the
newer plugin is used on the newest Darwin platforms.
<rdar://problem/25251243>
llvm-svn: 276254
diff --git a/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp
new file mode 100644
index 0000000..bc1cc62
--- /dev/null
+++ b/lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.cpp
@@ -0,0 +1,528 @@
+//===-- 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();
+ }
+ }
+ }
+ 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;
+}