--- dyld/dyld-635.2/src/dyldAPIs.cpp
+++ dyld/dyld-44.2/src/dyldAPIs.cpp
@@ -1,6 +1,6 @@
 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
  *
- * Copyright (c) 2004-2009 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2005 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_LICENSE_HEADER_START@
  * 
@@ -27,134 +27,57 @@
 //
 //
 
-#define __STDC_LIMIT_MACROS
+
 #include <stddef.h>
-#include <stdint.h>
+#include <stdio.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"
+
+extern "C" mach_port_name_t	task_self_trap(void);  // can't include <System/mach/mach_traps.h> because it is missing extern C
+
+#include "mach-o/dyld_gdb.h"
 #include "mach-o/dyld.h"
 #include "mach-o/dyld_priv.h"
+#include "dlfcn.h"
 
 #include "ImageLoader.h"
-#include "ImageLoaderMachO.h"
 #include "dyld.h"
-#include "dyldLibSystemInterface.h"
-#include "DyldSharedCache.h"
-#include "MachOFile.h"
-
-#undef _POSIX_C_SOURCE
-#include "dlfcn.h"
-
-#if __has_feature(ptrauth_calls)
-  #include <ptrauth.h>
-#endif
-
-#ifndef CPU_SUBTYPE_ARM64_E
-	#define CPU_SUBTYPE_ARM64_E    2
-#endif
-
-// relocation_info.r_length field has value 3 for 64-bit executables and value 2 for 32-bit executables
-#if __LP64__
-#define RELOC_SIZE 3
-#define LC_SEGMENT_COMMAND		LC_SEGMENT_64
-#define LC_ROUTINES_COMMAND		LC_ROUTINES_64
-struct macho_segment_command	: public segment_command_64  {};
-struct macho_section			: public section_64  {};
-struct macho_routines_command	: public routines_command_64  {};
-#else
-#define RELOC_SIZE 2
-#define LC_SEGMENT_COMMAND		LC_SEGMENT
-#define LC_ROUTINES_COMMAND		LC_ROUTINES
-struct macho_segment_command	: public segment_command {};
-struct macho_section			: public section  {};
-struct macho_routines_command	: public routines_command  {};
-#endif
-
-
-// this was in dyld_priv.h but it is no longer exported
-extern "C" {
-    const struct dyld_all_image_infos* _dyld_get_all_image_infos();
-}
-
-// from dyldExceptions.c
-extern "C" void __Unwind_SjLj_SetThreadKey(pthread_key_t key);
-
-// from dyld_gdb.cpp 
-extern void addImagesToAllImages(uint32_t infoCount, const dyld_image_info info[]);
-extern uint32_t allImagesCount();
-extern const mach_header* allImagesIndexedMachHeader(uint32_t index);
-extern const char* allImagesIndexedPath(uint32_t index);
-
-extern "C" int _dyld_func_lookup(const char* name, void** address);
-
-extern "C" void* dlopen_internal(const char* path, int mode, void* callerAddress);
-extern "C" bool  dlopen_preflight_internal(const char* path, void* callerAddress);
-extern "C" void* dlsym_internal(void* handle, const char* symbolName, void* callerAddress);
-
-extern "C" void* dlopen_compat(const char* path, int mode);
-extern "C" bool  dlopen_preflight_compat(const char* path);
-extern "C" void* dlsym_compat(void* handle, const char* symbolName);
-
-
-
-// deprecated APIs are still availble on Mac OS X, but not on iPhone OS
-#if __IPHONE_OS_VERSION_MIN_REQUIRED	
-	#define DEPRECATED_APIS_SUPPORTED 0
-#else
-	#define DEPRECATED_APIS_SUPPORTED 1
-#endif
-
-static bool sDynamicInterposing = false;
-
-#if DEPRECATED_APIS_SUPPORTED
+#include "dyldLibSystemThreadHelpers.h"
+
 static char sLastErrorFilePath[1024];
 static NSLinkEditErrors sLastErrorFileCode;
 static int sLastErrorNo;
-#endif
+
 
 // In 10.3.x and earlier all the NSObjectFileImage API's were implemeneted in libSystem.dylib
 // Beginning in 10.4 the NSObjectFileImage API's are implemented in dyld and libSystem just forwards
 // This conditional keeps support for old libSystem's which needed some help implementing the API's
-#define OLD_LIBSYSTEM_SUPPORT (__i386__)
+#define OLD_LIBSYSTEM_SUPPORT 1
+
 
 // The following functions have no prototype in any header.  They are special cases
 // where _dyld_func_lookup() is used directly.
+static void _dyld_install_handlers(void* undefined, void* multiple, void* linkEdit);
+static NSModule _dyld_link_module(NSObjectFileImage object_addr, size_t object_size, const char* moduleName, uint32_t options);
+static void _dyld_register_binding_handler(void * (*)(const char *, const char *, void *), ImageLoader::BindingOptions);
+static void _dyld_fork_prepare();
+static void _dyld_fork_parent();
+static void _dyld_fork_child();
+static void _dyld_fork_child_final();
 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 void _dyld_mod_term_funcs();
 static bool NSMakePrivateModulePublic(NSModule module);
 static void _dyld_call_module_initializers_for_dylib(const struct mach_header* mh_dylib_header);
+static void registerThreadHelpers(const dyld::ThreadingHelpers*);
+static void _dyld_update_prebinding(int pathCount, const char* paths[], uint32_t flags);
+static const struct dyld_all_image_infos* _dyld_get_all_image_infos();
 
 // The following functions are dyld API's, but since dyld links with a static copy of libc.a
 // the public name cannot be used.
 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 SUPPORT_ZERO_COST_EXCEPTIONS
-static bool client_dyld_find_unwind_sections(void* addr, dyld_unwind_sections* info);
-#endif
-#if DEPRECATED_APIS_SUPPORTED
-#endif
+
 
 static void unimplemented()
 {
@@ -167,59 +90,38 @@
 };
 
 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_internal",							(void*)dlopen_internal },
-    {"__dyld_dlsym_internal",							(void*)dlsym_internal },
-    {"__dyld_dlopen_preflight_internal",				(void*)dlopen_preflight_internal },
-    {"__dyld_dlopen",									(void*)dlopen_compat },
-    {"__dyld_dlsym",									(void*)dlsym_compat },
-    {"__dyld_dlopen_preflight",							(void*)dlopen_preflight_compat },
-	{"__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 },
-
-	// SPIs
-  	{"__dyld_register_thread_helpers",					(void*)registerThreadHelpers },
-	{"__dyld_fork_child",								(void*)_dyld_fork_child },
-    {"__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 SUPPORT_ZERO_COST_EXCEPTIONS
-	{"__dyld_find_unwind_sections",						(void*)client_dyld_find_unwind_sections },
-#endif
-#if __i386__ || __x86_64__ || __arm__ || __arm64__
-	{"__dyld_fast_stub_entry",							(void*)dyld::fastBindLazySymbol },
-#endif
-	{"__dyld_image_path_containing_address",			(void*)dyld_image_path_containing_address },
-	{"__dyld_shared_cache_some_image_overridden",		(void*)dyld_shared_cache_some_image_overridden },
-	{"__dyld_process_is_restricted",					(void*)dyld::processIsRestricted },
-	{"__dyld_dynamic_interpose",						(void*)dyld_dynamic_interpose },
-	{"__dyld_shared_cache_file_path",					(void*)dyld::getStandardSharedCacheFilePath },
-    {"__dyld_get_image_header_containing_address",		(void*)dyld_image_header_containing_address },
-    {"__dyld_is_memory_immutable",						(void*)_dyld_is_memory_immutable },
-    {"__dyld_objc_notify_register",						(void*)_dyld_objc_notify_register },
-    {"__dyld_get_shared_cache_uuid",					(void*)_dyld_get_shared_cache_uuid },
-    {"__dyld_get_shared_cache_range",					(void*)_dyld_get_shared_cache_range },
-    {"__dyld_images_for_addresses",						(void*)_dyld_images_for_addresses },
-    {"__dyld_register_for_image_loads",					(void*)_dyld_register_for_image_loads },
-
-	// deprecated
-#if DEPRECATED_APIS_SUPPORTED
+    {"__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_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_objc",					(void*)unimplemented },
     {"__dyld_lookup_and_bind_fully",				(void*)_dyld_lookup_and_bind_fully },
     {"__dyld_install_handlers",						(void*)_dyld_install_handlers },
     {"__dyld_link_edit_error",						(void*)NSLinkEditError },
+#if OLD_LIBSYSTEM_SUPPORT
+    {"__dyld_link_module",							(void*)_dyld_link_module },
+#endif
     {"__dyld_unlink_module",						(void*)NSUnLinkModule },
+    {"__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_register_func_for_link_module",		(void*)unimplemented },
+    {"__dyld_register_func_for_unlink_module",		(void*)unimplemented },
+    {"__dyld_register_func_for_replace_module",		(void*)unimplemented },
+    {"__dyld_get_objc_module_sect_for_module",		(void*)unimplemented },
+    {"__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_get_image_header_containing_address",  (void*)_dyld_get_image_header_containing_address },
+    {"__dyld_moninit",								(void*)_dyld_moninit },
+    {"__dyld_register_binding_handler",						(void*)_dyld_register_binding_handler },
+    {"__dyld_fork_prepare",							(void*)_dyld_fork_prepare },
+    {"__dyld_fork_parent",							(void*)_dyld_fork_parent },
+    {"__dyld_fork_child",							(void*)_dyld_fork_child },
+    {"__dyld_fork_child_final",						(void*)_dyld_fork_child_final },
+    {"__dyld_fork_mach_init",						(void*)unimplemented },
+    {"__dyld_make_delayed_module_initializer_calls",(void*)_dyld_make_delayed_module_initializer_calls },
     {"__dyld_NSNameOfSymbol",						(void*)NSNameOfSymbol },
     {"__dyld_NSAddressOfSymbol",					(void*)NSAddressOfSymbol },
     {"__dyld_NSModuleForSymbol",					(void*)NSModuleForSymbol },
@@ -236,36 +138,37 @@
     {"__dyld_NSAddLibrary",							(void*)NSAddLibrary },
     {"__dyld_NSAddLibraryWithSearching",			(void*)NSAddLibraryWithSearching },
     {"__dyld_NSAddImage",							(void*)NSAddImage },
+    {"__dyld__NSGetExecutablePath",					(void*)_NSGetExecutablePath },
     {"__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_mod_term_funcs",						(void*)_dyld_mod_term_funcs },
+    {"__dyld_install_link_edit_symbol_handlers",	(void*)dyld::registerZeroLinkHandlers },
     {"__dyld_NSCreateObjectFileImageFromFile",			(void*)NSCreateObjectFileImageFromFile },
     {"__dyld_NSCreateObjectFileImageFromMemory",		(void*)NSCreateObjectFileImageFromMemory },
+    {"__dyld_NSCreateCoreFileImageFromFile",			(void*)unimplemented },
     {"__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
-
+    {"__dyld_NSFindSectionAndOffsetInObjectFileImage",  (void*)NSFindSectionAndOffsetInObjectFileImage },
+	{"__dyld_register_thread_helpers",					(void*)registerThreadHelpers },
+    {"__dyld_dladdr",									(void*)dladdr },
+    {"__dyld_dlclose",									(void*)dlclose },
+    {"__dyld_dlerror",									(void*)dlerror },
+    {"__dyld_dlopen",									(void*)dlopen },
+    {"__dyld_dlsym",									(void*)dlsym },
+	{"__dyld_update_prebinding",						(void*)_dyld_update_prebinding },
+	{"__dyld_get_all_image_infos",						(void*)_dyld_get_all_image_infos },
     {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);
-}
 
 // dyld's abstract type NSSymbol is implemented as const ImageLoader::Symbol*
 inline NSSymbol SymbolToNSSymbol(const ImageLoader::Symbol* sym)
@@ -278,7 +181,7 @@
 }	
 
 // dyld's abstract type NSModule is implemented as ImageLoader*
-inline NSModule ImageLoaderToNSModule(const ImageLoader* image)
+inline NSModule ImageLoaderToNSModule(ImageLoader* image)
 {
 	return (NSModule)image;
 }	
@@ -297,10 +200,6 @@
 	const void*		imageBaseAddress;	// not used with OFI created from files
 	size_t			imageLength;		// not used with OFI created from files
 };
