529 lines
18 KiB
C++
529 lines
18 KiB
C++
//===-- 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;
|
|
}
|