#define __STDC_LIMIT_MACROS
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <sys/param.h>
#include <sys/mount.h>
#include <Availability.h>
#include <vector>
#include <map>
#include <algorithm>
#include <mach/mach.h>
#include <sys/time.h>
#include <sys/sysctl.h>
#include <mach/mach_traps.h> // for task_self_trap()
#include "mach-o/dyld_images.h"
#include "mach-o/dyld.h"
#include "mach-o/dyld_priv.h"
#include "ImageLoader.h"
#include "dyld.h"
#include "dyldLibSystemInterface.h"
#undef _POSIX_C_SOURCE
#include "dlfcn.h"
extern "C" void __Unwind_SjLj_SetThreadKey(pthread_key_t key);
extern void addImagesToAllImages(uint32_t infoCount, const dyld_image_info info[]);
#if __IPHONE_OS_VERSION_MIN_REQUIRED
#define DEPRECATED_APIS_SUPPORTED 0
#else
#define DEPRECATED_APIS_SUPPORTED 1
#endif
#if DEPRECATED_APIS_SUPPORTED
static char sLastErrorFilePath[1024];
static NSLinkEditErrors sLastErrorFileCode;
static int sLastErrorNo;
#endif
#define OLD_LIBSYSTEM_SUPPORT (__i386__)
static void _dyld_make_delayed_module_initializer_calls();
static void registerThreadHelpers(const dyld::LibSystemHelpers*);
#if DEPRECATED_APIS_SUPPORTED
static void _dyld_install_handlers(void* undefined, void* multiple, void* linkEdit);
#if OLD_LIBSYSTEM_SUPPORT
static NSModule _dyld_link_module(NSObjectFileImage object_addr, size_t object_size, const char* moduleName, uint32_t options);
#endif
static void _dyld_register_binding_handler(void * (*)(const char *, const char *, void *), ImageLoader::BindingOptions);
static bool NSMakePrivateModulePublic(NSModule module);
static void _dyld_call_module_initializers_for_dylib(const struct mach_header* mh_dylib_header);
static void client_dyld_lookup_and_bind(const char* symbolName, void** address, NSModule* module);
static bool client_NSIsSymbolNameDefined(const char* symbolName);
#endif // DEPRECATED_APIS_SUPPORTED
#if !__arm__
static bool client_dyld_find_unwind_sections(void* addr, dyld_unwind_sections* info);
#endif
static void unimplemented()
{
dyld::halt("unimplemented dyld function\n");
}
struct dyld_func {
const char* name;
void* implementation;
};
static struct dyld_func dyld_funcs[] = {
{"__dyld_register_func_for_add_image", (void*)_dyld_register_func_for_add_image },
{"__dyld_register_func_for_remove_image", (void*)_dyld_register_func_for_remove_image },
{"__dyld_dladdr", (void*)dladdr },
{"__dyld_dlclose", (void*)dlclose },
{"__dyld_dlerror", (void*)dlerror },
{"__dyld_dlopen", (void*)dlopen },
{"__dyld_dlsym", (void*)dlsym },
{"__dyld_dlopen_preflight", (void*)dlopen_preflight },
{"__dyld_image_count", (void*)_dyld_image_count },
{"__dyld_get_image_header", (void*)_dyld_get_image_header },
{"__dyld_get_image_vmaddr_slide", (void*)_dyld_get_image_vmaddr_slide },
{"__dyld_get_image_name", (void*)_dyld_get_image_name },
{"__dyld_get_image_slide", (void*)_dyld_get_image_slide },
{"__dyld__NSGetExecutablePath", (void*)_NSGetExecutablePath },
{"__dyld_dyld_register_image_state_change_handler", (void*)dyld_register_image_state_change_handler },
{"__dyld_register_thread_helpers", (void*)registerThreadHelpers },
{"__dyld_fork_child", (void*)_dyld_fork_child },
{"__dyld_moninit", (void*)_dyld_moninit },
{"__dyld_make_delayed_module_initializer_calls", (void*)_dyld_make_delayed_module_initializer_calls },
{"__dyld_get_all_image_infos", (void*)_dyld_get_all_image_infos },
#if !__arm__
{"__dyld_find_unwind_sections", (void*)client_dyld_find_unwind_sections },
#endif
#if __i386__ || __x86_64__ || __arm__
{"__dyld_fast_stub_entry", (void*)dyld::fastBindLazySymbol },
#endif
{"__dyld_image_path_containing_address", (void*)dyld_image_path_containing_address },
#if __IPHONE_OS_VERSION_MIN_REQUIRED
{"__dyld_shared_cache_some_image_overridden", (void*)dyld_shared_cache_some_image_overridden },
#endif
{"__dyld_process_is_restricted", (void*)dyld::processIsRestricted },
#if DEPRECATED_APIS_SUPPORTED
{"__dyld_get_image_header_containing_address", (void*)_dyld_get_image_header_containing_address },
{"__dyld_lookup_and_bind", (void*)client_dyld_lookup_and_bind },
{"__dyld_lookup_and_bind_with_hint", (void*)_dyld_lookup_and_bind_with_hint },
{"__dyld_lookup_and_bind_fully", (void*)_dyld_lookup_and_bind_fully },
{"__dyld_install_handlers", (void*)_dyld_install_handlers },
{"__dyld_link_edit_error", (void*)NSLinkEditError },
{"__dyld_unlink_module", (void*)NSUnLinkModule },
{"__dyld_bind_objc_module", (void*)_dyld_bind_objc_module },
{"__dyld_bind_fully_image_containing_address", (void*)_dyld_bind_fully_image_containing_address },
{"__dyld_image_containing_address", (void*)_dyld_image_containing_address },
{"__dyld_register_binding_handler", (void*)_dyld_register_binding_handler },
{"__dyld_NSNameOfSymbol", (void*)NSNameOfSymbol },
{"__dyld_NSAddressOfSymbol", (void*)NSAddressOfSymbol },
{"__dyld_NSModuleForSymbol", (void*)NSModuleForSymbol },
{"__dyld_NSLookupAndBindSymbol", (void*)NSLookupAndBindSymbol },
{"__dyld_NSLookupAndBindSymbolWithHint", (void*)NSLookupAndBindSymbolWithHint },
{"__dyld_NSLookupSymbolInModule", (void*)NSLookupSymbolInModule},
{"__dyld_NSLookupSymbolInImage", (void*)NSLookupSymbolInImage},
{"__dyld_NSMakePrivateModulePublic", (void*)NSMakePrivateModulePublic},
{"__dyld_NSIsSymbolNameDefined", (void*)client_NSIsSymbolNameDefined},
{"__dyld_NSIsSymbolNameDefinedWithHint", (void*)NSIsSymbolNameDefinedWithHint },
{"__dyld_NSIsSymbolNameDefinedInImage", (void*)NSIsSymbolNameDefinedInImage},
{"__dyld_NSNameOfModule", (void*)NSNameOfModule },
{"__dyld_NSLibraryNameForModule", (void*)NSLibraryNameForModule },
{"__dyld_NSAddLibrary", (void*)NSAddLibrary },
{"__dyld_NSAddLibraryWithSearching", (void*)NSAddLibraryWithSearching },
{"__dyld_NSAddImage", (void*)NSAddImage },
{"__dyld_launched_prebound", (void*)_dyld_launched_prebound },
{"__dyld_all_twolevel_modules_prebound", (void*)_dyld_all_twolevel_modules_prebound },
{"__dyld_call_module_initializers_for_dylib", (void*)_dyld_call_module_initializers_for_dylib },
{"__dyld_NSCreateObjectFileImageFromFile", (void*)NSCreateObjectFileImageFromFile },
{"__dyld_NSCreateObjectFileImageFromMemory", (void*)NSCreateObjectFileImageFromMemory },
{"__dyld_NSDestroyObjectFileImage", (void*)NSDestroyObjectFileImage },
{"__dyld_NSLinkModule", (void*)NSLinkModule },
{"__dyld_NSHasModInitObjectFileImage", (void*)NSHasModInitObjectFileImage },
{"__dyld_NSSymbolDefinitionCountInObjectFileImage", (void*)NSSymbolDefinitionCountInObjectFileImage },
{"__dyld_NSSymbolDefinitionNameInObjectFileImage", (void*)NSSymbolDefinitionNameInObjectFileImage },
{"__dyld_NSIsSymbolDefinedInObjectFileImage", (void*)NSIsSymbolDefinedInObjectFileImage },
{"__dyld_NSSymbolReferenceNameInObjectFileImage", (void*)NSSymbolReferenceNameInObjectFileImage },
{"__dyld_NSSymbolReferenceCountInObjectFileImage", (void*)NSSymbolReferenceCountInObjectFileImage },
{"__dyld_NSGetSectionDataInObjectFileImage", (void*)NSGetSectionDataInObjectFileImage },
#if OLD_LIBSYSTEM_SUPPORT
{"__dyld_link_module", (void*)_dyld_link_module },
#endif
#endif //DEPRECATED_APIS_SUPPORTED
{NULL, 0}
};
#if DEPRECATED_APIS_SUPPORTED
static void dyldAPIhalt(const char* apiName, const char* errorMsg)
{
dyld::log("dyld: %s() error\n", apiName);
dyld::halt(errorMsg);
}
inline NSSymbol SymbolToNSSymbol(const ImageLoader::Symbol* sym)
{
return (NSSymbol)sym;
}
inline const ImageLoader::Symbol* NSSymbolToSymbol(NSSymbol sym)
{
return (const ImageLoader::Symbol*)sym;
}
inline NSModule ImageLoaderToNSModule(const ImageLoader* image)
{
return (NSModule)image;
}
inline ImageLoader* NSModuleToImageLoader(NSModule module)
{
ImageLoader* image = (ImageLoader*)module;
if ( dyld::validImage(image) )
return image;
return NULL;
}
struct __NSObjectFileImage
{
ImageLoader* image;
const void* imageBaseAddress; size_t imageLength; };
VECTOR_NEVER_DESTRUCTED(NSObjectFileImage);
static std::vector<NSObjectFileImage> sObjectFileImages;
static void setLastError(NSLinkEditErrors code, int errnum, const char* file, const char* message)
{
dyld::setErrorMessage(message);
strncpy(sLastErrorFilePath, file, 1024);
sLastErrorFilePath[1023] = '\0';
sLastErrorFileCode = code;
sLastErrorNo = errnum;
}
#endif // DEPRECATED_APIS_SUPPORTED
int _NSGetExecutablePath(char* buf, uint32_t *bufsize)
{
if ( dyld::gLogAPIs )
dyld::log("%s(...)\n", __func__);
const char* exePath = dyld::getExecutablePath();
if(*bufsize < strlen(exePath) + 1){
*bufsize = strlen(exePath) + 1;
return -1;
}
strcpy(buf, exePath);
return 0;
}
uint32_t _dyld_image_count(void)
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
return dyld::getImageCount();
}
const struct mach_header* _dyld_get_image_header(uint32_t image_index)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%u)\n", __func__, image_index);
ImageLoader* image = dyld::getIndexedImage(image_index);
if ( image != NULL )
return (struct mach_header*)image->machHeader();
else
return NULL;
}
intptr_t _dyld_get_image_vmaddr_slide(uint32_t image_index)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%u)\n", __func__, image_index);
ImageLoader* image = dyld::getIndexedImage(image_index);
if ( image != NULL )
return image->getSlide();
else
return 0;
}
intptr_t _dyld_get_image_slide(const struct mach_header* mh)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, mh);
ImageLoader* image = dyld::findImageByMachHeader(mh);
if ( image != NULL )
return image->getSlide();
else
return 0;
}
const char* _dyld_get_image_name(uint32_t image_index)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%u)\n", __func__, image_index);
ImageLoader* image = dyld::getIndexedImage(image_index);
if ( image != NULL )
return image->getRealPath();
else
return NULL;
}
const struct mach_header * _dyld_get_image_header_containing_address(const void* address)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, address);
ImageLoader* image = dyld::findImageContainingAddress(address);
if ( image != NULL )
return image->machHeader();
return NULL;
}
void _dyld_register_func_for_add_image(void (*func)(const struct mach_header *mh, intptr_t vmaddr_slide))
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, (void *)func);
dyld::registerAddCallback(func);
}
void _dyld_register_func_for_remove_image(void (*func)(const struct mach_header *mh, intptr_t vmaddr_slide))
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, (void *)func);
dyld::registerRemoveCallback(func);
}
static void _dyld_make_delayed_module_initializer_calls()
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
#if SUPPORT_OLD_CRT_INITIALIZATION
if ( dyld::gRunInitializersOldWay )
dyld::initializeMainExecutable();
#endif
}
#if DEPRECATED_APIS_SUPPORTED
static void _dyld_call_module_initializers_for_dylib(const struct mach_header* mh_dylib_header)
{
if ( dyld::gLogAPIs )
dyld::log("__initialize_Cplusplus()\n");
}
void _dyld_lookup_and_bind_fully(const char* symbolName, void** address, NSModule* module)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", %p, %p)\n", __func__, symbolName, address, module);
ImageLoader* image;
const ImageLoader::Symbol* sym;
dyld::clearErrorMessage();
if ( dyld::flatFindExportedSymbol(symbolName, &sym, (const ImageLoader**)&image) ) {
try {
image->bindAllLazyPointers(dyld::gLinkContext, true);
if ( address != NULL)
*address = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
if ( module != NULL)
*module = ImageLoaderToNSModule(image);
}
catch (const char* msg) {
dyldAPIhalt(__func__, msg);
}
}
else {
if ( address != NULL)
*address = NULL;
if ( module != NULL)
*module = NULL;
}
}
static void client_dyld_lookup_and_bind(const char* symbolName, void** address, NSModule* module)
{
if ( dyld::gLogAPIs )
dyld::log("_dyld_lookup_and_bind(\"%s\", %p, %p)\n", symbolName, address, module);
const ImageLoader* image;
const ImageLoader::Symbol* sym;
if ( dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {
if ( address != NULL)
*address = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
if ( module != NULL)
*module = ImageLoaderToNSModule(image);
}
else {
if ( address != NULL)
*address = NULL;
if ( module != NULL)
*module = NULL;
}
}
void _dyld_lookup_and_bind_with_hint(const char* symbolName, const char* library_name_hint, void** address, NSModule* module)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", \"%s\", %p, %p)\n", __func__, symbolName, library_name_hint, address, module);
const ImageLoader* image;
const ImageLoader::Symbol* sym;
if ( dyld::flatFindExportedSymbolWithHint(symbolName, library_name_hint, &sym, &image)
|| dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {
if ( address != NULL)
*address = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
if ( module != NULL)
*module = ImageLoaderToNSModule(image);
}
else {
if ( address != NULL)
*address = NULL;
if ( module != NULL)
*module = NULL;
}
}
NSSymbol NSLookupAndBindSymbol(const char *symbolName)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\")\n", __func__, symbolName);
const ImageLoader* image;
const ImageLoader::Symbol* sym;
if ( dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {
return SymbolToNSSymbol(sym);
}
return NULL;
}
NSSymbol NSLookupAndBindSymbolWithHint(const char* symbolName, const char* libraryNameHint)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", \"%s\")\n", __func__, symbolName, libraryNameHint);
const ImageLoader* image;
const ImageLoader::Symbol* sym;
bool found = dyld::flatFindExportedSymbolWithHint(symbolName, libraryNameHint, &sym, &image);
if ( ! found ) {
found = dyld::flatFindExportedSymbol(symbolName, &sym, &image);
}
if ( found )
return SymbolToNSSymbol(sym);
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", \"%s\") => NULL \n", __func__, symbolName, libraryNameHint);
return NULL;
}
static __attribute__((noinline))
const struct mach_header* addImage(void* callerAddress, const char* path, bool search, bool dontLoad, bool matchInstallName, bool abortOnError)
{
ImageLoader* image = NULL;
std::vector<const char*> rpathsFromCallerImage;
try {
dyld::clearErrorMessage();
ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
if ( callerImage != NULL )
callerImage->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
ImageLoader::RPathChain callersRPaths(NULL, &rpathsFromCallerImage);
if ( callerImage != dyld::mainExecutable() ) {
dyld::mainExecutable()->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
}
dyld::LoadContext context;
context.useSearchPaths = search;
context.useFallbackPaths = search;
context.useLdLibraryPath = false;
context.implicitRPath = false;
context.matchByInstallName = matchInstallName;
context.dontLoad = dontLoad;
context.mustBeBundle = false;
context.mustBeDylib = true;
context.canBePIE = false;
context.origin = callerImage != NULL ? callerImage->getPath() : NULL; context.rpath = &callersRPaths;
image = load(path, context);
if ( image != NULL ) {
if ( context.matchByInstallName )
image->setMatchInstallPath(true);
dyld::link(image, false, false, callersRPaths);
dyld::runInitializers(image);
image->setNeverUnload();
}
}
catch (const char* msg) {
dyld::garbageCollectImages();
if ( abortOnError) {
char pathMsg[strlen(msg)+strlen(path)+4];
strcpy(pathMsg, msg);
strcat(pathMsg, " ");
strcat(pathMsg, path);
dyldAPIhalt("NSAddImage", pathMsg);
}
setLastError(NSLinkEditOtherError, 0, path, msg);
free((void*)msg); image = NULL;
}
for(std::vector<const char*>::iterator it=rpathsFromCallerImage.begin(); it != rpathsFromCallerImage.end(); ++it) {
const char* str = *it;
free((void*)str);
}
if ( image == NULL )
return NULL;
else
return image->machHeader();
}
const struct mach_header* NSAddImage(const char* path, uint32_t options)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", 0x%08X)\n", __func__, path, options);
const bool dontLoad = ( (options & NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED) != 0 );
const bool search = ( (options & NSADDIMAGE_OPTION_WITH_SEARCHING) != 0 );
const bool matchInstallName = ( (options & NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME) != 0 );
const bool abortOnError = ( (options & (NSADDIMAGE_OPTION_RETURN_ON_ERROR|NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED)) == 0 );
void* callerAddress = __builtin_return_address(1); return addImage(callerAddress, path, search, dontLoad, matchInstallName, abortOnError);
}
bool NSAddLibrary(const char* path)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\")\n", __func__, path);
void* callerAddress = __builtin_return_address(1); return (addImage(callerAddress, path, false, false, false, false) != NULL);
}
bool NSAddLibraryWithSearching(const char* path)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\")\n", __func__, path);
void* callerAddress = __builtin_return_address(1); return (addImage(callerAddress, path, true, false, false, false) != NULL);
}
bool NSIsSymbolNameDefinedInImage(const struct mach_header* mh, const char* symbolName)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, \"%s\")\n", __func__, (void *)mh, symbolName);
ImageLoader* image = dyld::findImageByMachHeader(mh);
if ( image != NULL ) {
if ( image->findExportedSymbol(symbolName, true, NULL) != NULL)
return true;
}
return false;
}
NSSymbol NSLookupSymbolInImage(const struct mach_header* mh, const char* symbolName, uint32_t options)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, \"%s\", 0x%08X)\n", __func__, mh, symbolName, options);
const ImageLoader::Symbol* symbol = NULL;
dyld::clearErrorMessage();
ImageLoader* image = dyld::findImageByMachHeader(mh);
if ( image != NULL ) {
try {
if ( options & NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY ) {
image->bindAllLazyPointers(dyld::gLinkContext, true);
}
else if ( options & NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW ) {
image->bindAllLazyPointers(dyld::gLinkContext, false);
}
}
catch (const char* msg) {
if ( (options & NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) == 0 ) {
dyldAPIhalt(__func__, msg);
}
}
symbol = image->findExportedSymbol(symbolName, true, NULL);
}
if ( dyld::gLogAPIs && (symbol == NULL) )
dyld::log("%s(%p, \"%s\", 0x%08X) ==> NULL\n", __func__, mh, symbolName, options);
return SymbolToNSSymbol(symbol);
}
static bool client_NSIsSymbolNameDefined(const char* symbolName)
{
if ( dyld::gLogAPIs )
dyld::log("NSIsSymbolNameDefined(\"%s\")\n", symbolName);
const ImageLoader* image;
const ImageLoader::Symbol* sym;
return dyld::flatFindExportedSymbol(symbolName, &sym, &image);
}
bool NSIsSymbolNameDefinedWithHint(const char* symbolName, const char* libraryNameHint)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", \"%s\")\n", __func__, symbolName, libraryNameHint);
const ImageLoader* image;
const ImageLoader::Symbol* sym;
bool found = dyld::flatFindExportedSymbolWithHint(symbolName, libraryNameHint, &sym, &image);
if ( ! found ) {
found = dyld::flatFindExportedSymbol(symbolName, &sym, &image);
}
if ( !found && dyld::gLogAPIs )
dyld::log("%s(\"%s\", \"%s\") => false \n", __func__, symbolName, libraryNameHint);
return found;
}
const char* NSNameOfSymbol(NSSymbol symbol)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, (void *)symbol);
const char* result = NULL;
ImageLoader* image = dyld::findImageContainingSymbol(symbol);
if ( image != NULL )
result = image->getExportedSymbolName(NSSymbolToSymbol(symbol));
return result;
}
void* NSAddressOfSymbol(NSSymbol symbol)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, (void *)symbol);
if ( symbol == NULL )
return NULL;
void* result = NULL;
ImageLoader* image = dyld::findImageContainingSymbol(symbol);
if ( image != NULL )
result = (void*)image->getExportedSymbolAddress(NSSymbolToSymbol(symbol), dyld::gLinkContext);
return result;
}
NSModule NSModuleForSymbol(NSSymbol symbol)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, (void *)symbol);
NSModule result = NULL;
ImageLoader* image = dyld::findImageContainingSymbol(symbol);
if ( image != NULL )
result = ImageLoaderToNSModule(image);
return result;
}
bool _dyld_all_twolevel_modules_prebound(void)
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
return FALSE;
}
void _dyld_bind_objc_module(const void *objc_module)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, objc_module);
}
bool _dyld_bind_fully_image_containing_address(const void* address)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, address);
dyld::clearErrorMessage();
ImageLoader* image = dyld::findImageContainingAddress(address);
if ( image != NULL ) {
try {
image->bindAllLazyPointers(dyld::gLinkContext, true);
return true;
}
catch (const char* msg) {
dyldAPIhalt(__func__, msg);
}
}
return false;
}
bool _dyld_image_containing_address(const void* address)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, address);
ImageLoader *imageLoader = dyld::findImageContainingAddress(address);
return (NULL != imageLoader);
}
static NSObjectFileImage createObjectImageFile(ImageLoader* image, const void* address = NULL, size_t len=0)
{
NSObjectFileImage result = new __NSObjectFileImage();
result->image = image;
result->imageBaseAddress = address;
result->imageLength = len;
sObjectFileImages.push_back(result);
return result;
}
NSObjectFileImageReturnCode NSCreateObjectFileImageFromFile(const char* pathName, NSObjectFileImage *objectFileImage)
{
if ( dyld::gLogAPIs )
dyld::log("%s(\"%s\", ...)\n", __func__, pathName);
try {
void* callerAddress = __builtin_return_address(1); ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
dyld::LoadContext context;
context.useSearchPaths = false;
context.useFallbackPaths = false;
context.useLdLibraryPath = false;
context.implicitRPath = false;
context.matchByInstallName = false;
context.dontLoad = false;
context.mustBeBundle = true;
context.mustBeDylib = false;
context.canBePIE = false;
context.origin = callerImage != NULL ? callerImage->getPath() : NULL; context.rpath = NULL;
ImageLoader* image = dyld::load(pathName, context);
if ( image != NULL ) {
if ( !image->isBundle() ) {
return NSObjectFileImageInappropriateFile;
}
*objectFileImage = createObjectImageFile(image);
return NSObjectFileImageSuccess;
}
}
catch (const char* msg) {
dyld::garbageCollectImages();
free((void*)msg);
return NSObjectFileImageInappropriateFile;
}
return NSObjectFileImageFailure;
}
NSObjectFileImageReturnCode NSCreateObjectFileImageFromMemory(const void* address, size_t size, NSObjectFileImage *objectFileImage)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, %lu, %p)\n", __func__, address, size, objectFileImage);
try {
ImageLoader* image = dyld::loadFromMemory((const uint8_t*)address, size, NULL);
if ( ! image->isBundle() ) {
dyld::garbageCollectImages();
return NSObjectFileImageInappropriateFile;
}
if ( image != NULL ) {
*objectFileImage = createObjectImageFile(image, address, size);
return NSObjectFileImageSuccess;
}
}
catch (const char* msg) {
free((void*)msg);
dyld::garbageCollectImages();
}
return NSObjectFileImageFailure;
}
static bool validOFI(NSObjectFileImage objectFileImage)
{
const int ofiCount = sObjectFileImages.size();
for (int i=0; i < ofiCount; ++i) {
if ( sObjectFileImages[i] == objectFileImage )
return true;
}
return false;
}
bool NSDestroyObjectFileImage(NSObjectFileImage objectFileImage)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, objectFileImage);
if ( validOFI(objectFileImage) ) {
if ( objectFileImage->image != NULL ) {
bool linkedImage = dyld::validImage(objectFileImage->image);
if ( ! linkedImage ) {
ImageLoader::deleteImage(objectFileImage->image);
objectFileImage->image = NULL;
}
}
for (std::vector<NSObjectFileImage>::iterator it=sObjectFileImages.begin(); it != sObjectFileImages.end(); it++) {
if ( *it == objectFileImage ) {
sObjectFileImages.erase(it);
break;
}
}
if ( objectFileImage->imageBaseAddress != NULL ) {
bool freed = false;
if ( (dyld::gLibSystemHelpers != NULL) && (dyld::gLibSystemHelpers->version >= 6) ) {
size_t sz = (*dyld::gLibSystemHelpers->malloc_size)(objectFileImage->imageBaseAddress);
if ( sz != 0 ) {
(*dyld::gLibSystemHelpers->free)((void*)(objectFileImage->imageBaseAddress));
freed = true;
}
}
if ( ! freed )
vm_deallocate(mach_task_self(), (vm_address_t)objectFileImage->imageBaseAddress, objectFileImage->imageLength);
}
delete objectFileImage;
return true;
}
return false;
}
bool NSHasModInitObjectFileImage(NSObjectFileImage objectFileImage)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, objectFileImage);
return objectFileImage->image->needsInitialization();
}
uint32_t NSSymbolDefinitionCountInObjectFileImage(NSObjectFileImage objectFileImage)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, objectFileImage);
return objectFileImage->image->getExportedSymbolCount();
}
const char* NSSymbolDefinitionNameInObjectFileImage(NSObjectFileImage objectFileImage, uint32_t ordinal)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p,%d)\n", __func__, objectFileImage, ordinal);
const ImageLoader::Symbol* sym = objectFileImage->image->getIndexedExportedSymbol(ordinal);
return objectFileImage->image->getExportedSymbolName(sym);
}
uint32_t NSSymbolReferenceCountInObjectFileImage(NSObjectFileImage objectFileImage)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, objectFileImage);
return objectFileImage->image->getImportedSymbolCount();
}
const char * NSSymbolReferenceNameInObjectFileImage(NSObjectFileImage objectFileImage, uint32_t ordinal,
bool* tentative_definition)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p,%d)\n", __func__, objectFileImage, ordinal);
const ImageLoader::Symbol* sym = objectFileImage->image->getIndexedImportedSymbol(ordinal);
if ( tentative_definition != NULL ) {
ImageLoader::ReferenceFlags flags = objectFileImage->image->getImportedSymbolInfo(sym);
if ( (flags & ImageLoader::kTentativeDefinition) != 0 )
*tentative_definition = true;
else
*tentative_definition = false;
}
return objectFileImage->image->getImportedSymbolName(sym);
}
void* NSGetSectionDataInObjectFileImage(NSObjectFileImage objectFileImage,
const char* segmentName, const char* sectionName, unsigned long* size)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p,%s, %s)\n", __func__, objectFileImage, segmentName, sectionName);
void* start;
size_t length;
if ( objectFileImage->image->getSectionContent(segmentName, sectionName, &start, &length) ) {
if ( size != NULL )
*size = length;
return start;
}
return NULL;
}
bool NSIsSymbolDefinedInObjectFileImage(NSObjectFileImage objectFileImage, const char* symbolName)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p,%s)\n", __func__, objectFileImage, symbolName);
const ImageLoader::Symbol* sym = objectFileImage->image->findExportedSymbol(symbolName, true, NULL);
return ( sym != NULL );
}
NSModule NSLinkModule(NSObjectFileImage objectFileImage, const char* moduleName, uint32_t options)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, \"%s\", 0x%08X)\n", __func__, objectFileImage, moduleName, options);
dyld::clearErrorMessage();
try {
if ( (options & NSLINKMODULE_OPTION_CAN_UNLOAD) != 0 )
objectFileImage->image->setCanUnload();
if ( objectFileImage->image->isLinked() ) {
objectFileImage->image = dyld::cloneImage(objectFileImage->image);
}
if ( objectFileImage->image->getPath() == NULL ) {
objectFileImage->image->setPath(moduleName);
dyld_image_info info;
info.imageLoadAddress = objectFileImage->image->machHeader();
info.imageFilePath = moduleName;
info.imageFileModDate = 0;
addImagesToAllImages(1, &info);
}
if ( (options & NSLINKMODULE_OPTION_PRIVATE) != 0 )
objectFileImage->image->setHideExports();
bool forceLazysBound = ( (options & NSLINKMODULE_OPTION_BINDNOW) != 0 );
dyld::link(objectFileImage->image, forceLazysBound, false, ImageLoader::RPathChain(NULL,NULL));
objectFileImage->image->incrementDlopenReferenceCount();
if ( (options & NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES) == 0 )
dyld::runInitializers(objectFileImage->image);
return ImageLoaderToNSModule(objectFileImage->image);
}
catch (const char* msg) {
dyld::garbageCollectImages();
if ( (options & NSLINKMODULE_OPTION_RETURN_ON_ERROR) == 0 )
dyldAPIhalt(__func__, msg);
setLastError(NSLinkEditOtherError, 0, moduleName, msg);
objectFileImage->image = NULL;
free((void*)msg);
return NULL;
}
}
#if OLD_LIBSYSTEM_SUPPORT
static NSModule _dyld_link_module(NSObjectFileImage object_addr, size_t object_size, const char* moduleName, uint32_t options)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, \"%s\", 0x%08X)\n", "NSLinkModule", object_addr, moduleName, options); ImageLoader* image = NULL;
dyld::clearErrorMessage();
try {
const char* imageName = moduleName;
image = dyld::loadFromMemory((const uint8_t*)object_addr, object_size, imageName);
if ( image != NULL ) {
if ( (options & NSLINKMODULE_OPTION_PRIVATE) != 0 )
image->setHideExports();
bool forceLazysBound = ( (options & NSLINKMODULE_OPTION_BINDNOW) != 0 );
dyld::link(image, forceLazysBound, false, ImageLoader::RPathChain(NULL,NULL));
if ( (options & NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES) == 0 )
dyld::runInitializers(image);
}
}
catch (const char* msg) {
if ( (options & NSLINKMODULE_OPTION_RETURN_ON_ERROR) == 0 )
dyldAPIhalt("NSLinkModule", msg);
setLastError(NSLinkEditOtherError, 0, moduleName, msg);
if ( image != NULL ) {
dyld::removeImage(image);
ImageLoader::deleteImage(image);
}
image = NULL;
free((void*)msg);
}
return ImageLoaderToNSModule(image);
}
#endif
NSSymbol NSLookupSymbolInModule(NSModule module, const char* symbolName)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, \"%s\")\n", __func__, (void *)module, symbolName);
ImageLoader* image = NSModuleToImageLoader(module);
if ( image == NULL )
return NULL;
return SymbolToNSSymbol(image->findExportedSymbol(symbolName, false, NULL));
}
const char* NSNameOfModule(NSModule module)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, module);
ImageLoader* image = NSModuleToImageLoader(module);
if ( image == NULL )
return NULL;
return image->getPath();
}
const char* NSLibraryNameForModule(NSModule module)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, module);
ImageLoader* image = NSModuleToImageLoader(module);
if ( image == NULL )
return NULL;
return image->getPath();
}
bool NSUnLinkModule(NSModule module, uint32_t options)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, 0x%08X)\n", __func__, module, options);
if ( module == NULL )
return false;
ImageLoader* image = NSModuleToImageLoader(module);
if ( image == NULL )
return false;
dyld::runImageTerminators(image);
dyld::removeImage(image);
if ( (options & NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED) != 0 )
image->setLeaveMapped();
const int ofiCount = sObjectFileImages.size();
bool found = false;
for (int i=0; i < ofiCount; ++i) {
NSObjectFileImage ofi = sObjectFileImages[i];
if ( ofi->image == image )
found = true;
}
if ( !found )
ImageLoader::deleteImage(image);
return true;
}
static void _dyld_install_handlers(void* undefined, void* multiple, void* linkEdit)
{
if ( dyld::gLogAPIs )
dyld::log("NSLinkEditErrorHandlers()\n");
dyld::registerUndefinedHandler((dyld::UndefinedHandler)undefined);
}
void NSLinkEditError(NSLinkEditErrors* c, int* errorNumber, const char** fileName, const char** errorString)
{
*c = sLastErrorFileCode;
*errorNumber = sLastErrorNo;
*fileName = sLastErrorFilePath;
*errorString = dyld::getErrorMessage();
}
static void _dyld_register_binding_handler(void * (*bindingHandler)(const char *, const char *, void *), ImageLoader::BindingOptions bindingOptions)
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
dyld::gLinkContext.bindingHandler = bindingHandler;
dyld::gLinkContext.bindingOptions = bindingOptions;
}
#endif //DEPRECATED_APIS_SUPPORTED
void _dyld_fork_child()
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
extern mach_port_t mach_task_self_;
mach_task_self_ = task_self_trap();
dyld::gProcessInfo->coreSymbolicationShmPage = NULL;
dyld::gProcessInfo->systemOrderFlag = 0;
}
typedef void (*MonitorProc)(char *lowpc, char *highpc);
static void monInitCallback(ImageLoader* image, void* userData)
{
MonitorProc proc = (MonitorProc)userData;
void* start;
size_t length;
if ( image->getSectionContent("__TEXT", "__text", &start, &length) ) {
proc((char*)start, (char*)start+length);
}
}
void _dyld_moninit(MonitorProc proc)
{
dyld::forEachImageDo(&monInitCallback, (void*)proc);
}
#if DEPRECATED_APIS_SUPPORTED
bool _dyld_launched_prebound()
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
return dyld::mainExecutablePrebound();
}
static bool NSMakePrivateModulePublic(NSModule module)
{
ImageLoader* image = NSModuleToImageLoader(module);
if ( image != NULL ) {
if ( image->hasHiddenExports() ) {
image->setHideExports(false);
return true;
}
}
return false;
}
#endif // DEPRECATED_APIS_SUPPORTED
bool lookupDyldFunction(const char* name, uintptr_t* address)
{
for (const dyld_func* p = dyld_funcs; p->name != NULL; ++p) {
if ( strcmp(p->name, name) == 0 ) {
if( p->implementation == unimplemented )
dyld::log("unimplemented dyld function: %s\n", p->name);
*address = (uintptr_t)p->implementation;
return true;
}
}
*address = 0;
return false;
}
static void registerThreadHelpers(const dyld::LibSystemHelpers* helpers)
{
dyld::gLibSystemHelpers = helpers;
dyld::gProcessInfo->libSystemInitialized = true;
#if __arm__
if ( helpers->version >= 5 ) {
pthread_key_t key;
int result = helpers->pthread_key_create(&key, NULL);
if ( result == 0 )
__Unwind_SjLj_SetThreadKey(key);
}
#endif
}
static void dlerrorClear()
{
if ( dyld::gLibSystemHelpers != NULL ) {
if ( dyld::gLibSystemHelpers->version >= 10 ) {
if ( ! (*dyld::gLibSystemHelpers->hasPerThreadBufferFor_dlerror)() )
return;
}
char* buffer = (*dyld::gLibSystemHelpers->getThreadBufferFor_dlerror)(2);
buffer[0] = '\0';
buffer[1] = '\0';
}
}
static void dlerrorSet(const char* msg)
{
if ( dyld::gLibSystemHelpers != NULL ) {
char* buffer = (*dyld::gLibSystemHelpers->getThreadBufferFor_dlerror)(strlen(msg)+2);
buffer[0] = '\1';
strcpy(&buffer[1], msg);
}
}
bool dlopen_preflight(const char* path)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%s)\n", __func__, path);
dlerrorClear();
#if DYLD_SHARED_CACHE_SUPPORT
if ( dyld::inSharedCache(path) )
return true;
#endif
CRSetCrashLogMessage("dyld: in dlopen_preflight()");
bool result = false;
std::vector<const char*> rpathsFromCallerImage;
try {
void* callerAddress = __builtin_return_address(1); ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
if ( callerImage != NULL )
callerImage->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
ImageLoader::RPathChain callersRPaths(NULL, &rpathsFromCallerImage);
if ( callerImage != dyld::mainExecutable() ) {
dyld::mainExecutable()->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
}
ImageLoader* image = NULL;
const bool leafName = (strchr(path, '/') == NULL);
const bool absolutePath = (path[0] == '/');
#if __IPHONE_OS_VERSION_MIN_REQUIRED
char canonicalPath[PATH_MAX];
if ( !leafName ) {
if ( (strstr(path, "//") != NULL) || (strstr(path, "./") != NULL) ) {
const char* lastSlash = strrchr(path, '/');
char dirPath[PATH_MAX];
if ( strlcpy(dirPath, path, sizeof(dirPath)) < sizeof(dirPath) ) {
dirPath[lastSlash-path] = '\0';
if ( realpath(dirPath, canonicalPath) ) {
strlcat(canonicalPath, "/", sizeof(canonicalPath));
if ( strlcat(canonicalPath, lastSlash+1, sizeof(canonicalPath)) < sizeof(canonicalPath) ) {
path = canonicalPath;
}
}
}
}
}
#endif
dyld::LoadContext context;
context.useSearchPaths = true;
context.useFallbackPaths= leafName; context.useLdLibraryPath= leafName; context.implicitRPath = !absolutePath; context.matchByInstallName = true;
context.dontLoad = false;
context.mustBeBundle = false;
context.mustBeDylib = false;
context.canBePIE = true;
context.origin = callerImage != NULL ? callerImage->getPath() : NULL; context.rpath = &callersRPaths;
image = load(path, context);
if ( image != NULL ) {
dyld::preflight(image, callersRPaths); result = true;
}
}
catch (const char* msg) {
const char* str = dyld::mkstringf("dlopen_preflight(%s): %s", path, msg);
dlerrorSet(str);
free((void*)str);
free((void*)msg); }
for(std::vector<const char*>::iterator it=rpathsFromCallerImage.begin(); it != rpathsFromCallerImage.end(); ++it) {
const char* str = *it;
free((void*)str);
}
CRSetCrashLogMessage(NULL);
return result;
}
void* dlopen(const char* path, int mode)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%s, 0x%08X)\n", __func__, ((path==NULL) ? "NULL" : path), mode);
dlerrorClear();
if ( path == NULL ) {
if ( (mode & RTLD_FIRST) != 0 )
return RTLD_MAIN_ONLY;
else
return RTLD_DEFAULT;
}
bool lockHeld = false;
if ( (dyld::gLibSystemHelpers != NULL) && (dyld::gLibSystemHelpers->version >= 4) ) {
dyld::gLibSystemHelpers->acquireGlobalDyldLock();
CRSetCrashLogMessage("dyld: in dlopen()");
lockHeld = true;
}
void* result = NULL;
ImageLoader* image = NULL;
std::vector<const char*> rpathsFromCallerImage;
try {
void* callerAddress = __builtin_return_address(1); ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
if ( callerImage != NULL )
callerImage->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
ImageLoader::RPathChain callersRPaths(NULL, &rpathsFromCallerImage);
if ( callerImage != dyld::mainExecutable() ) {
dyld::mainExecutable()->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
}
const bool leafName = (strchr(path, '/') == NULL);
const bool absolutePath = (path[0] == '/');
#if __IPHONE_OS_VERSION_MIN_REQUIRED
char canonicalPath[PATH_MAX];
if ( !leafName ) {
if ( (strstr(path, "//") != NULL) || (strstr(path, "./") != NULL) ) {
const char* lastSlash = strrchr(path, '/');
char dirPath[PATH_MAX];
if ( strlcpy(dirPath, path, sizeof(dirPath)) < sizeof(dirPath) ) {
dirPath[lastSlash-path] = '\0';
if ( realpath(dirPath, canonicalPath) ) {
strlcat(canonicalPath, "/", sizeof(canonicalPath));
if ( strlcat(canonicalPath, lastSlash+1, sizeof(canonicalPath)) < sizeof(canonicalPath) ) {
path = canonicalPath;
}
}
}
}
}
#endif
dyld::LoadContext context;
context.useSearchPaths = true;
context.useFallbackPaths= leafName; context.useLdLibraryPath= leafName; context.implicitRPath = !absolutePath; context.matchByInstallName = true;
context.dontLoad = ( (mode & RTLD_NOLOAD) != 0 );
context.mustBeBundle = false;
context.mustBeDylib = false;
context.canBePIE = true;
context.origin = callerImage != NULL ? callerImage->getPath() : NULL; context.rpath = &callersRPaths;
image = load(path, context);
if ( image != NULL ) {
image->incrementDlopenReferenceCount();
if ( (mode & RTLD_NOLOAD) == 0 ) {
bool alreadyLinked = image->isLinked();
bool forceLazysBound = ( (mode & RTLD_NOW) != 0 );
dyld::link(image, forceLazysBound, false, callersRPaths);
if ( ! alreadyLinked ) {
if ( (mode & RTLD_LOCAL) != 0 )
image->setHideExports(true);
}
}
if ( (mode & RTLD_NODELETE) != 0 )
image->setLeaveMapped();
if ( lockHeld ) {
CRSetCrashLogMessage(NULL);
dyld::gLibSystemHelpers->releaseGlobalDyldLock();
lockHeld = false;
}
if ( (mode & RTLD_NOLOAD) == 0 ) {
dyld::runInitializers(image);
}
if ( (mode & RTLD_FIRST) != 0 )
result = (void*)(((uintptr_t)image)|1);
else
result = image;
}
}
catch (const char* msg) {
if ( image != NULL ) {
image->decrementDlopenReferenceCount();
if ( image->dlopenCount() == 0 )
dyld::garbageCollectImages();
}
const char* str = dyld::mkstringf("dlopen(%s, %d): %s", path, mode, msg);
if ( dyld::gLogAPIs )
dyld::log(" %s() failed, error: '%s'\n", __func__, str);
dlerrorSet(str);
free((void*)str);
free((void*)msg); result = NULL;
}
for(std::vector<const char*>::iterator it=rpathsFromCallerImage.begin(); it != rpathsFromCallerImage.end(); ++it) {
const char* str = *it;
free((void*)str);
}
if ( (mode & RTLD_NOLOAD) && (result == NULL) ) {
dlerrorSet("image not already loaded");
}
if ( lockHeld ) {
CRSetCrashLogMessage(NULL);
dyld::gLibSystemHelpers->releaseGlobalDyldLock();
}
if ( dyld::gLogAPIs && (result != NULL) )
dyld::log(" %s(%s) ==> %p\n", __func__, path, result);
return result;
}
int dlclose(void* handle)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, handle);
if ( handle == RTLD_MAIN_ONLY )
return 0;
if ( handle == RTLD_DEFAULT )
return 0;
ImageLoader* image = (ImageLoader*)(((uintptr_t)handle) & (-4)); if ( dyld::validImage(image) ) {
dlerrorClear();
if ( image->decrementDlopenReferenceCount() ) {
dlerrorSet("dlclose() called too many times");
return -1;
}
if ( image->dlopenCount() == 0 )
dyld::garbageCollectImages();
return 0;
}
else {
dlerrorSet("invalid handle passed to dlclose()");
return -1;
}
}
int dladdr(const void* address, Dl_info* info)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, %p)\n", __func__, address, info);
CRSetCrashLogMessage("dyld: in dladdr()");
ImageLoader* image = dyld::findImageContainingAddress(address);
if ( image != NULL ) {
info->dli_fname = image->getRealPath();
info->dli_fbase = (void*)image->machHeader();
if ( address == info->dli_fbase ) {
info->dli_sname = "__dso_handle";
info->dli_saddr = info->dli_fbase;
CRSetCrashLogMessage(NULL);
return 1; }
info->dli_sname = image->findClosestSymbol(address, (const void**)&info->dli_saddr);
if ( info->dli_saddr == info->dli_fbase ) {
info->dli_sname = NULL;
info->dli_saddr = NULL;
CRSetCrashLogMessage(NULL);
return 1; }
if ( info->dli_sname != NULL ) {
if ( info->dli_sname[0] == '_' )
info->dli_sname = info->dli_sname +1; CRSetCrashLogMessage(NULL);
return 1; }
info->dli_sname = NULL;
info->dli_saddr = NULL;
CRSetCrashLogMessage(NULL);
return 1; }
CRSetCrashLogMessage(NULL);
return 0; }
char* dlerror()
{
if ( dyld::gLogAPIs )
dyld::log("%s()\n", __func__);
if ( dyld::gLibSystemHelpers != NULL ) {
if ( dyld::gLibSystemHelpers->version >= 10 ) {
if ( ! (*dyld::gLibSystemHelpers->hasPerThreadBufferFor_dlerror)() )
return NULL;
}
char* buffer = (*dyld::gLibSystemHelpers->getThreadBufferFor_dlerror)(2);
if ( buffer[0] != '\0' ) { buffer[0] = '\0'; return &buffer[1]; }
}
return NULL;
}
void* dlsym(void* handle, const char* symbolName)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p, %s)\n", __func__, handle, symbolName);
CRSetCrashLogMessage("dyld: in dlsym()");
dlerrorClear();
const ImageLoader* image;
const ImageLoader::Symbol* sym;
char underscoredName[strlen(symbolName)+2];
underscoredName[0] = '_';
strcpy(&underscoredName[1], symbolName);
if ( handle == RTLD_DEFAULT ) {
if ( dyld::flatFindExportedSymbol(underscoredName, &sym, &image) ) {
CRSetCrashLogMessage(NULL);
return (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
}
const char* str = dyld::mkstringf("dlsym(RTLD_DEFAULT, %s): symbol not found", symbolName);
dlerrorSet(str);
free((void*)str);
CRSetCrashLogMessage(NULL);
return NULL;
}
if ( handle == RTLD_MAIN_ONLY ) {
image = dyld::mainExecutable();
sym = image->findExportedSymbol(underscoredName, true, &image); if ( sym != NULL ) {
CRSetCrashLogMessage(NULL);
return (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
}
const char* str = dyld::mkstringf("dlsym(RTLD_MAIN_ONLY, %s): symbol not found", symbolName);
dlerrorSet(str);
free((void*)str);
CRSetCrashLogMessage(NULL);
return NULL;
}
if ( handle == RTLD_NEXT ) {
void* callerAddress = __builtin_return_address(1); ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
sym = callerImage->findExportedSymbolInDependentImages(underscoredName, dyld::gLinkContext, &image); if ( sym != NULL ) {
CRSetCrashLogMessage(NULL);
return (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
}
const char* str = dyld::mkstringf("dlsym(RTLD_NEXT, %s): symbol not found", symbolName);
dlerrorSet(str);
free((void*)str);
CRSetCrashLogMessage(NULL);
return NULL;
}
if ( handle == RTLD_SELF ) {
void* callerAddress = __builtin_return_address(1); ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
sym = callerImage->findExportedSymbolInImageOrDependentImages(underscoredName, dyld::gLinkContext, &image); if ( sym != NULL ) {
CRSetCrashLogMessage(NULL);
return (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
}
const char* str = dyld::mkstringf("dlsym(RTLD_SELF, %s): symbol not found", symbolName);
dlerrorSet(str);
free((void*)str);
CRSetCrashLogMessage(NULL);
return NULL;
}
image = (ImageLoader*)(((uintptr_t)handle) & (-4)); if ( dyld::validImage(image) ) {
if ( (((uintptr_t)handle) & 1) != 0 )
sym = image->findExportedSymbol(underscoredName, true, &image); else
sym = image->findExportedSymbolInImageOrDependentImages(underscoredName, dyld::gLinkContext, &image);
if ( sym != NULL ) {
CRSetCrashLogMessage(NULL);
return (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
}
const char* str = dyld::mkstringf("dlsym(%p, %s): symbol not found", handle, symbolName);
dlerrorSet(str);
free((void*)str);
}
else {
dlerrorSet("invalid handle passed to dlsym()");
}
CRSetCrashLogMessage(NULL);
return NULL;
}
const struct dyld_all_image_infos* _dyld_get_all_image_infos()
{
return dyld::gProcessInfo;
}
#if !__arm__
static bool client_dyld_find_unwind_sections(void* addr, dyld_unwind_sections* info)
{
ImageLoader* image = dyld::findImageContainingAddress(addr);
if ( image != NULL ) {
image->getUnwindInfo(info);
return true;
}
return false;
}
#endif
void dyld_register_image_state_change_handler(dyld_image_states state, bool batch,
dyld_image_state_change_handler handler)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%d, %d, %p)\n", __func__, state, batch, handler);
if ( batch )
dyld::registerImageStateBatchChangeHandler(state, handler);
else
dyld::registerImageStateSingleChangeHandler(state, handler);
}
const char* dyld_image_path_containing_address(const void* address)
{
if ( dyld::gLogAPIs )
dyld::log("%s(%p)\n", __func__, address);
ImageLoader* image = dyld::findImageContainingAddress(address);
if ( image != NULL )
return image->getRealPath();
return NULL;
}
#if __IPHONE_OS_VERSION_MIN_REQUIRED
bool dyld_shared_cache_some_image_overridden()
{
#if DYLD_SHARED_CACHE_SUPPORT
return dyld::gSharedCacheOverridden;
#else
return true;
#endif
}
#endif