-typedef __NSObjectFileImage*  NSObjectFileImage;
-
-
-VECTOR_NEVER_DESTRUCTED(NSObjectFileImage);
 static std::vector<NSObjectFileImage> sObjectFileImages;
 
 
@@ -313,6 +212,13 @@
 //
 
 
+static void dyldAPIhalt(const char* apiName, const char* errorMsg)
+{
+	fprintf(stderr, "dyld: %s() error\n", apiName);
+	dyld::halt(errorMsg);
+}
+
+
 
 static void setLastError(NSLinkEditErrors code, int errnum, const char* file, const char* message)
 {
@@ -323,7 +229,6 @@
 	sLastErrorNo = errnum;
 }
 
-#endif // DEPRECATED_APIS_SUPPORTED
 
 /*
  *_dyld_NSGetExecutablePath is the dyld side of _NSGetExecutablePath which
@@ -338,121 +243,16 @@
 int _NSGetExecutablePath(char* buf, uint32_t *bufsize)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(...)\n", __func__);
+		fprintf(stderr, "%s(...)\n", __func__);
 	const char* exePath = dyld::getExecutablePath();
 	if(*bufsize < strlen(exePath) + 1){
-	    *bufsize = (uint32_t)(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 allImagesCount();
-}
-
-const struct mach_header* _dyld_get_image_header(uint32_t image_index)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%u)\n", __func__, image_index);
-	return allImagesIndexedMachHeader(image_index);
-}
-
-intptr_t _dyld_get_image_vmaddr_slide(uint32_t image_index)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%u)\n", __func__, image_index);
-	const struct mach_header* mh = allImagesIndexedMachHeader(image_index);
-	if ( mh != NULL )
-		return ImageLoaderMachO::computeSlide(mh);
-	else
-		return 0;
-}
-
-intptr_t _dyld_get_image_slide(const struct mach_header* mh)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, mh);
-	return ImageLoaderMachO::computeSlide(mh);
-}
-
-
-const char* _dyld_get_image_name(uint32_t image_index)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%u)\n", __func__, image_index);
-	return allImagesIndexedPath(image_index);
-}
-
-static const void *stripPointer(const void *ptr) {
-#if __has_feature(ptrauth_calls)
-	return __builtin_ptrauth_strip(ptr, ptrauth_key_asia);
-#else
-	return ptr;
-#endif
-}
-
-static void *stripPointer(void *ptr) {
-#if __has_feature(ptrauth_calls)
-	return __builtin_ptrauth_strip(ptr, ptrauth_key_asia);
-#else
-	return ptr;
-#endif
-}
-
-const struct mach_header * dyld_image_header_containing_address(const void* address)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, address);
-	address = stripPointer(address);
-#if SUPPORT_ACCELERATE_TABLES
-	const mach_header* mh;
-	const char* path;
-	if ( dyld::addressInCache(address, &mh, &path) )
-		return mh;
-#endif
-	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);
-}
-
-
-
-// called by crt before main() by programs linked with 10.4 or earlier crt1.o
-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
 
 //
 // _dyld_call_module_initializers_for_dylib() is the dyld side of
@@ -466,7 +266,7 @@
 static void _dyld_call_module_initializers_for_dylib(const struct mach_header* mh_dylib_header)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("__initialize_Cplusplus()\n");
+		fprintf(stderr, "__initialize_Cplusplus()\n");
 	
 	// for now, do nothing...
 }
@@ -475,15 +275,15 @@
 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);
+		fprintf(stderr, "%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) ) {	
+	if ( dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {	
 		try {
-			image->bindAllLazyPointers(dyld::gLinkContext, true);
+			dyld::link(image, ImageLoader::kLazyOnly, ImageLoader::kDontRunInitializers);
 			if ( address != NULL)
-				*address = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
+				*address = (void*)image->getExportedSymbolAddress(sym);
 			if ( module != NULL)
 				*module = ImageLoaderToNSModule(image);
 		}
@@ -505,12 +305,12 @@
 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;
+		fprintf(stderr, "_dyld_lookup_and_bind(\"%s\", %p, %p)\n", symbolName, address, module);
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
 	if ( dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {
 		if ( address != NULL)
-			*address = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
+			*address = (void*)image->getExportedSymbolAddress(sym);
 		if ( module != NULL)
 			*module = ImageLoaderToNSModule(image);
 	}
@@ -526,14 +326,14 @@
 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;
+		fprintf(stderr, "%s(\"%s\", \"%s\", %p, %p)\n", __func__, symbolName, library_name_hint, address, module);
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
 	// Look for library whose path contains the hint.  If that fails search everywhere
 	if (  dyld::flatFindExportedSymbolWithHint(symbolName, library_name_hint, &sym, &image) 
 	  ||  dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {
 		if ( address != NULL)
-			*address = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext);
+			*address = (void*)image->getExportedSymbolAddress(sym);
 		if ( module != NULL)
 			*module = ImageLoaderToNSModule(image);
 	}
@@ -550,8 +350,8 @@
 NSSymbol NSLookupAndBindSymbol(const char *symbolName)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(\"%s\")\n", __func__, symbolName);
-	const ImageLoader* image;
+		fprintf(stderr, "%s(\"%s\")\n", __func__, symbolName);
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
 	if ( dyld::flatFindExportedSymbol(symbolName, &sym, &image) ) {
 		return SymbolToNSSymbol(sym);
@@ -563,8 +363,8 @@
 NSSymbol NSLookupAndBindSymbolWithHint(const char* symbolName, const char* libraryNameHint)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(\"%s\", \"%s\")\n", __func__, symbolName, libraryNameHint);
-	const ImageLoader* image;
+		fprintf(stderr, "%s(\"%s\", \"%s\")\n", __func__, symbolName, libraryNameHint);
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
 	bool found = dyld::flatFindExportedSymbolWithHint(symbolName, libraryNameHint, &sym, &image);
 	if ( ! found ) {
@@ -576,55 +376,56 @@
 		
 	// return NULL on failure and log
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(\"%s\", \"%s\") => NULL \n", __func__, symbolName, libraryNameHint);
+		fprintf(stderr, "%s(\"%s\", \"%s\") => NULL \n", __func__, symbolName, libraryNameHint);
 	return NULL;
 }
 
-
+uint32_t _dyld_image_count(void)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+	return dyld::getImageCount();
+}
+
+const struct mach_header* _dyld_get_image_header(uint32_t image_index)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%u)\n", __func__, image_index);
+	ImageLoader* image = dyld::getIndexedImage(image_index);
+	if ( image != NULL )
+		return (struct mach_header*)image->machHeader();
+	else
+		return NULL;
+}
 
 
 static __attribute__((noinline)) 
-const struct mach_header* addImage(void* callerAddress, const char* path, bool search, bool dontLoad, bool matchInstallName, bool abortOnError)
+const struct mach_header* addImage(const char* path, bool search, bool dontLoad, bool matchInstallName, bool abortOnError)
 {
 	ImageLoader*	image = NULL;
-	std::vector<const char*> rpathsFromCallerImage;
 	try {
 		dyld::clearErrorMessage();
+		void* callerAddress = __builtin_return_address(2); // note layers: 2: real client, 1: libSystem glue, 0: dyld API
 		ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
-		// like dlopen, use rpath from caller image and from main executable
-		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.enforceIOSMac		= false;
 		context.origin				= callerImage != NULL ? callerImage->getPath() : NULL; // caller's image's path
-		context.rpath				= &callersRPaths; 	// rpaths from caller and main executable
-
-		unsigned cacheIndex;
-		image = load(path, context, cacheIndex);
+		context.rpath				= NULL; // support not yet implemented
+				
+		image = load(path, context);
 		if ( image != NULL ) {
 			if ( context.matchByInstallName )
 				image->setMatchInstallPath(true);
-			dyld::link(image, false, false, callersRPaths, cacheIndex);
-			dyld::runInitializers(image);
-			// images added with NSAddImage() can never be unloaded
-			image->setNeverUnload(); 
+			dyld::link(image, ImageLoader::kNonLazyOnly, ImageLoader::kRunInitializers);
+			return image->machHeader();
 		}
 	}
 	catch (const char* msg) {
-		dyld::garbageCollectImages();
 		if ( abortOnError) {
 			char pathMsg[strlen(msg)+strlen(path)+4];
 			strcpy(pathMsg, msg);
@@ -634,47 +435,33 @@
 		}
 		// not halting, so set error state for NSLinkEditError to find
 		setLastError(NSLinkEditOtherError, 0, path, msg);
-		free((void*)msg); 	// our free() will do nothing if msg is a string literal
-		image = NULL;
-	}
-	// free rpaths (getRPaths() malloc'ed each string)
-	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();
-}
-
+	}
+	return NULL;
+}
 
 const struct mach_header* NSAddImage(const char* path, uint32_t options)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(\"%s\", 0x%08X)\n", __func__, path, options);
+		fprintf(stderr, "%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); // note layers: 1: real client, 0: libSystem glue
-	return addImage(callerAddress, path, search, dontLoad, matchInstallName, abortOnError);
+	const bool abortOnError = ( (options & NSADDIMAGE_OPTION_RETURN_ON_ERROR) == 0 );
+	return addImage(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); // note layers: 1: real client, 0: libSystem glue
-	return (addImage(callerAddress, path, false, false, false, false) != NULL);
+		fprintf(stderr, "%s(\"%s\")\n", __func__, path);
+	return (addImage(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); // note layers: 1: real client, 0: libSystem glue
-	return (addImage(callerAddress, path, true, false, false, false) != NULL);
+		fprintf(stderr, "%s(\"%s\")\n", __func__, path);
+	return (addImage(path, true, false, false, false) != NULL);
 }
 
 
@@ -686,31 +473,29 @@
 bool NSIsSymbolNameDefinedInImage(const struct mach_header* mh, const char* symbolName)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, \"%s\")\n", __func__, (void *)mh, symbolName);
+		fprintf(stderr, "%s(%p, \"%s\")\n", __func__, (void *)mh, symbolName);
 	ImageLoader* image = dyld::findImageByMachHeader(mh);
 	if ( image != NULL ) {
-		if ( image->findExportedSymbol(symbolName, true, NULL) != NULL)
+		if ( image->findExportedSymbol(symbolName, NULL, 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);
+		fprintf(stderr, "%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 ) {
-		const char* symbolToFind = symbolName;
 		try {
 			if ( options & NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY ) {
-				image->bindAllLazyPointers(dyld::gLinkContext, true);
+				dyld::link(image, ImageLoader::kLazyOnly, ImageLoader::kDontRunInitializers);
 			}
 			else if ( options & NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW ) {
-				image->bindAllLazyPointers(dyld::gLinkContext, false);
+				dyld::link(image, ImageLoader::kLazyOnlyNoDependents, ImageLoader::kDontRunInitializers);
 			}
 		}
 		catch (const char* msg) {
@@ -718,10 +503,10 @@
 				dyldAPIhalt(__func__, msg);
 			}
 		}
-		symbol = image->findExportedSymbol(symbolToFind, true, NULL);
+		symbol = image->findExportedSymbol(symbolName, NULL, true, NULL);
 	}
 	if ( dyld::gLogAPIs && (symbol == NULL) )
-		dyld::log("%s(%p, \"%s\", 0x%08X) ==> NULL\n", __func__, mh, symbolName, options);
+		fprintf(stderr, "%s(%p, \"%s\", 0x%08X) ==> NULL\n", __func__, mh, symbolName, options);
 	return SymbolToNSSymbol(symbol);
 }
 
@@ -731,8 +516,8 @@
 static bool client_NSIsSymbolNameDefined(const char* symbolName)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("NSIsSymbolNameDefined(\"%s\")\n", symbolName);
-	const ImageLoader* image;
+		fprintf(stderr, "NSIsSymbolNameDefined(\"%s\")\n", symbolName);
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
 	return dyld::flatFindExportedSymbol(symbolName, &sym, &image);
 }
@@ -740,8 +525,8 @@
 bool NSIsSymbolNameDefinedWithHint(const char* symbolName, const char* libraryNameHint)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(\"%s\", \"%s\")\n", __func__, symbolName, libraryNameHint);
-	const ImageLoader* image;
+		fprintf(stderr, "%s(\"%s\", \"%s\")\n", __func__, symbolName, libraryNameHint);
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
 	bool found = dyld::flatFindExportedSymbolWithHint(symbolName, libraryNameHint, &sym, &image);
 	if ( ! found ) {
@@ -749,16 +534,16 @@
 		 found = dyld::flatFindExportedSymbol(symbolName, &sym, &image);
 	}
 	if ( !found && dyld::gLogAPIs )
-		dyld::log("%s(\"%s\", \"%s\") => false \n", __func__, symbolName, libraryNameHint);
+		fprintf(stderr, "%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);
+		fprintf(stderr, "%s(%p)\n", __func__, (void *)symbol);
 	const char* result = NULL;
-	ImageLoader* image = dyld::findImageContainingSymbol(symbol);
+	ImageLoader* image = dyld::findImageContainingAddress(symbol);
 	if ( image != NULL ) 
 		result = image->getExportedSymbolName(NSSymbolToSymbol(symbol));
 	return result;
@@ -767,47 +552,74 @@
 void* NSAddressOfSymbol(NSSymbol symbol)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, (void *)symbol);
-	if ( symbol == NULL )
-		return NULL;
+		fprintf(stderr, "%s(%p)\n", __func__, (void *)symbol);
 	void* result = NULL;
-	ImageLoader* image = dyld::findImageContainingSymbol(symbol);
+	ImageLoader* image = dyld::findImageContainingAddress(symbol);
 	if ( image != NULL ) 
-		result = (void*)image->getExportedSymbolAddress(NSSymbolToSymbol(symbol), dyld::gLinkContext);
+		result = (void*)image->getExportedSymbolAddress(NSSymbolToSymbol(symbol));
 	return result;
 }
 
 NSModule NSModuleForSymbol(NSSymbol symbol)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, (void *)symbol);
+		fprintf(stderr, "%s(%p)\n", __func__, (void *)symbol);
 	NSModule result = NULL;
-	ImageLoader* image = dyld::findImageContainingSymbol(symbol);
+	ImageLoader* image = dyld::findImageContainingAddress(symbol);
 	if ( image != NULL ) 
 		result = ImageLoaderToNSModule(image);
 	return result;
 }
 
 
+intptr_t _dyld_get_image_vmaddr_slide(uint32_t image_index)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%u)\n", __func__, image_index);
+	ImageLoader* image = dyld::getIndexedImage(image_index);
+	if ( image != NULL )
+		return image->getSlide();
+	else
+		return 0;
+}
+
+const char* _dyld_get_image_name(uint32_t image_index)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%u)\n", __func__, image_index);
+	ImageLoader* image = dyld::getIndexedImage(image_index);
+	if ( image != NULL )
+		return image->getLogicalPath();
+	else
+		return NULL;
+}
+
 
 
 bool _dyld_all_twolevel_modules_prebound(void)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s()\n", __func__);
-	return FALSE; 
-}
+		fprintf(stderr, "%s()\n", __func__);
+	return FALSE; // fixme
+}
+
+void _dyld_bind_objc_module(const void *objc_module)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%p)\n", __func__, objc_module);
+	// do nothing, with new dyld everything already bound
+}
+
 
 bool _dyld_bind_fully_image_containing_address(const void* address)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, address);
-	address = stripPointer(address);
+		fprintf(stderr, "%s(%p)\n", __func__, address);
 	dyld::clearErrorMessage();
 	ImageLoader* image = dyld::findImageContainingAddress(address);
 	if ( image != NULL ) {
 		try {
-			image->bindAllLazyPointers(dyld::gLinkContext, true);
+			dyld::link(image, ImageLoader::kLazyAndNonLazy, ImageLoader::kDontRunInitializers);
 			return true;
 		}
 		catch (const char* msg) {
@@ -820,7 +632,7 @@
 bool _dyld_image_containing_address(const void* address)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, address);
+		fprintf(stderr, "%s(%p)\n", __func__, address);
 	ImageLoader *imageLoader = dyld::findImageContainingAddress(address);
 	return (NULL != imageLoader);
 }
@@ -838,27 +650,22 @@
 NSObjectFileImageReturnCode NSCreateObjectFileImageFromFile(const char* pathName, NSObjectFileImage *objectFileImage)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(\"%s\", ...)\n", __func__, pathName);
+		fprintf(stderr, "%s(\"%s\", ...)\n", __func__, pathName);
 	try {
 		void* callerAddress = __builtin_return_address(1); // note layers: 1: real client, 0: libSystem glue
 		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.enforceIOSMac		= false;
 		context.origin				= callerImage != NULL ? callerImage->getPath() : NULL; // caller's image's path
 		context.rpath				= NULL; // support not yet implemented
 
-		unsigned cacheIndex;
-		ImageLoader* image = dyld::load(pathName, context, cacheIndex);
+		ImageLoader* image = dyld::load(pathName, context);
 		// Note:  We DO NOT link the image!  NSLinkModule will do that
 		if ( image != NULL ) {
 			if ( !image->isBundle() ) {
@@ -870,9 +677,7 @@
 		}
 	}
 	catch (const char* msg) {
-		//dyld::log("dyld: NSCreateObjectFileImageFromFile() error: %s\n", msg);
-		dyld::garbageCollectImages();
-		free((void*)msg);
+		//fprintf(stderr, "dyld: NSCreateObjectFileImageFromFile() error: %s\n", msg);
 		return NSObjectFileImageInappropriateFile;
 	}
 	return NSObjectFileImageFailure;
@@ -882,13 +687,13 @@
 NSObjectFileImageReturnCode NSCreateObjectFileImageFromMemory(const void* address, size_t size, NSObjectFileImage *objectFileImage)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, %lu, %p)\n", __func__, address, size, objectFileImage);
+		fprintf(stderr, "%s(%p, %lu, %p)\n", __func__, address, size, objectFileImage);
 	
 	try {
 		ImageLoader* image = dyld::loadFromMemory((const uint8_t*)address, size, NULL); 
 		if ( ! image->isBundle() ) {
 			// this API can only be used with bundles...
-			dyld::garbageCollectImages();
+			delete image; 
 			return NSObjectFileImageInappropriateFile;
 		}
 		// Note:  We DO NOT link the image!  NSLinkModule will do that
@@ -898,17 +703,15 @@
 		}
 	}
 	catch (const char* msg) {
-		free((void*)msg);
-		dyld::garbageCollectImages();
-		//dyld::log("dyld: NSCreateObjectFileImageFromMemory() error: %s\n", msg);
+		fprintf(stderr, "dyld: NSCreateObjectFileImageFromMemory() error: %s\n", msg);
 	}
 	return NSObjectFileImageFailure;
 }
 
 static bool validOFI(NSObjectFileImage objectFileImage)
 {
-	const size_t ofiCount = sObjectFileImages.size();
-	for (size_t i=0; i < ofiCount; ++i) {
+	const int ofiCount = sObjectFileImages.size();
+	for (int i=0; i < ofiCount; ++i) {
 		if ( sObjectFileImages[i] == objectFileImage )
 			return true;
 	}
@@ -918,19 +721,14 @@
 bool NSDestroyObjectFileImage(NSObjectFileImage objectFileImage)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, objectFileImage);
+		fprintf(stderr, "%s(%p)\n", __func__, objectFileImage);
 	
 	if ( validOFI(objectFileImage) ) {
-		// a failure during NSLinkModule will delete the image
-		if ( objectFileImage->image != NULL ) {
-			// if the image has never been linked or has been unlinked, the image is not in the list of valid images
-			// and we should delete it
-			bool linkedImage = dyld::validImage(objectFileImage->image);
-			if ( ! linkedImage )  {
-				ImageLoader::deleteImage(objectFileImage->image);
-				objectFileImage->image = NULL;
-			}
-		}
+		// if the image has never been linked or has been unlinked, the image is not in the list of valid images
+		// and we should delete it
+		bool linkedImage = dyld::validImage(objectFileImage->image);
+		if ( ! linkedImage ) 
+			delete objectFileImage->image;
 		
 		// remove from list of ofi's
 		for (std::vector<NSObjectFileImage>::iterator it=sObjectFileImages.begin(); it != sObjectFileImages.end(); it++) {
@@ -943,16 +741,7 @@
 		// if object was created from a memory, release that memory
 		// NOTE: this is the way dyld has always done this. NSCreateObjectFileImageFromMemory() hands over ownership of the memory to dyld
 		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);
+			vm_deallocate(mach_task_self(), (vm_address_t)objectFileImage->imageBaseAddress, objectFileImage->imageLength);
 		}
 		
 		// free ofi object
@@ -963,17 +752,24 @@
 	return false;
 }
 
+bool NSHasModInitObjectFileImage(NSObjectFileImage objectFileImage)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%p)\n", __func__, objectFileImage);
+	return objectFileImage->image->needsInitialization();
+}
+
 uint32_t NSSymbolDefinitionCountInObjectFileImage(NSObjectFileImage objectFileImage)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, objectFileImage);
+		fprintf(stderr, "%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);
+		fprintf(stderr, "%s(%p,%d)\n", __func__, objectFileImage, ordinal);
 	const ImageLoader::Symbol* sym = objectFileImage->image->getIndexedExportedSymbol(ordinal);
 	return objectFileImage->image->getExportedSymbolName(sym);	
 }
@@ -981,7 +777,7 @@
 uint32_t NSSymbolReferenceCountInObjectFileImage(NSObjectFileImage objectFileImage)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, objectFileImage);
+		fprintf(stderr, "%s(%p)\n", __func__, objectFileImage);
 	return objectFileImage->image->getImportedSymbolCount();
 }
 
@@ -989,10 +785,10 @@
 													bool* tentative_definition)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p,%d)\n", __func__, objectFileImage, ordinal);
+		fprintf(stderr, "%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);
+		ImageLoader::ReferenceFlags flags = objectFileImage->image->geImportedSymbolInfo(sym);
 		if ( (flags & ImageLoader::kTentativeDefinition) != 0 )
 			*tentative_definition = true;
 		else
@@ -1005,7 +801,7 @@
 										const char* segmentName, const char* sectionName, unsigned long* size)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p,%s, %s)\n", __func__, objectFileImage, segmentName, sectionName);
+		fprintf(stderr, "%s(%p,%s, %s)\n", __func__, objectFileImage, segmentName, sectionName);
 
 	void* start;
 	size_t length;
@@ -1022,100 +818,127 @@
 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);
+		fprintf(stderr, "%s(%p,%s)\n", __func__, objectFileImage, symbolName);
+	const ImageLoader::Symbol* sym = objectFileImage->image->findExportedSymbol(symbolName, NULL, true, NULL);
 	return ( sym != NULL );
 }
 
+/*
+ * Given an imageOffset into an ObjectFileImage, returns 
+ * the segment/section name and offset into that section of
+ * that imageOffset.  Returns FALSE if the imageOffset is not 
+ * in any section.  You can used the resulting sectionOffset to
+ * index into the data returned by NSGetSectionDataInObjectFileImage.
+ * 
+ * First appeared in Mac OS X 10.3 
+ *
+ * SPI: currently only used by ZeroLink to detect +load methods
+ */
+bool 
+NSFindSectionAndOffsetInObjectFileImage(NSObjectFileImage objectFileImage, 
+										unsigned long imageOffset,
+										const char** segmentName, 	/* can be NULL */
+										const char** sectionName, 	/* can be NULL */
+										unsigned long* sectionOffset)	/* can be NULL */
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%p)\n", __func__, objectFileImage);
+	
+	return objectFileImage->image->findSection((char*)(objectFileImage->image->getBaseAddress())+imageOffset, segmentName, sectionName, sectionOffset);
+}
+
 
 
 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); 
+		fprintf(stderr, "%s(%p, \"%s\", 0x%08X)\n", __func__, objectFileImage, moduleName, options); 
 	
 	dyld::clearErrorMessage();
 	try {
-		if ( (options & NSLINKMODULE_OPTION_CAN_UNLOAD) != 0 )
-			objectFileImage->image->setCanUnload();
-
 		// NSLinkModule allows a bundle to be link multpile times
 		// each link causes the bundle to be copied to a new address
 		if ( objectFileImage->image->isLinked() ) {
 			// already linked, so clone a new one and link it
+#if 0
+			fprintf(stderr, "dyld: warning: %s(0x%08X, \"%s\", 0x%08X) called more than once for 0x%08X\n",
+					__func__, objectFileImage, moduleName, options, objectFileImage); 
+#endif
 			objectFileImage->image = dyld::cloneImage(objectFileImage->image);
 		}
 		
-		// for memory based images, set moduleName as the name anyone calling _dyld_get_image_name() will see
-		if ( objectFileImage->image->getPath() == NULL ) {
-			objectFileImage->image->setPath(moduleName);
-			// <rdar://problem/8812589> dyld has NULL paths in image info array
-			dyld_image_info info;
-			info.imageLoadAddress = objectFileImage->image->machHeader();
-			info.imageFilePath = moduleName;
-			info.imageFileModDate = 0;
-			addImagesToAllImages(1, &info);
-		}
+		// if this ofi was made with NSCreateObjectFileImageFromFile() then physical path is already set
+		// if this ofi was create with NSCreateObjectFileImageFromMemory() then the phyiscal path should be set if supplied 
+		if ( (options & NSLINKMODULE_OPTION_TRAILING_PHYS_NAME) != 0 ) {
+			if ( objectFileImage->imageBaseAddress != NULL ) {
+				const char* physEnd = &moduleName[strlen(moduleName)+1];
+				objectFileImage->image->setPath(physEnd);
+			}
+		}
+	
+		// set moduleName as the name anyone calling _dyld_get_image_name() will see
+		objectFileImage->image->setLogicalPath(moduleName);
 
 		// support private bundles
 		if ( (options & NSLINKMODULE_OPTION_PRIVATE) != 0 )
 			objectFileImage->image->setHideExports();
 	
 		// set up linking options
-		bool forceLazysBound = ( (options & NSLINKMODULE_OPTION_BINDNOW) != 0 );
+		ImageLoader::BindingLaziness bindness = ImageLoader::kNonLazyOnly;
+		if ( (options & NSLINKMODULE_OPTION_BINDNOW) != 0 )
+			bindness = ImageLoader::kLazyAndNonLazy;
+		ImageLoader::InitializerRunning runInitializers = ImageLoader::kRunInitializers;
+		if ( (options & NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES) != 0 )
+			runInitializers = ImageLoader::kDontRunInitializersButTellObjc;
 		
 		// load libraries, rebase, bind, to make this image usable
-		dyld::link(objectFileImage->image, forceLazysBound, false, ImageLoader::RPathChain(NULL,NULL), UINT32_MAX);
+		dyld::link(objectFileImage->image, bindness, runInitializers);
 		
-		// bump reference count to keep this bundle from being garbage collected
-		objectFileImage->image->incrementDlopenReferenceCount();
-
-		// run initializers unless magic flag says not to
-		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);
 		// not halting, so set error state for NSLinkEditError to find
+		dyld::removeImage(objectFileImage->image);
 		setLastError(NSLinkEditOtherError, 0, moduleName, msg);
-		// dyld::link() deleted the image so lose our reference
-		objectFileImage->image = NULL;
-		free((void*)msg);
 		return NULL;
 	}
 }
-
 
 #if OLD_LIBSYSTEM_SUPPORT
 // This is for compatibility with old libSystems (libdyld.a) which process ObjectFileImages outside dyld
 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); // note name/args translation
+		fprintf(stderr, "%s(%p, \"%s\", 0x%08X)\n", "NSLinkModule", object_addr,  moduleName, options); // note name/args translation
 	ImageLoader* image = NULL;
 	dyld::clearErrorMessage();
 	try {
-		const char* imageName = moduleName;			
+		const char* imageName = moduleName;
+		if ( (options & NSLINKMODULE_OPTION_TRAILING_PHYS_NAME) != 0 )
+			imageName = &moduleName[strlen(moduleName)+1];
+			
 		image = dyld::loadFromMemory((const uint8_t*)object_addr, object_size, imageName); 
 		
+		if ( (options & NSLINKMODULE_OPTION_TRAILING_PHYS_NAME) != 0 )
+			image->setLogicalPath(moduleName);
+			
 		if ( image != NULL ) {		
 			// support private bundles
 			if ( (options & NSLINKMODULE_OPTION_PRIVATE) != 0 )
 				image->setHideExports();
 		
 			// set up linking options
-			bool forceLazysBound = ( (options & NSLINKMODULE_OPTION_BINDNOW) != 0 );
+			ImageLoader::BindingLaziness bindness = ImageLoader::kNonLazyOnly;
+			if ( (options & NSLINKMODULE_OPTION_BINDNOW) != 0 )
+				bindness = ImageLoader::kLazyAndNonLazy;
+			ImageLoader::InitializerRunning runInitializers = ImageLoader::kRunInitializers;
+			if ( (options & NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES) != 0 )
+				runInitializers = ImageLoader::kDontRunInitializersButTellObjc;
 			
 			// load libraries, rebase, bind, to make this image usable
-			dyld::link(image, forceLazysBound, false, ImageLoader::RPathChain(NULL,NULL), UINT32_MAX);
-			
-			// run initializers unless magic flag says not to
-			if ( (options & NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES) == 0 )
-				dyld::runInitializers(image);
+			dyld::link(image, bindness, runInitializers);
 		}
 	}
 	catch (const char* msg) {
@@ -1126,10 +949,9 @@
 		// if image was created for this bundle, destroy it
 		if ( image != NULL ) {
 			dyld::removeImage(image);
-			ImageLoader::deleteImage(image);
+			delete image;
 		}
 		image = NULL;
-		free((void*)msg);
 	}
 	return ImageLoaderToNSModule(image);
 }
@@ -1138,17 +960,17 @@
 NSSymbol NSLookupSymbolInModule(NSModule module, const char* symbolName)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, \"%s\")\n", __func__, (void *)module, symbolName);
+		fprintf(stderr, "%s(%p, \"%s\")\n", __func__, (void *)module, symbolName);
 	ImageLoader* image = NSModuleToImageLoader(module);
 	if ( image == NULL ) 
 		return NULL;
-	return SymbolToNSSymbol(image->findExportedSymbol(symbolName, false, NULL));
+	return SymbolToNSSymbol(image->findExportedSymbol(symbolName, NULL, false, NULL));
 }
 
 const char* NSNameOfModule(NSModule module)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, module);
+		fprintf(stderr, "%s(%p)\n", __func__, module);
 	ImageLoader* image = NSModuleToImageLoader(module);
 	if ( image == NULL ) 
 		return NULL;
@@ -1158,7 +980,7 @@
 const char* NSLibraryNameForModule(NSModule module)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, module);
+		fprintf(stderr, "%s(%p)\n", __func__, module);
 	ImageLoader* image = NSModuleToImageLoader(module);
 	if ( image == NULL ) 
 		return NULL;
@@ -1168,25 +990,12 @@
 bool NSUnLinkModule(NSModule module, uint32_t options)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, 0x%08X)\n", __func__, module, options); 
+		fprintf(stderr, "%s(%p, 0x%08X)\n", __func__, module, options); 
 	if ( module == NULL )
 		return false;
 	ImageLoader* image = NSModuleToImageLoader(module);
 	if ( image == NULL ) 
 		return false;
-	dyld::runImageStaticTerminators(image);
-	if ( (dyld::gLibSystemHelpers != NULL) && (dyld::gLibSystemHelpers->version >= 13) ) {
-		__cxa_range_t ranges[image->segmentCount()];
-		int rangeCount = 0;
-		for (unsigned int j=0; j < image->segmentCount(); ++j) {
-			if ( !image->segExecutable(j) )
-				continue;
-			ranges[rangeCount].addr = (const void*)image->segActualLoadAddress(j);
-			ranges[rangeCount].length = image->segSize(j);
-			++rangeCount;
-		}
-		(*dyld::gLibSystemHelpers->cxa_finalize_ranges)(ranges, rangeCount);
-	}
 	dyld::removeImage(image);
 	
 	if ( (options & NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED) != 0 )
@@ -1196,15 +1005,15 @@
 
 	// Only delete image if there is no ofi referencing it
 	// That means the ofi was destroyed after linking, so no one is left to delete this image	
-	const size_t ofiCount = sObjectFileImages.size();
+	const int ofiCount = sObjectFileImages.size();
 	bool found = false;
-	for (size_t i=0; i < ofiCount; ++i) {
+	for (int i=0; i < ofiCount; ++i) {
 		NSObjectFileImage ofi = sObjectFileImages[i];
 		if ( ofi->image == image )
 			found = true;
 	}
 	if ( !found )
-		ImageLoader::deleteImage(image);
+		delete image;
 	
 	return true;
 }
@@ -1213,13 +1022,52 @@
 static void _dyld_install_handlers(void* undefined, void* multiple, void* linkEdit)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("NSLinkEditErrorHandlers()\n");
+		fprintf(stderr, "NSLinkEditErrorHandlers()\n");
 
 	dyld::registerUndefinedHandler((dyld::UndefinedHandler)undefined);
 	// no support for multiple or linkedit handlers
 }
 
-
+const struct mach_header * _dyld_get_image_header_containing_address(const void* address)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%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 )
+		fprintf(stderr, "%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 )
+		fprintf(stderr, "%s(%p)\n", __func__, (void *)func);
+	dyld::registerRemoveCallback(func);
+}
+
+// called by atexit() function installed by crt
+static void _dyld_mod_term_funcs()
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+	dyld::runTerminators();
+}
+
+// called by crt before main
+static void _dyld_make_delayed_module_initializer_calls()
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+	dyld::initializeMainExecutable();
+}
 
 
 void NSLinkEditError(NSLinkEditErrors* c, int* errorNumber, const char** fileName, const char** errorString)
@@ -1231,24 +1079,33 @@
 	*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__);
+		fprintf(stderr, "%s()\n", __func__);
 	dyld::gLinkContext.bindingHandler = bindingHandler;
 	dyld::gLinkContext.bindingOptions = bindingOptions;
 }
 
-#endif //DEPRECATED_APIS_SUPPORTED
-
+// Call by fork() in libSystem before the kernel trap is done
+static void _dyld_fork_prepare()
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+}
+
+// Call by fork() in libSystem after the kernel trap is done on the parent side
+static void _dyld_fork_parent()
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+}
 
 // Call by fork() in libSystem after the kernel trap is done on the child side
-void _dyld_fork_child()
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s()\n", __func__);
+static void _dyld_fork_child()
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
 	// The implementation of fork() in libSystem knows to reset the variable mach_task_self_
 	// in libSystem for the child of a fork.  But dyld is built with a static copy
 	// of libc.a and has its own copy of mach_task_self_ which we reset here.
@@ -1258,22 +1115,44 @@
 	//
 	extern mach_port_t	mach_task_self_;
 	mach_task_self_ = task_self_trap();
- 	
-	// If dyld is sending load/unload notices to CoreSymbolication, the shared memory
-	// page is not copied on fork. <rdar://problem/6797342>
- 	// NULL the CoreSymbolication shared memory pointer to prevent a crash.
- 	dyld::gProcessInfo->coreSymbolicationShmPage = NULL;
-	// for safety, make sure child starts with clean systemOrderFlag
-	dyld::gProcessInfo->systemOrderFlag = 0;
-}
-
-
-#if DEPRECATED_APIS_SUPPORTED
+}
+
+// Call by fork() in libSystem after the kernel trap is done on the child side after
+// other libSystem child side fixups are done
+static void _dyld_fork_child_final()
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+}
+
+
+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);
+	}
+}
+
+//
+// _dyld_moninit is called from profiling runtime routine moninit().
+// dyld calls back with the range of each __TEXT/__text section in every
+// linked image.
+//
+void _dyld_moninit(MonitorProc proc)
+{
+	dyld::forEachImageDo(&monInitCallback, (void*)proc);
+}
+
 // returns true if prebinding was used in main executable
 bool _dyld_launched_prebound()
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s()\n", __func__);
+		fprintf(stderr, "%s()\n", __func__);
 		
 	// ¥¥¥Êif we deprecate prebinding, we may want to consider always returning true or false here
 	return dyld::mainExecutablePrebound();
@@ -1299,15 +1178,15 @@
 	return false;
 }
 
-#endif // DEPRECATED_APIS_SUPPORTED
-
-int _dyld_func_lookup(const char* name, void** address)
+
+
+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 = p->implementation;
+				fprintf(stderr, "unimplemented dyld function: %s\n", p->name);
+			*address = (uintptr_t)p->implementation;
 			return true;
 	    }
 	}
@@ -1316,289 +1195,79 @@
 }
 
 
-static void registerThreadHelpers(const dyld::LibSystemHelpers* helpers)
-{
-	dyld::gLibSystemHelpers = helpers;
-	
-#if !SUPPORT_ZERO_COST_EXCEPTIONS
-	if ( helpers->version >= 5 )  {
-		// create key use by dyld exception handling
-		pthread_key_t key;
-		int result = helpers->pthread_key_create(&key, NULL);
-		if ( result == 0 )
-			__Unwind_SjLj_SetThreadKey(key);
-	}
-#endif
+static void registerThreadHelpers(const dyld::ThreadingHelpers* helpers)
+{
+	// We need to make sure libSystem's lazy pointer's are bound
+	// before installing thred helpers.
+	// The reason for this is that if accessing the lock requires
+	// a lazy pointer to be bound (and it does when multi-module
+	// libSystem) is not prebound, the lazy handler will be
+	// invoked which tries to acquire the lock again...an infinite 
+	// loop.
+	ImageLoader* image = dyld::findImageContainingAddress(helpers);
+	dyld::link(image, ImageLoader::kLazyOnly, ImageLoader::kDontRunInitializers);
+
+	dyld::gThreadHelpers = helpers;
 }
 
 
 static void dlerrorClear()
 {
-	if ( dyld::gLibSystemHelpers != NULL ) {
-		// <rdar://problem/10595338> dlerror buffer leak
-		// dlerrorClear() should not force allocation, but zero it if already allocated
-		if ( dyld::gLibSystemHelpers->version >= 10 ) {
-			if ( ! (*dyld::gLibSystemHelpers->hasPerThreadBufferFor_dlerror)() )
-				return;
-		}
-
-		// first char of buffer is flag whether string (starting at second char) is valid
-		char* buffer = (*dyld::gLibSystemHelpers->getThreadBufferFor_dlerror)(2);
+	if ( dyld::gThreadHelpers != NULL ) {
+		char* buffer = (*dyld::gThreadHelpers->getThreadBufferFor_dlerror)(1);
 		buffer[0] = '\0';
-		buffer[1] = '\0';
 	}
 }
 
 static void dlerrorSet(const char* msg)
 {
-	if ( dyld::gLibSystemHelpers != NULL ) {
-		// first char of buffer is flag whether string (starting at second char) is valid
-		char* buffer = (*dyld::gLibSystemHelpers->getThreadBufferFor_dlerror)(strlen(msg)+2);
-		buffer[0] = '\1';
-		strcpy(&buffer[1], msg);
-	}
-}
-
-
-bool dlopen_preflight_internal(const char* path, void* callerAddress)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%s)\n", __func__, path);
+	if ( dyld::gThreadHelpers != NULL ) {
+		char* buffer = (*dyld::gThreadHelpers->getThreadBufferFor_dlerror)(strlen(msg)+1);
+		strcpy(buffer, msg);
+	}
+}
+
+
+
+void* dlopen(const char* path, int mode)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%s, 0x%08X)\n", __func__, path, mode);
 
 	dlerrorClear();
 	
-	CRSetCrashLogMessage("dyld: in dlopen_preflight()");
-
-	const bool leafName = (strchr(path, '/') == NULL);
-	const bool absolutePath = (path[0] == '/');
-#if __IPHONE_OS_VERSION_MIN_REQUIRED
-	char canonicalPath[PATH_MAX]; 
-	// <rdar://problem/7017050> dlopen() not opening frameworks from shared cache with // or ./ in path
-	if ( !leafName ) {
-		// make path canonical if it contains a // or ./
-		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) ) {
-						// if all fit in buffer, use new canonical path
-						path = canonicalPath;
-					}
-				}
-			}
-		}
-	}
-#endif
-#if SUPPORT_ACCELERATE_TABLES
-	if  ( dyld::isPathInCache(path) )
-		return true;
-#endif
-
-	// <rdar://problem/5910137> dlopen_preflight() on image in shared cache leaves it loaded but not objc initialized
-	// if requested path is to something in the dyld shared cache, always succeed
-	if ( dyld::inSharedCache(path) )
-		return true;
+	// passing NULL for path means return magic object
+	if ( path == NULL ) {
+		return RTLD_DEFAULT;
+	}
 	
-	bool result = false;
-	std::vector<const char*> rpathsFromCallerImage;
 	try {
+		void* callerAddress = __builtin_return_address(1); // note layers: 1: real client, 0: libSystem glue
 		ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
-		// for dlopen, use rpath from caller image and from main executable
-		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;
 		dyld::LoadContext context;
 		context.useSearchPaths	= true;
-		context.useFallbackPaths= leafName;					// a partial path implies don't use fallback paths
-		context.useLdLibraryPath= leafName;					// a leafname implies should search 
-		context.implicitRPath	= !absolutePath;			// a non-absolute path implies try rpath searching 
+		context.useLdLibraryPath= (strchr(path, '/') == NULL);	// a leafname implies should search 
 		context.matchByInstallName = true;
-		context.dontLoad		= false;
+		context.dontLoad = ( (mode & RTLD_NOLOAD) != 0 );
 		context.mustBeBundle	= false;
 		context.mustBeDylib		= false;
-		context.canBePIE		= true;
-		context.enforceIOSMac	= false;
 		context.origin			= callerImage != NULL ? callerImage->getPath() : NULL; // caller's image's path
-		context.rpath			= &callersRPaths;	// rpaths from caller and main executable
-
-		unsigned cacheIndex;
-		image = load(path, context, cacheIndex);
+		context.rpath			= NULL; // support not yet implemented
+		
+		image = load(path, context);
 		if ( image != NULL ) {
-			dyld::preflight(image, callersRPaths, cacheIndex);	// image object deleted by dyld::preflight()
-			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); 	// our free() will do nothing if msg is a string literal
-	}
-	// free rpaths (getRPaths() malloc'ed each string)
-	for(std::vector<const char*>::iterator it=rpathsFromCallerImage.begin(); it != rpathsFromCallerImage.end(); ++it) {
-		const char* str = *it;
-		free((void*)str);
-	}
-	CRSetCrashLogMessage(NULL);
-	return result;
-}
-
-#if SUPPORT_ACCELERATE_TABLES
-bool static callerIsNonOSApp(void* callerAddress, const char** shortName)
-{
-	*shortName = NULL;
-	const mach_header* unusedMh;
-	const char* unusedPath;
-	unsigned unusedIndex;
-	// any address in shared cache is not from app
-	if ( dyld::addressInCache(callerAddress, &unusedMh, &unusedPath, &unusedIndex) )
-		return false;
-
-	ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
-	if ( callerImage == NULL )
-		return false;
-
-	*shortName = callerImage->getShortName();
-	return ( strncmp(callerImage->getPath(), "/var/containers/", 16) == 0 );
-}
-#endif
-
-void* dlopen_internal(const char* path, int mode, void* callerAddress)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%s, 0x%08X)\n", __func__, ((path==NULL) ? "NULL" : path), mode);
-
-#if SUPPORT_ACCELERATE_TABLES
-	if ( dyld::gLogAppAPIs ) {
-		const char* shortName;
-		if ( callerIsNonOSApp(callerAddress, &shortName) ) {
-			dyld::log("%s: %s(%s, 0x%08X)\n", shortName, __func__, ((path==NULL) ? "NULL" : path), mode);
-		}
-	}
-#endif
-
-	dlerrorClear();
-
-	// passing NULL for path means return magic object
-	if ( path == NULL ) {
-		// RTLD_FIRST means any dlsym() calls on the handle should only search that handle and not subsequent images
-		if ( (mode & RTLD_FIRST) != 0 )
-			return RTLD_MAIN_ONLY;
-		else
-			return RTLD_DEFAULT;
-	}
-	
-	// acquire global dyld lock (dlopen is special - libSystem glue does not do locking)
-	bool lockHeld = false;
-	if ( (dyld::gLibSystemHelpers != NULL) && (dyld::gLibSystemHelpers->version >= 4) ) {
-		dyld::gLibSystemHelpers->acquireGlobalDyldLock();
-		CRSetCrashLogMessage("dyld: in dlopen()");
-		lockHeld = true;
-	}
-		
-	void* result = NULL;
-	const bool leafName = (strchr(path, '/') == NULL);
-	const bool absolutePath = (path[0] == '/');
-#if __IPHONE_OS_VERSION_MIN_REQUIRED
-	char canonicalPath[PATH_MAX]; 
-	// <rdar://problem/7017050> dlopen() not opening frameworks from shared cache with // or ./ in path
-	if ( !leafName ) {
-		// make path canonical if it contains a // or ./
-		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) ) {
-						// if all fit in buffer, use new canonical path
-						path = canonicalPath;
-					}
-				}
+			image->incrementReferenceCount();
+			if ( ! image->isLinked() ) {
+				ImageLoader::BindingLaziness bindiness = ImageLoader::kNonLazyOnly;
+				if ( (mode & RTLD_NOW) != 0 )
+					bindiness = ImageLoader::kLazyAndNonLazy;
+				dyld::link(image, bindiness, ImageLoader::kRunInitializers);
+				// only hide exports if image is not already in use
+				if ( (mode & RTLD_LOCAL) != 0 )
+					image->setHideExports(true);
 			}
-		}
-	}
-#endif
-#if SUPPORT_ACCELERATE_TABLES
-	if ( dyld::dlopenFromCache(path, mode, &result) ) {
-		// Note: dlopenFromCache() releases the lock
-		if ( dyld::gLogAPIs )
-			dyld::log("  %s(%s) ==> %p\n", __func__, path, result);
-		return result;
-	}
-#endif
-
-	ImageLoader* image = NULL;
-	std::vector<const char*> rpathsFromCallerImage;
-	ImageLoader::RPathChain callersRPaths(NULL, &rpathsFromCallerImage);
-	try {
-		ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
-		if ( (mode & RTLD_NOLOAD) == 0 ) {
-			// for dlopen, use rpath from caller image and from main executable
-			if ( callerImage != NULL )
-				callerImage->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
-			if ( callerImage != dyld::mainExecutable() )
-				dyld::mainExecutable()->getRPaths(dyld::gLinkContext, rpathsFromCallerImage);
-		}
- 
-		dyld::LoadContext context;
-		context.useSearchPaths	= true;
-		context.useFallbackPaths= leafName;				// a partial path means no fallback paths
-		context.useLdLibraryPath= leafName;				// a leafname implies should search 
-		context.implicitRPath   = !absolutePath;		// a non-absolute path implies try rpath searching 
-		context.matchByInstallName = true;
-		context.dontLoad		= ( (mode & RTLD_NOLOAD) != 0 );
-		context.mustBeBundle	= false;
-		context.mustBeDylib		= false;
-		context.canBePIE		= true;
-		context.enforceIOSMac	= false;
-		context.origin			= callerImage != NULL ? callerImage->getPath() : NULL; // caller's image's path
-		context.rpath			= &callersRPaths;				// rpaths from caller and main executable
-
-		unsigned cacheIndex;
-		image = load(path, context, cacheIndex);
-#if SUPPORT_ACCELERATE_TABLES
-		if ( (image != NULL) && (cacheIndex != UINT32_MAX) ) {
-            // found in cache, but under a different path
-            const char* betterPath = dyld::getPathFromIndex(cacheIndex);
-            if ( (betterPath != NULL) && dyld::dlopenFromCache(betterPath, mode, &result) ) {
-                // Note: dlopenFromCache() releases the lock
-                if ( dyld::gLogAPIs )
-                    dyld::log("  %s(%s) ==> %p\n", __func__, path, result);
-                return result;
-			}
-		}
-#endif
-		if ( image != NULL ) {
-			// bump reference count.  Do this before link() so that if an initializer calls dlopen and fails
-			// this image is not garbage collected
-			image->incrementDlopenReferenceCount();
-			// link in all dependents
-			if ( (mode & RTLD_NOLOAD) == 0 ) {
-				bool alreadyLinked = image->isLinked();
-				bool forceLazysBound = ( (mode & RTLD_NOW) != 0 );
-				dyld::link(image, forceLazysBound, false, callersRPaths, cacheIndex);
-				if ( alreadyLinked ) {
-					// upgrade
-					if ( ((mode & RTLD_LOCAL) == 0) && image->hasHiddenExports() )
-						image->setHideExports(false);
-				}
-				else {
-					// only hide exports if image is not already in use
-					if ( (mode & RTLD_LOCAL) != 0 )
-						image->setHideExports(true);
-				}
-			}
-			
 			// RTLD_NODELETE means don't unmap image even after dlclosed. This is what dlcompat did on Mac OS X 10.3
 			// On other *nix OS's, it means dlclose() should do nothing, but the handle should be invalidated. 
 			// The subtle differences are: 
@@ -1606,97 +1275,34 @@
 			//  2) If someone does a supsequent dlopen() on the same image, whether the same address should be used. 
 			if ( (mode & RTLD_NODELETE) != 0 )
 				image->setLeaveMapped();
-			
-			// release global dyld lock early, this enables initializers to do threaded operations
-			if ( lockHeld ) {
-				CRSetCrashLogMessage(NULL);
-				dyld::gLibSystemHelpers->releaseGlobalDyldLock();
-				lockHeld = false;
+			return image;
+		}
+	}
+	catch (const char* msg) {
+		const char* format = "dlopen(%s, %d): %s";
+		char temp[strlen(format)+strlen(path)+strlen(msg)+10];
+		sprintf(temp, format, path, mode, msg);
+		dlerrorSet(temp);
+	}
+	return NULL;
+}
+
+int dlclose(void* handle)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%p)\n", __func__, handle);
+
+	ImageLoader* image = (ImageLoader*)handle;
+	if ( dyld::validImage(image) ) {
+		if ( image->decrementReferenceCount() ) {
+			// for now, only bundles can be unloaded
+			// to unload dylibs we would need to track all direct and indirect uses
+			if ( image->isBundle() ) {
+				dyld::removeImage(image);
+				delete image;
 			}
-			
-			// RTLD_NOLOAD means dlopen should fail unless path is already loaded. 
-			// don't run initializers when RTLD_NOLOAD is set.  This only matters if dlopen() is
-			// called from within an initializer because it can cause initializers to run
-			// out of order. Most uses of RTLD_NOLOAD are "probes".  If they want initialzers
-			// to run, then don't use RTLD_NOLOAD.
-			if ( (mode & RTLD_NOLOAD) == 0 ) {
-				// run initializers
-				dyld::runInitializers(image);
-			}
-			
-			// RTLD_FIRST means any dlsym() calls on the handle should only search that handle and not subsequent images
-			// this is tracked by setting the low bit of the handle, which is usually zero by malloc alignment
-			if ( (mode & RTLD_FIRST) != 0 )
-				result = (void*)(((uintptr_t)image)|1);
-			else
-				result = image;
-		}
-	}
-	catch (const char* msg) {
-		if ( image != NULL ) {
-			// load() succeeded but, link() failed
-			// back down reference count and do GC
-			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); 	// our free() will do nothing if msg is a string literal
-		result = NULL;
-	}
-	// free rpaths (getRPaths() malloc'ed each string)
-	for(std::vector<const char*>::iterator it=rpathsFromCallerImage.begin(); it != rpathsFromCallerImage.end(); ++it) {
-		const char* str = *it;
-		free((void*)str);
-	}
-	
-	// when context.dontLoad is set, load() returns NULL instead of throwing an exception 
-	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);
-
-	// silently accept magic handles for main executable
-	if ( handle == RTLD_MAIN_ONLY )
-		return 0;
-	if ( handle == RTLD_DEFAULT )
-		return 0;
-
-#if SUPPORT_ACCELERATE_TABLES
-	if ( dyld::isCacheHandle(handle) ) {
+		}
 		dlerrorClear();
-		return 0;
-	}
-#endif
-
-	ImageLoader* image = (ImageLoader*)(((uintptr_t)handle) & (-4));	// clear mode bits
-	if ( dyld::validImage(image) ) {
-		dlerrorClear();
-		// decrement use count
-		if ( image->decrementDlopenReferenceCount() ) {
-			dlerrorSet("dlclose() called too many times");
-			return -1;
-		}
-		// remove image if reference count went to zero
-		if ( image->dlopenCount() == 0 )
-			dyld::garbageCollectImages();
 		return 0;
 	}
 	else {
@@ -1710,55 +1316,34 @@
 int dladdr(const void* address, Dl_info* info)
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, %p)\n", __func__, address, info);
-
-	// <rdar://problem/42171466> calling dladdr(xx,NULL) crashes
-	if ( info == NULL )
-		return 0; // failure
-
-	address = stripPointer(address);
-
-	CRSetCrashLogMessage("dyld: in dladdr()");
-#if SUPPORT_ACCELERATE_TABLES
-	if ( dyld::dladdrFromCache(address, info) ) {
-		CRSetCrashLogMessage(NULL);
-		return 1; // success
-	}
-#endif
+		fprintf(stderr, "%s(%p, %p)\n", __func__, address, info);
 
 	ImageLoader* image = dyld::findImageContainingAddress(address);
 	if ( image != NULL ) {
-		info->dli_fname = image->getRealPath();
-		info->dli_fbase = (void*)image->machHeader();
-		if ( address == info->dli_fbase ) {
-			// special case lookup of header
-			info->dli_sname = "__dso_handle";
-			info->dli_saddr = info->dli_fbase;
-			CRSetCrashLogMessage(NULL);
-			return 1; // success
-		}
-		// find closest symbol in the image
-		info->dli_sname = image->findClosestSymbol(address, (const void**)&info->dli_saddr);
-		// never return the mach_header symbol
-		if ( info->dli_saddr == info->dli_fbase ) {
+		info->dli_fname = image->getLogicalPath();
+		info->dli_fbase = (void*)image->machHeader();	
+		// find closest exported symbol in the image
+		const uint32_t exportCount = image->getExportedSymbolCount();
+		const ImageLoader::Symbol* bestSym = NULL;
+		const void* bestAddr = 0;
+		for(uint32_t i=0; i < exportCount; ++i) {
+			const ImageLoader::Symbol* sym = image->getIndexedExportedSymbol(i);
+			const void* symAddr = (void*)image->getExportedSymbolAddress(sym);
+			if ( (symAddr <= address) && (bestAddr < symAddr) ) {
+				bestSym = sym;
+				bestAddr = symAddr;
+			}
+		}
+		if ( bestSym != NULL ) {
+			info->dli_sname = image->getExportedSymbolName(bestSym) + 1; // strip off leading underscore
+			info->dli_saddr = (void*)bestAddr;
+		}
+		else {
 			info->dli_sname = NULL;
 			info->dli_saddr = NULL;
-			CRSetCrashLogMessage(NULL);
-			return 1; // success
-		}
-		if ( info->dli_sname != NULL ) {
-			if ( info->dli_sname[0] == '_' )
-				info->dli_sname = info->dli_sname +1; // strip off leading underscore
-			//dyld::log("dladdr(%p) => %p %s\n", address, info->dli_saddr, info->dli_sname);
-			CRSetCrashLogMessage(NULL);
-			return 1; // success
-		}
-		info->dli_sname = NULL;
-		info->dli_saddr = NULL;
-		CRSetCrashLogMessage(NULL);
+		}
 		return 1; // success
 	}
-	CRSetCrashLogMessage(NULL);
 	return 0;  // failure
 }
 
@@ -1766,45 +1351,26 @@
 char* dlerror()
 {
 	if ( dyld::gLogAPIs )
-		dyld::log("%s()\n", __func__);
-
-	if ( dyld::gLibSystemHelpers != NULL ) {
-		// if using newer libdyld.dylib and buffer if buffer not yet allocated, return NULL
-		if ( dyld::gLibSystemHelpers->version >= 10 ) {
-			if ( ! (*dyld::gLibSystemHelpers->hasPerThreadBufferFor_dlerror)() )
-				return NULL;
-		}
-
-		// first char of buffer is flag whether string (starting at second char) is valid
-		char* buffer = (*dyld::gLibSystemHelpers->getThreadBufferFor_dlerror)(2);
-		if ( buffer[0] != '\0' ) {	// if valid buffer
-			buffer[0] = '\0';		// mark invalid, so next call to dlerror returns NULL
-			return &buffer[1];		// return message
-		}
+		fprintf(stderr, "%s()\n", __func__);
+
+	if ( dyld::gThreadHelpers != NULL ) {
+		char* buffer = (*dyld::gThreadHelpers->getThreadBufferFor_dlerror)(1);
+		// if no error set, return NULL
+		if ( buffer[0] != '\0' )
+			return buffer;
 	}
 	return NULL;
 }
 
-void* dlsym_internal(void* handle, const char* symbolName, void* callerAddress)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, %s)\n", __func__, handle, symbolName);
-
-#if SUPPORT_ACCELERATE_TABLES
-	if ( dyld::gLogAppAPIs ) {
-		const char* shortName;
-		if ( callerIsNonOSApp(callerAddress, &shortName) ) {
-			dyld::log("%s: %s(%p, %s)\n", shortName, __func__, handle, symbolName);
-		}
-	}
-#endif
-
-	CRSetCrashLogMessage("dyld: in dlsym()");
+void* dlsym(void* handle, const char* symbolName)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s(%p, %s)\n", __func__, handle, symbolName);
+
 	dlerrorClear();
 
-	const ImageLoader* image;
+	ImageLoader* image;
 	const ImageLoader::Symbol* sym;
-	void* result;
 
 	// dlsym() assumes symbolName passed in is same as in C source code
 	// dyld assumes all symbol names have an underscore prefix
@@ -1815,413 +1381,238 @@
 	// magic "search all" handle
 	if ( handle == RTLD_DEFAULT ) {
 		if ( dyld::flatFindExportedSymbol(underscoredName, &sym, &image) ) {
-			CRSetCrashLogMessage(NULL);
-			result = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext, NULL, false, underscoredName);
-#if __has_feature(ptrauth_calls)
-			// Sign the pointer if it points to a function
-			// Note we only do this if the main executable is arm64e as otherwise we
-			// may end up calling containsAddress on the accelerator tables.
-			if ( result && (dyld::gLinkContext.mainExecutable->machHeader()->cpusubtype == CPU_SUBTYPE_ARM64_E) ) {
-				const ImageLoader* symbolImage = image;
-				if (!symbolImage->containsAddress(result)) {
-					symbolImage = dyld::findImageContainingAddress(result);
-				}
-				const macho_section *sect = symbolImage ? symbolImage->findSection(result) : NULL;
-				if ( sect && ((sect->flags & S_ATTR_PURE_INSTRUCTIONS) || (sect->flags & S_ATTR_SOME_INSTRUCTIONS)) )
-					result = __builtin_ptrauth_sign_unauthenticated(result, ptrauth_key_asia, 0);
-			}
-#endif
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(RTLD_DEFAULT, %s) ==> %p\n", __func__, symbolName, result);
-			return result;
-		}
-		const char* str = dyld::mkstringf("dlsym(RTLD_DEFAULT, %s): symbol not found", symbolName);
-		dlerrorSet(str);
-		free((void*)str);
-		CRSetCrashLogMessage(NULL);
-		if ( dyld::gLogAPIs )
-			dyld::log("  %s(RTLD_DEFAULT, %s) ==> NULL\n", __func__, symbolName);
-		return NULL;
-	}
-	
-	// magic "search only main executable" handle
-	else if ( handle == RTLD_MAIN_ONLY ) {
-		image = dyld::mainExecutable();
-		sym = image->findExportedSymbol(underscoredName, true, &image); // search RTLD_FIRST way
-		if ( sym != NULL ) {
-			CRSetCrashLogMessage(NULL);
-			result = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext, NULL, false, underscoredName);
-#if __has_feature(ptrauth_calls)
-			// Sign the pointer if it points to a function
-			// Note we only do this if the main executable is arm64e as otherwise we
-			// may end up calling containsAddress on the accelerator tables.
-			if ( result && (dyld::gLinkContext.mainExecutable->machHeader()->cpusubtype == CPU_SUBTYPE_ARM64_E) ) {
-				const ImageLoader* symbolImage = image;
-				if (!symbolImage->containsAddress(result)) {
-					symbolImage = dyld::findImageContainingAddress(result);
-				}
-				const macho_section *sect = symbolImage ? symbolImage->findSection(result) : NULL;
-				if ( sect && ((sect->flags & S_ATTR_PURE_INSTRUCTIONS) || (sect->flags & S_ATTR_SOME_INSTRUCTIONS)) )
-					result = __builtin_ptrauth_sign_unauthenticated(result, ptrauth_key_asia, 0);
-			}
-#endif
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(RTLD_MAIN_ONLY, %s) ==> %p\n", __func__, symbolName, result);
-			return result;
-		}
-		const char* str = dyld::mkstringf("dlsym(RTLD_MAIN_ONLY, %s): symbol not found", symbolName);
-		dlerrorSet(str);
-		free((void*)str);
-		CRSetCrashLogMessage(NULL);
-		if ( dyld::gLogAPIs )
-			dyld::log("  %s(RTLD_MAIN_ONLY, %s) ==> NULL\n", __func__, symbolName);
+			return (void*)image->getExportedSymbolAddress(sym);
+		}
+		const char* format = "dlsym(RTLD_DEFAULT, %s): symbol not found";
+		char temp[strlen(format)+strlen(symbolName)+2];
+		sprintf(temp, format, symbolName);
+		dlerrorSet(temp);
 		return NULL;
 	}
 	
 	// magic "search what I would see" handle
-	else if ( handle == RTLD_NEXT ) {
-#if SUPPORT_ACCELERATE_TABLES
-		const mach_header* mh;
-		const char* path;
-		unsigned index;
-		if ( dyld::addressInCache(callerAddress, &mh, &path, &index) ) {
-			// if dylib in cache is calling dlsym(RTLD_NEXT,xxx) handle search differently
-			result = dyld::dlsymFromCache(RTLD_NEXT, underscoredName, index);
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(RTLD_NEXT, %s) ==> %p\n", __func__, symbolName, result);
-			return result;
-		}
-#endif
+	if ( handle == RTLD_NEXT ) {
+		void* callerAddress = __builtin_return_address(1); // note layers: 1: real client, 0: libSystem glue
 		ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
-		sym = callerImage->findExportedSymbolInDependentImages(underscoredName, dyld::gLinkContext, &image); // don't search image, but do search what it links against
+		sym = callerImage->findExportedSymbolInDependentImages(underscoredName, &image); // don't search image, but do search what it links against
 		if ( sym != NULL ) {
-			CRSetCrashLogMessage(NULL);
-			result = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext , callerImage, false, underscoredName);
-#if __has_feature(ptrauth_calls)
-			// Sign the pointer if it points to a function
-			// Note we only do this if the main executable is arm64e as otherwise we
-			// may end up calling containsAddress on the accelerator tables.
-			if ( result && (dyld::gLinkContext.mainExecutable->machHeader()->cpusubtype == CPU_SUBTYPE_ARM64_E) ) {
-				const ImageLoader* symbolImage = image;
-				if (!symbolImage->containsAddress(result)) {
-					symbolImage = dyld::findImageContainingAddress(result);
-				}
-				const macho_section *sect = symbolImage ? symbolImage->findSection(result) : NULL;
-				if ( sect && ((sect->flags & S_ATTR_PURE_INSTRUCTIONS) || (sect->flags & S_ATTR_SOME_INSTRUCTIONS)) )
-					result = __builtin_ptrauth_sign_unauthenticated(result, ptrauth_key_asia, 0);
-			}
-#endif
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(RTLD_NEXT, %s) ==> %p\n", __func__, symbolName, result);
-			return result;
-		}
-		const char* str = dyld::mkstringf("dlsym(RTLD_NEXT, %s): symbol not found", symbolName);
-		dlerrorSet(str);
-		free((void*)str);
-		CRSetCrashLogMessage(NULL);
-		if ( dyld::gLogAPIs )
-			dyld::log("  %s(RTLD_NEXT, %s) ==> NULL\n", __func__, symbolName);
+			return (void*)image->getExportedSymbolAddress(sym);
+		}
+		const char* format = "dlsym(RTLD_NEXT, %s): symbol not found";
+		char temp[strlen(format)+strlen(symbolName)+2];
+		sprintf(temp, format, symbolName);
+		dlerrorSet(temp);
 		return NULL;
 	}
+#ifdef RTLD_SELF
 	// magic "search me, then what I would see" handle
-	else if ( handle == RTLD_SELF ) {
-#if SUPPORT_ACCELERATE_TABLES
-		const mach_header* mh;
-		const char* path;
-		unsigned index;
-		if ( dyld::addressInCache(callerAddress, &mh, &path, &index) ) {
-			// if dylib in cache is calling dlsym(RTLD_SELF,xxx) handle search differently
-			result = dyld::dlsymFromCache(RTLD_SELF, underscoredName, index);
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(RTLD_SELF, %s) ==> %p\n", __func__, symbolName, result);
-			return result;
-		}
-#endif
+	if ( handle == RTLD_SELF ) {
+		void* callerAddress = __builtin_return_address(1); // note layers: 1: real client, 0: libSystem glue
 		ImageLoader* callerImage = dyld::findImageContainingAddress(callerAddress);
-		sym = callerImage->findExportedSymbolInImageOrDependentImages(underscoredName, dyld::gLinkContext, &image); // search image and what it links against
+		sym = callerImage->findExportedSymbolInImageOrDependentImages(underscoredName, &image); // search image and what it links against
 		if ( sym != NULL ) {
-			CRSetCrashLogMessage(NULL);
-			result = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext, callerImage, false, underscoredName);
-#if __has_feature(ptrauth_calls)
-			// Sign the pointer if it points to a function
-			// Note we only do this if the main executable is arm64e as otherwise we
-			// may end up calling containsAddress on the accelerator tables.
-			if ( result && (dyld::gLinkContext.mainExecutable->machHeader()->cpusubtype == CPU_SUBTYPE_ARM64_E) ) {
-				const ImageLoader* symbolImage = image;
-				if (!symbolImage->containsAddress(result)) {
-					symbolImage = dyld::findImageContainingAddress(result);
-				}
-				const macho_section *sect = symbolImage ? symbolImage->findSection(result) : NULL;
-				if ( sect && ((sect->flags & S_ATTR_PURE_INSTRUCTIONS) || (sect->flags & S_ATTR_SOME_INSTRUCTIONS)) )
-					result = __builtin_ptrauth_sign_unauthenticated(result, ptrauth_key_asia, 0);
-			}
-#endif
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(RTLD_SELF, %s) ==> %p\n", __func__, symbolName, result);
-			return result;
-		}
-		const char* str = dyld::mkstringf("dlsym(RTLD_SELF, %s): symbol not found", symbolName);
-		dlerrorSet(str);
-		free((void*)str);
-		CRSetCrashLogMessage(NULL);
-		if ( dyld::gLogAPIs )
-			dyld::log("  %s(RTLD_SELF, %s) ==> NULL\n", __func__, symbolName);
+			return (void*)image->getExportedSymbolAddress(sym);
+		}
+		const char* format = "dlsym(RTLD_SELF, %s): symbol not found";
+		char temp[strlen(format)+strlen(symbolName)+2];
+		sprintf(temp, format, symbolName);
+		dlerrorSet(temp);
 		return NULL;
-	}
-#if SUPPORT_ACCELERATE_TABLES
-	// check for mega dylib handle
-	else if ( dyld::isCacheHandle(handle) ) {
-		result = dyld::dlsymFromCache(handle, underscoredName, 0);
-		if ( dyld::gLogAPIs )
-			dyld::log("  %s(%p, %s) ==> %p\n", __func__, handle, symbolName, result);
-		return result;
 	}
 #endif
 	// real handle
-	image = (ImageLoader*)(((uintptr_t)handle) & (-4));	// clear mode bits
+	image = (ImageLoader*)handle;
 	if ( dyld::validImage(image) ) {
-		if ( (((uintptr_t)handle) & 1) != 0 )
-			sym = image->findExportedSymbol(underscoredName, true, &image); // search RTLD_FIRST way
-		else
-			sym = image->findExportedSymbolInImageOrDependentImages(underscoredName, dyld::gLinkContext, &image); // search image and what it links against
-		
+		sym = image->findExportedSymbolInImageOrDependentImages(underscoredName, &image); // search image and what it links against
 		if ( sym != NULL ) {
-			CRSetCrashLogMessage(NULL);
-			ImageLoader* callerImage = NULL;
-			if ( sDynamicInterposing ) {
-				// only take time to look up caller, if dynamic interposing in use
-				callerImage = dyld::findImageContainingAddress(callerAddress);
-			}
-			result = (void*)image->getExportedSymbolAddress(sym, dyld::gLinkContext, callerImage, false, underscoredName);
-#if __has_feature(ptrauth_calls)
-			// Sign the pointer if it points to a function
-			// Note we only do this if the main executable is arm64e as otherwise we
-			// may end up calling containsAddress on the accelerator tables.
-			if ( result && (dyld::gLinkContext.mainExecutable->machHeader()->cpusubtype == CPU_SUBTYPE_ARM64_E) ) {
-				const ImageLoader* symbolImage = image;
-				if (!symbolImage->containsAddress(result)) {
-					symbolImage = dyld::findImageContainingAddress(result);
-				}
-				const macho_section *sect = symbolImage ? symbolImage->findSection(result) : NULL;
-				if ( sect && ((sect->flags & S_ATTR_PURE_INSTRUCTIONS) || (sect->flags & S_ATTR_SOME_INSTRUCTIONS)) )
-					result = __builtin_ptrauth_sign_unauthenticated(result, ptrauth_key_asia, 0);
-			}
-#endif
-			if ( dyld::gLogAPIs )
-				dyld::log("  %s(%p, %s) ==> %p\n", __func__, handle, symbolName, result);
-			return result;
-		}
-		const char* str = dyld::mkstringf("dlsym(%p, %s): symbol not found", handle, symbolName);
-		dlerrorSet(str);
-		free((void*)str);
+			return (void*)image->getExportedSymbolAddress(sym);
+		}
+		const char* format = "dlsym(%p, %s): symbol not found";
+		char temp[strlen(format)+strlen(symbolName)+20];
+		sprintf(temp, format, handle, symbolName);
+		dlerrorSet(temp);
 	}
 	else {
 		dlerrorSet("invalid handle passed to dlsym()");
 	}
-	CRSetCrashLogMessage(NULL);
-	if ( dyld::gLogAPIs )
-		dyld::log("  %s(%p, %s) ==> NULL\n", __func__, handle, symbolName);
 	return NULL;
 }
 
-// Note this is only here to support ___pthread_abort in libpthread.a
-void* dlsym(void* handle, const char* symbolName) {
-	return dlsym_internal(handle, symbolName, __builtin_return_address(1));
-}
-
-
-// <rdar://problem/40352925> *_compat functions are for old binaries that have __dyld section and use it to bypass libdyld.dylib
-void* dlopen_compat(const char* path, int mode)
-{
-	return dlopen_internal(path, mode, (void*)dyld::mainExecutable()->machHeader());
-}
-bool  dlopen_preflight_compat(const char* path)
-{
-	return dlopen_preflight_internal(path, (void*)dyld::mainExecutable()->machHeader());
-}
-void* dlsym_compat(void* handle, const char* symbolName)
-{
-	return dlsym_internal(handle, symbolName, (void*)dyld::mainExecutable()->machHeader());
-}
-
-
-
-
-const struct dyld_all_image_infos* _dyld_get_all_image_infos()
-{
-	return dyld::gProcessInfo;
-}
-
-
-#if SUPPORT_ZERO_COST_EXCEPTIONS
-static bool client_dyld_find_unwind_sections(void* addr, dyld_unwind_sections* info)
-{
-	//if ( dyld::gLogAPIs )
-	//	dyld::log("%s(%p, %p)\n", __func__, addr, info);
-
-	addr = stripPointer(addr);
+
+static void commitRepreboundFiles(std::vector<ImageLoader*> files, bool unmapOld)
+{
+	// tell file system to flush all dirty buffers to disk
+	// after this sync, the _redoprebinding files will be on disk
+	sync();
+
+	// now commit (swap file) for each re-prebound image
+	// this only updates directories, since the files have already been flushed by previous sync()
+	for (std::vector<ImageLoader*>::iterator it=files.begin(); it != files.end(); it++) {
+		(*it)->reprebindCommit(dyld::gLinkContext, true, unmapOld);
+	}
+
+	// tell file system to flush all dirty buffers to disk
+	// this should flush out all directory changes caused by the file swapping
+	sync();
+}
+
+
+#define UPDATE_PREBINDING_DRY_RUN  0x00000001
+#define UPDATE_PREBINDING_PROGRESS 0x00000002
+
+//
+// SPI called only by update_prebinding tool to redo prebinding in all prebound files specified
+// There must be no dylibs loaded when this fnction is called.
+//
+__attribute__((noreturn))
+static void _dyld_update_prebinding(int pathCount, const char* paths[], uint32_t flags)
+{
+	if ( dyld::gLogAPIs )
+		fprintf(stderr, "%s()\n", __func__);
+
+	// list of requested dylibs actually loaded
+	std::vector<ImageLoader*> preboundImages;
 	
-#if SUPPORT_ACCELERATE_TABLES
-	if ( dyld::findUnwindSections(addr, info) )
-		return true;
-#endif
-	ImageLoader* image = dyld::findImageContainingAddress(addr);
-	if ( image != NULL ) {
-		image->getUnwindInfo(info);
-		return true;
-	}
-	return false;
-}
-#endif
-
-
-const char* dyld_image_path_containing_address(const void* address)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, address);
-
-    address = (void*)stripPointer(address);
-    
-#if SUPPORT_ACCELERATE_TABLES
-	const mach_header* mh;
-	const char* path;
-	if ( dyld::addressInCache(address, &mh, &path) )
-		return path;
-#endif
-
-	ImageLoader* image = dyld::findImageContainingAddress(address);
-	if ( image != NULL )
-		return image->getRealPath();
-	return NULL;
-}
-
-
-
-bool dyld_shared_cache_some_image_overridden()
-{
-	return dyld::gSharedCacheOverridden;
-}
-
-
-void dyld_dynamic_interpose(const struct mach_header* mh, const struct dyld_interpose_tuple array[], size_t count)
-{
-	if ( mh == NULL )
-		return;
-	if ( array == NULL )
-		return;
-	if ( count == 0 )
-		return;
-	ImageLoader* image = dyld::findImageByMachHeader(mh);
-	if ( image == NULL )
-		return;
-	
-	// make pass at bound references in this image and update them
-	dyld::gLinkContext.dynamicInterposeArray = array;
-	dyld::gLinkContext.dynamicInterposeCount = count;
-		image->dynamicInterpose(dyld::gLinkContext);
-	dyld::gLinkContext.dynamicInterposeArray = NULL;
-	dyld::gLinkContext.dynamicInterposeCount = 0;
-	
-	// leave interposing info so any future (lazy) binding will get it too
-	image->addDynamicInterposingTuples(array, count);
-	
-	sDynamicInterposing = true;
-}
-
-
-bool _dyld_is_memory_immutable(const void* addr, size_t length)
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p, %ld)\n", __func__, addr, length);
-
-	uintptr_t checkStart = (uintptr_t)addr;
-	uintptr_t checkEnd   = checkStart + length;
-
-	// quick check to see if in r/o region of shared cache.  If so return true.
-    const DyldSharedCache* cache = (DyldSharedCache*)dyld::imMemorySharedCacheHeader();
-    if ( cache != nullptr ) {
-        const dyld_cache_mapping_info* const mappings = (dyld_cache_mapping_info*)((char*)cache + cache->header.mappingOffset);
-		uintptr_t roStart    = (uintptr_t)cache;
-		uintptr_t roEnd      = roStart + (uintptr_t)mappings[0].size;
-		if ( (roStart < checkStart) && (checkEnd < roEnd) )
-			return true;
-    }
-
-	// Otherwise find if addr is in a dyld loaded image
-	ImageLoader* image = dyld::findImageContainingAddress(addr);
-	if ( image != NULL ) {
-		// <rdar://problem/24091154> already checked for r/o portion of cache
-		if ( image->inSharedCache() )
-			return false;
-		if ( !image->neverUnload() )
-			return false;
-		for (unsigned i=0, e=image->segmentCount(); i < e; ++i) {
-			if ( (image->segActualLoadAddress(i) < checkStart) && (checkEnd < image->segActualEndAddress(i)) ) {
-				return !image->segWriteable(i);
+	try {
+		// verify no dylibs loaded
+		if ( dyld::getImageCount() != 1 )
+			throw "_dyld_update_prebinding cannot be called with dylib already loaded";
+			
+		const uint32_t max_allowed_link_errors = 10;
+		uint32_t link_error_count = 0;
+		
+		// load and link each dylib
+		for (int i=0; i < pathCount; ++i) {
+			dyld::LoadContext context;
+			context.useSearchPaths		= false;
+			context.matchByInstallName	= true;
+			context.dontLoad			= false;
+			context.mustBeBundle		= false;
+			context.mustBeDylib			= true;
+			context.origin				= NULL;		// @loader_path not allowed in prebinding list
+			context.rpath				= NULL;		// support not yet implemented
+			
+			ImageLoader* image = NULL;
+			try {
+				image = dyld::load(paths[i], context);
+				// bind lazy and non-lazy symbols, but don't run initializers
+				// this may bring in other dylibs later in the list or missing from list, but that is ok
+				dyld::link(image, ImageLoader::kLazyAndNonLazy, ImageLoader::kDontRunInitializers);
+				// recored images we successfully loaded
+				preboundImages.push_back(image);
 			}
-		}
-	}
-	return false;
-}
-
-
-
-void _dyld_objc_notify_register(_dyld_objc_notify_mapped    mapped,
-                                _dyld_objc_notify_init      init,
-                                _dyld_objc_notify_unmapped  unmapped)
-{
-	dyld::registerObjCNotifiers(mapped, init, unmapped);
-}
-
-
-bool _dyld_get_shared_cache_uuid(uuid_t uuid)
-{
-	return dyld::sharedCacheUUID(uuid);
-}
-
-const void* _dyld_get_shared_cache_range(size_t* length)
-{
-    const DyldSharedCache* cache = (DyldSharedCache*)dyld::imMemorySharedCacheHeader();
-    if ( cache != nullptr ) {
-        const dyld_cache_mapping_info* const mappings = (dyld_cache_mapping_info*)((char*)cache + cache->header.mappingOffset);
-        *length = (size_t)((mappings[2].address + mappings[2].size) - mappings[0].address);
-        return cache;
-    }
-	return nullptr;
-}
-
-void _dyld_images_for_addresses(unsigned count, const void* addresses[], struct dyld_image_uuid_offset infos[])
-{
-	for (unsigned i=0; i < count; ++i) {
-        const void* addr = addresses[i];
-		addr = stripPointer(addr);
-        bzero(&infos[i], sizeof(dyld_image_uuid_offset));
-#if SUPPORT_ACCELERATE_TABLES
-		const mach_header* 	mh;
-		const char* 		path;
-		if ( dyld::addressInCache(addr, &mh, &path) ) {
-			infos[i].image         = mh;
-			infos[i].offsetInImage = (uintptr_t)addr - (uintptr_t)mh;
-			((dyld3::MachOFile*)mh)->getUuid(infos[i].uuid);
-			break;
-		}
-#endif
-		ImageLoader* image = dyld::findImageContainingAddress(addr);
-        if ( image != nullptr ) {
-            infos[i].image         = image->machHeader();
-            infos[i].offsetInImage = (uintptr_t)addr - (uintptr_t)(image->machHeader());
-            image->getUUID(infos[i].uuid);
-        }
-    }
-}
-
-void _dyld_register_for_image_loads(void (*func)(const mach_header* mh, const char* path, bool unloadable))
-{
-	if ( dyld::gLogAPIs )
-		dyld::log("%s(%p)\n", __func__, (void *)func);
-	dyld::registerLoadCallback(func);
-}
-
-
-
-
+			catch (const char* msg) {
+				if ( dyld::gLinkContext.verbosePrebinding || (UPDATE_PREBINDING_DRY_RUN & flags) ) {
+					const char *stage;
+					if ( image == NULL ) // load exception
+						stage = "load";
+					else // link exception
+						stage = "link";
+					fprintf(stderr, "update_prebinding: warning: could not %s %s: %s\n", stage, paths[i], msg);
+				}
+				if ( image != NULL )
+					link_error_count++;
+				if ( link_error_count > max_allowed_link_errors )
+					throw;
+			}
+		}
+		
+		// find missing images
+		uint32_t loadedImageCount =	dyld::getImageCount();
+		if ( loadedImageCount > (preboundImages.size()+1) ) {
+			if ( dyld::gLinkContext.verbosePrebinding || (UPDATE_PREBINDING_DRY_RUN & flags) )
+				fprintf(stderr, "update_prebinding: warning: the following dylibs were loaded but will not have their prebinding updated because they are not in the list of paths to reprebind\n");
+			for (uint32_t i=1; i < loadedImageCount; ++i) {
+				ImageLoader* target = dyld::getIndexedImage(i);
+				bool found = false;
+				for (std::vector<ImageLoader*>::iterator it=preboundImages.begin(); it != preboundImages.end(); it++) {
+					if ( *it == target ) {
+						found = true;
+						break;
+					}
+				}
+				if ( !found ) 
+					if ( dyld::gLinkContext.verbosePrebinding || (UPDATE_PREBINDING_DRY_RUN & flags) )
+						fprintf(stderr, "  %s\n", target->getPath());
+			}
+		}
+
+		// warn about unprebound files in the list
+		bool unpreboundWarned = false;
+		for (std::vector<ImageLoader*>::iterator it=preboundImages.begin(); it != preboundImages.end(); it++) {
+			if ( ! (*it)->isPrebindable() && (*it != dyld::mainExecutable()) ) {
+				if ( ! unpreboundWarned ) {
+					if ( dyld::gLinkContext.verbosePrebinding || (UPDATE_PREBINDING_DRY_RUN & flags) )
+						fprintf(stderr, "update_prebinding: warning: the following dylibs were specified but were not built prebound\n");
+					unpreboundWarned = true;
+				}
+				if ( dyld::gLinkContext.verbosePrebinding || (UPDATE_PREBINDING_DRY_RUN & flags) )
+					fprintf(stderr, "  %s\n", (*it)->getPath());
+			}
+		}
+		
+		if(UPDATE_PREBINDING_DRY_RUN & flags) {
+			fprintf(stderr, "update_prebinding: dry-run: no changes were made to the filesystem.\n");
+		}
+		else {
+			uint32_t imageCount = preboundImages.size();
+			uint32_t imageNumber = 1;
+			// tell each image to write itself out re-prebound
+			struct timeval currentTime = { 0 , 0 };
+			gettimeofday(&currentTime, NULL);
+			time_t timestamp = currentTime.tv_sec;
+			std::vector<ImageLoader*> updatedImages;
+			for (std::vector<ImageLoader*>::iterator it=preboundImages.begin(); it != preboundImages.end(); it++) {
+				uint64_t freespace = (*it)->reprebind(dyld::gLinkContext, timestamp);
+				updatedImages.push_back(*it);
+				if(UPDATE_PREBINDING_PROGRESS & flags) {
+					fprintf(stdout, "update_prebinding: progress: %3u/%u\n", imageNumber, imageCount);
+					fflush(stdout);
+					imageNumber++;
+				}
+				// see if we are running low on disk space (less than 32MB is "low")
+				const uint64_t kMinFreeSpace = 32*1024*1024;  
+				if ( freespace < kMinFreeSpace ) {
+					if ( dyld::gLinkContext.verbosePrebinding || (UPDATE_PREBINDING_DRY_RUN & flags) )
+						fprintf(stderr, "update_prebinding: disk space down to %lluMB, committing %lu prebound files\n", freespace/(1024*1024), updatedImages.size());
+					// commit files processed so far, to free up more disk space
+					commitRepreboundFiles(updatedImages, true);
+					// empty list of temp files
+					updatedImages.clear();
+				}
+			}
+		
+			// commit them, don't need to unmap old, cause we are done
+			commitRepreboundFiles(updatedImages, false);
+		}
+	}
+	catch (const char* msg) {
+		// delete temp files
+		try {
+			for (std::vector<ImageLoader*>::iterator it=preboundImages.begin(); it != preboundImages.end(); it++) {
+				(*it)->reprebindCommit(dyld::gLinkContext, false, false);
+			}
+		}
+		catch (const char* commitMsg) {
+			fprintf(stderr, "update_prebinding: error: %s\n", commitMsg);
+		}
+		fprintf(stderr, "update_prebinding: error: %s\n", msg);
+		exit(1);
+	}
+	exit(0);
+}
+
+
+
+static const struct dyld_all_image_infos* _dyld_get_all_image_infos()
+{
+	return &dyld_all_image_infos;
+}
+
+
+
+
+
+
+
+