1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
3 * Copyright (c) 2004-2006 Apple Computer, Inc. All rights reserved.
5 * @APPLE_LICENSE_HEADER_START@
7 * This file contains Original Code and/or Modifications of Original Code
8 * as defined in and that are subject to the Apple Public Source License
9 * Version 2.0 (the 'License'). You may not use this file except in
10 * compliance with the License. Please obtain a copy of the License at
11 * http://www.opensource.apple.com/apsl/ and read it before using this
14 * The Original Code and all software distributed under the License are
15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19 * Please see the License for the specific language governing rights and
20 * limitations under the License.
22 * @APPLE_LICENSE_HEADER_END@
29 #include <sys/param.h>
30 #include <mach/mach_time.h> // mach_absolute_time()
31 #include <sys/types.h>
33 #include <mach-o/fat.h>
34 #include <mach-o/loader.h>
35 #include <libkern/OSByteOrder.h>
36 #include <mach/mach.h>
37 #include <sys/sysctl.h>
41 #include "mach-o/dyld_gdb.h"
44 #include "ImageLoader.h"
45 #include "ImageLoaderMachO.h"
46 #include "dyldLibSystemThreadHelpers.h"
49 #define CPU_TYPE_MASK 0x00FFFFFF /* complement of CPU_ARCH_MASK */
52 /* implemented in dyld_gdb.cpp */
53 void addImagesToAllImages(uint32_t infoCount
, const dyld_image_info info
[]);
54 void removeImageFromAllImages(const mach_header
* mh
);
55 #if OLD_GDB_DYLD_INTERFACE
56 void addImageForgdb(const mach_header
* mh
, uintptr_t slide
, const char* physicalPath
, const char* logicalPath
);
57 void removeImageForgdb(const struct mach_header
* mh
);
60 // magic so CrashReporter logs message
62 char error_string
[1024];
67 // The file contains the core of dyld used to get a process to main().
68 // The API's that dyld supports are implemented in dyldAPIs.cpp.
80 // state of all environment variables dyld uses
82 struct EnvironmentVariables
{
83 const char* const * DYLD_FRAMEWORK_PATH
;
84 const char* const * DYLD_FALLBACK_FRAMEWORK_PATH
;
85 const char* const * DYLD_LIBRARY_PATH
;
86 const char* const * DYLD_FALLBACK_LIBRARY_PATH
;
87 const char* const * DYLD_ROOT_PATH
;
88 const char* const * DYLD_INSERT_LIBRARIES
;
89 const char* const * LD_LIBRARY_PATH
; // for unix conformance
90 bool DYLD_PRINT_LIBRARIES
;
91 bool DYLD_PRINT_LIBRARIES_POST_LAUNCH
;
92 bool DYLD_BIND_AT_LAUNCH
;
93 bool DYLD_PRINT_STATISTICS
;
96 // DYLD_IMAGE_SUFFIX ==> gLinkContext.imageSuffix
97 // DYLD_PRINT_OPTS ==> gLinkContext.verboseOpts
98 // DYLD_PRINT_ENV ==> gLinkContext.verboseEnv
99 // DYLD_FORCE_FLAT_NAMESPACE ==> gLinkContext.bindFlat
100 // DYLD_PRINT_INITIALIZERS ==> gLinkContext.verboseInit
101 // DYLD_PRINT_SEGMENTS ==> gLinkContext.verboseMapping
102 // DYLD_PRINT_BINDINGS ==> gLinkContext.verboseBind
103 // DYLD_PRINT_REBASINGS ==> gLinkContext.verboseRebase
104 // DYLD_PRINT_APIS ==> gLogAPIs
105 // DYLD_IGNORE_PREBINDING ==> gLinkContext.prebindUsage
106 // DYLD_PREBIND_DEBUG ==> gLinkContext.verbosePrebinding
107 // DYLD_NEW_LOCAL_SHARED_REGIONS ==> gLinkContext.sharedRegionMode
108 // DYLD_SHARED_REGION ==> gLinkContext.sharedRegionMode
109 // DYLD_SLIDE_AND_PACK_DYLIBS ==> gLinkContext.slideAndPackDylibs
110 // DYLD_PRINT_WARNINGS ==> gLinkContext.verboseWarnings
114 static const char* sExecPath
= NULL
;
115 static const struct mach_header
* sMainExecutableMachHeader
= NULL
;
116 static cpu_type_t sHostCPU
;
117 static cpu_subtype_t sHostCPUsubtype
;
118 static ImageLoader
* sMainExecutable
= NULL
;
119 static bool sAllImagesMightContainUnlinkedImages
; // necessary until will support dylib unloading
120 static std
::vector
<ImageLoader
*> sAllImages
;
121 static std
::vector
<ImageLoader
*> sImageRoots
;
122 static std
::vector
<ImageLoader
*> sImageFilesNeedingTermination
;
123 static std
::vector
<ImageLoader
*> sImagesToNotifyAboutOtherImages
;
124 static std
::vector
<ImageCallback
> sAddImageCallbacks
;
125 static std
::vector
<ImageCallback
> sRemoveImageCallbacks
;
126 static ImageLoader
* sLastImageByAddressCache
;
127 static EnvironmentVariables sEnv
;
128 static const char* sFrameworkFallbackPaths
[] = { "$HOME/Library/Frameworks", "/Library/Frameworks", "/Network/Library/Frameworks", "/System/Library/Frameworks", NULL
};
129 static const char* sLibraryFallbackPaths
[] = { "$HOME/lib", "/usr/local/lib", "/usr/lib", NULL
};
130 static BundleNotificationCallBack sBundleNotifier
= NULL
;
131 static BundleLocatorCallBack sBundleLocation
= NULL
;
132 static UndefinedHandler sUndefinedHandler
= NULL
;
133 ImageLoader
::LinkContext gLinkContext
;
134 bool gLogAPIs
= false;
135 const struct ThreadingHelpers
* gThreadHelpers
= NULL
;
139 // utility class to assure files are closed when an exception is thrown
142 FileOpener(const char* path
);
144 int getFileDescriptor() { return fd
; }
149 FileOpener
::FileOpener(const char* path
)
151 fd
= open(path
, O_RDONLY
, 0);
154 FileOpener
::~FileOpener()
161 // Objective-C installs an addImage hook to dyld to get notified about new images
162 // The callback needs to be run after the image is rebased and bound, but before its initializers are called
163 static uint32_t imageNotification(ImageLoader
* image
, uint32_t startIndex
)
165 // tell all register add image handlers about this
166 const uint32_t callbackCount
= sAddImageCallbacks
.size();
167 for (uint32_t i
=startIndex
; i
< callbackCount
; ++i
) {
168 ImageCallback cb
= sAddImageCallbacks
[i
];
169 //fprintf(stderr, "dyld: calling add-image-callback[%d]=%p for %s\n", i, cb, image->getPath());
170 (cb
)(image
->machHeader(), image
->getSlide());
172 return callbackCount
;
177 // notify gdb et al about these new images
178 static void notifyAdding(std
::vector
<ImageLoader
*>& images
)
181 unsigned int len
= images
.size();
183 dyld_image_info infos
[len
];
184 for (unsigned int i
=0; i
< len
; ++i
) {
185 dyld_image_info
* p
= &infos
[i
];
186 ImageLoader
* image
= images
[i
];
187 p
->imageLoadAddress
= image
->machHeader();
188 p
->imageFilePath
= image
->getPath();
189 p
->imageFileModDate
= image
->lastModified();
190 //fprintf(stderr, "notifying objc about %s\n", image->getPath());
194 addImagesToAllImages(len
, infos
);
196 // tell all interested images (after gdb, so you can debug anything the notification does)
197 for (std
::vector
<ImageLoader
*>::iterator it
=sImagesToNotifyAboutOtherImages
.begin(); it
!= sImagesToNotifyAboutOtherImages
.end(); it
++) {
198 (*it
)->doNotification(dyld_image_adding
, len
, infos
);
205 // In order for register_func_for_add_image() callbacks to to be called bottom up,
206 // we need to maintain a list of root images. The main executable is usally the
207 // first root. Any images dynamically added are also roots (unless already loaded).
208 // If DYLD_INSERT_LIBRARIES is used, those libraries are first.
209 static void addRootImage(ImageLoader
* image
)
211 //fprintf(stderr, "addRootImage(%p, %s)\n", image, image->getPath());
212 // add to list of roots
213 sImageRoots
.push_back(image
);
216 // Objective-C will contain a __DATA/__image_notify section which contains pointers to a function to call
217 // whenever any new image is loaded.
218 static void addImageNeedingNotification(ImageLoader
* image
)
220 sImagesToNotifyAboutOtherImages
.push_back(image
);
223 static void addImage(ImageLoader
* image
)
225 // add to master list
226 sAllImages
.push_back(image
);
228 if ( sEnv
.DYLD_PRINT_LIBRARIES
|| (sEnv
.DYLD_PRINT_LIBRARIES_POST_LAUNCH
&& (sMainExecutable
!=NULL
) && sMainExecutable
->isLinked()) ) {
229 uint64_t offset
= image
->getOffsetInFatFile();
231 fprintf(stderr
, "dyld: loaded: %s\n", image
->getPath());
233 fprintf(stderr
, "dyld: loaded: %s, cpu-sub-type: %d\n", image
->getPath(), image
->machHeader()->cpusubtype
);
236 #if OLD_GDB_DYLD_INTERFACE
237 // let gdb find out about this
238 addImageForgdb(image
->machHeader(), image
->getSlide(), image
->getPath(), image
->getLogicalPath());
242 void removeImage(ImageLoader
* image
)
244 // if in termination list, pull it out and run terminator
245 for (std
::vector
<ImageLoader
*>::iterator it
=sImageFilesNeedingTermination
.begin(); it
!= sImageFilesNeedingTermination
.end(); it
++) {
246 if ( *it
== image
) {
247 sImageFilesNeedingTermination
.erase(it
);
248 image
->doTermination(gLinkContext
);
253 // tell all register add image handlers about this
254 // do this before removing image from internal data structures so that the callback can querey dyld about the image
255 for (std
::vector
<ImageCallback
>::iterator it
=sRemoveImageCallbacks
.begin(); it
!= sRemoveImageCallbacks
.end(); it
++) {
256 (*it
)(image
->machHeader(), image
->getSlide());
259 // tell all interested images
260 for (std
::vector
<ImageLoader
*>::iterator it
=sImagesToNotifyAboutOtherImages
.begin(); it
!= sImagesToNotifyAboutOtherImages
.end(); it
++) {
261 dyld_image_info info
;
262 info
.imageLoadAddress
= image
->machHeader();
263 info
.imageFilePath
= image
->getPath();
264 info
.imageFileModDate
= image
->lastModified();
265 (*it
)->doNotification(dyld_image_removing
, 1, &info
);
268 // remove from master list
269 for (std
::vector
<ImageLoader
*>::iterator it
=sAllImages
.begin(); it
!= sAllImages
.end(); it
++) {
270 if ( *it
== image
) {
271 sAllImages
.erase(it
);
276 // flush find-by-address cache
277 if ( sLastImageByAddressCache
== image
)
278 sLastImageByAddressCache
= NULL
;
280 // if in announcement list, pull it out
281 for (std
::vector
<ImageLoader
*>::iterator it
=sImagesToNotifyAboutOtherImages
.begin(); it
!= sImagesToNotifyAboutOtherImages
.end(); it
++) {
282 if ( *it
== image
) {
283 sImagesToNotifyAboutOtherImages
.erase(it
);
288 // if in root list, pull it out
289 for (std
::vector
<ImageLoader
*>::iterator it
=sImageRoots
.begin(); it
!= sImageRoots
.end(); it
++) {
290 if ( *it
== image
) {
291 sImageRoots
.erase(it
);
297 removeImageFromAllImages(image
->machHeader());
299 #if OLD_GDB_DYLD_INTERFACE
301 removeImageForgdb(image
->machHeader());
302 gdb_dyld_state_changed();
307 static void terminationRecorder(ImageLoader
* image
)
309 sImageFilesNeedingTermination
.push_back(image
);
312 const char* getExecutablePath()
318 void initializeMainExecutable()
320 const int rootCount
= sImageRoots
.size();
321 for(int i
=0; i
< rootCount
; ++i
) {
322 ImageLoader
* image
= sImageRoots
[i
];
323 //fprintf(stderr, "initializeMainExecutable: image = %p\n", image);
324 image
->runInitializers(gLinkContext
);
327 // this does not work???
328 for (std::vector<ImageLoader*>::iterator it=sImageRoots.begin(); it != sImageRoots.end(); it++) {
329 ImageLoader* image = *it;
330 fprintf(stderr, "initializeMainExecutable: image = %p\n", image);
331 // don't know why vector sometimes starts with NULL element???
333 image->runInitializers(gLinkContext);
336 if ( sEnv
.DYLD_PRINT_STATISTICS
)
337 ImageLoaderMachO
::printStatistics(sAllImages
.size());
340 bool mainExecutablePrebound()
342 return sMainExecutable
->usablePrebinding(gLinkContext
);
345 ImageLoader
* mainExecutable()
347 return sMainExecutable
;
351 void runTerminators()
353 const unsigned int imageCount
= sImageFilesNeedingTermination
.size();
354 for(unsigned int i
=imageCount
; i
> 0; --i
){
355 ImageLoader
* image
= sImageFilesNeedingTermination
[i
-1];
356 image
->doTermination(gLinkContext
);
358 sImageFilesNeedingTermination
.clear();
363 // Turns a colon separated list of strings
364 // into a NULL terminated array of string
367 static const char** parseColonList(const char* list
)
369 if ( list
[0] == '\0' )
373 for(const char* s
=list
; *s
!= '\0'; ++s
) {
379 const char* start
= list
;
380 char** result
= new char*[colonCount
+2];
381 for(const char* s
=list
; *s
!= '\0'; ++s
) {
384 char* str
= new char[len
+1];
385 strncpy(str
, start
, len
);
388 result
[index
++] = str
;
391 int len
= strlen(start
);
392 char* str
= new char[len
+1];
394 result
[index
++] = str
;
395 result
[index
] = NULL
;
397 return (const char**)result
;
401 * Library path searching is not done for setuid programs
402 * which are not run by the real user. Futher the
403 * evironment varaible for the library path is cleared so
404 * that if this program executes a non-set uid program this
405 * part of the evironment will not be passed along so that
406 * that program also will not have it's libraries searched
409 static bool riskyUser()
411 static bool checked
= false;
412 static bool risky
= false;
414 risky
= ( getuid() != 0 && (getuid() != geteuid() || getgid() != getegid()) );
421 static bool disableIfBadUser(char* rhs
)
423 bool didDisable
= false;
431 static void paths_expand_roots(const char **paths
, const char *key
, const char *val
)
433 // assert(val != NULL);
434 // assert(paths != NULL);
436 size_t keyLen
= strlen(key
);
437 for(int i
=0; paths
[i
] != NULL
; ++i
) {
438 if ( strncmp(paths
[i
], key
, keyLen
) == 0 ) {
439 char* newPath
= new char[strlen(val
) + (strlen(paths
[i
]) - keyLen
) + 1];
440 strcpy(newPath
, val
);
441 strcat(newPath
, &paths
[i
][keyLen
]);
449 static void removePathWithPrefix(const char* paths
[], const char* prefix
)
451 size_t prefixLen
= strlen(prefix
);
452 for(int s
=0,d
=0; (paths
[d
] != NULL
) && (paths
[s
] != NULL
); ++s
, ++d
) {
453 if ( strncmp(paths
[s
], prefix
, prefixLen
) == 0 )
460 static void paths_dump(const char **paths
)
462 // assert(paths != NULL);
463 const char **strs
= paths
;
466 fprintf(stderr
, "\"%s\"\n", *strs
);
473 static void printOptions(const char* argv
[])
476 while ( NULL
!= argv
[i
] ) {
477 fprintf(stderr
, "opt[%i] = \"%s\"\n", i
, argv
[i
]);
482 static void printEnvironmentVariables(const char* envp
[])
484 while ( NULL
!= *envp
) {
485 fprintf(stderr
, "%s\n", *envp
);
492 void processDyldEnvironmentVarible(const char* key
, const char* value
)
494 if ( strcmp(key
, "DYLD_FRAMEWORK_PATH") == 0 ) {
495 if ( !disableIfBadUser((char*)value
) )
496 sEnv
.DYLD_FRAMEWORK_PATH
= parseColonList(value
);
498 else if ( strcmp(key
, "DYLD_FALLBACK_FRAMEWORK_PATH") == 0 ) {
499 if ( !disableIfBadUser((char*)value
) )
500 sEnv
.DYLD_FALLBACK_FRAMEWORK_PATH
= parseColonList(value
);
502 else if ( strcmp(key
, "DYLD_LIBRARY_PATH") == 0 ) {
503 if ( !disableIfBadUser((char*)value
) )
504 sEnv
.DYLD_LIBRARY_PATH
= parseColonList(value
);
506 else if ( strcmp(key
, "DYLD_FALLBACK_LIBRARY_PATH") == 0 ) {
507 if ( !disableIfBadUser((char*)value
) )
508 sEnv
.DYLD_FALLBACK_LIBRARY_PATH
= parseColonList(value
);
510 else if ( (strcmp(key
, "DYLD_ROOT_PATH") == 0) || (strcmp(key
, "DYLD_PATHS_ROOT") == 0) ) {
511 if ( !disableIfBadUser((char*)value
) ) {
512 if ( strcmp(value
, "/") != 0 ) {
513 sEnv
.DYLD_ROOT_PATH
= parseColonList(value
);
514 for (int i
=0; sEnv
.DYLD_ROOT_PATH
[i
] != NULL
; ++i
) {
515 if ( sEnv
.DYLD_ROOT_PATH
[i
][0] != '/' ) {
516 fprintf(stderr
, "dyld: warning DYLD_ROOT_PATH not used because it contains a non-absolute path\n");
517 sEnv
.DYLD_ROOT_PATH
= NULL
;
524 else if ( strcmp(key
, "DYLD_IMAGE_SUFFIX") == 0 ) {
525 if ( !disableIfBadUser((char*)value
) )
526 gLinkContext
.imageSuffix
= value
;
528 else if ( strcmp(key
, "DYLD_INSERT_LIBRARIES") == 0 ) {
529 if ( !disableIfBadUser((char*)value
) )
530 sEnv
.DYLD_INSERT_LIBRARIES
= parseColonList(value
);
532 else if ( strcmp(key
, "DYLD_DEBUG_TRACE") == 0 ) {
533 fprintf(stderr
, "dyld: warning DYLD_DEBUG_TRACE not supported\n");
535 else if ( strcmp(key
, "DYLD_ERROR_PRINT") == 0 ) {
536 fprintf(stderr
, "dyld: warning DYLD_ERROR_PRINT not supported\n");
538 else if ( strcmp(key
, "DYLD_PRINT_OPTS") == 0 ) {
539 sEnv
.DYLD_PRINT_OPTS
= true;
541 else if ( strcmp(key
, "DYLD_PRINT_ENV") == 0 ) {
542 sEnv
.DYLD_PRINT_ENV
= true;
544 else if ( strcmp(key
, "DYLD_PRINT_LIBRARIES") == 0 ) {
545 sEnv
.DYLD_PRINT_LIBRARIES
= true;
547 else if ( strcmp(key
, "DYLD_PRINT_LIBRARIES_POST_LAUNCH") == 0 ) {
548 sEnv
.DYLD_PRINT_LIBRARIES_POST_LAUNCH
= true;
550 else if ( strcmp(key
, "DYLD_TRACE") == 0 ) {
551 fprintf(stderr
, "dyld: warning DYLD_TRACE not supported\n");
553 else if ( strcmp(key
, "DYLD_EBADEXEC_ONLY") == 0 ) {
554 fprintf(stderr
, "dyld: warning DYLD_EBADEXEC_ONLY not supported\n");
556 else if ( strcmp(key
, "DYLD_BIND_AT_LAUNCH") == 0 ) {
557 sEnv
.DYLD_BIND_AT_LAUNCH
= true;
559 else if ( strcmp(key
, "DYLD_FORCE_FLAT_NAMESPACE") == 0 ) {
560 gLinkContext
.bindFlat
= true;
562 else if ( strcmp(key
, "DYLD_DEAD_LOCK_HANG") == 0 ) {
563 fprintf(stderr
, "dyld: warning DYLD_DEAD_LOCK_HANG not supported\n");
565 else if ( strcmp(key
, "DYLD_ABORT_MULTIPLE_INITS") == 0 ) {
566 fprintf(stderr
, "dyld: warning DYLD_ABORT_MULTIPLE_INITS not supported\n");
568 else if ( strcmp(key
, "DYLD_NEW_LOCAL_SHARED_REGIONS") == 0 ) {
569 gLinkContext
.sharedRegionMode
= ImageLoader
::kUsePrivateSharedRegion
;
571 else if ( strcmp(key
, "DYLD_SLIDE_AND_PACK_DYLIBS") == 0 ) {
572 gLinkContext
.slideAndPackDylibs
= true;
574 else if ( strcmp(key
, "DYLD_NO_FIX_PREBINDING") == 0 ) {
575 // since the new dyld never runs fix_prebinding, no need to warn if someone does not want it run
576 //fprintf(stderr, "dyld: warning DYLD_NO_FIX_PREBINDING not supported\n");
578 else if ( strcmp(key
, "DYLD_PREBIND_DEBUG") == 0 ) {
579 gLinkContext
.verbosePrebinding
= true;
581 else if ( strcmp(key
, "DYLD_HINTS_DEBUG") == 0 ) {
582 fprintf(stderr
, "dyld: warning DYLD_HINTS_DEBUG not supported\n");
584 else if ( strcmp(key
, "DYLD_SAMPLE_DEBUG") == 0 ) {
585 fprintf(stderr
, "dyld: warning DYLD_SAMPLE_DEBUG not supported\n");
587 else if ( strcmp(key
, "DYLD_EXECUTABLE_PATH_DEBUG") == 0 ) {
588 fprintf(stderr
, "dyld: warning DYLD_EXECUTABLE_PATH_DEBUG not supported\n");
590 else if ( strcmp(key
, "DYLD_TWO_LEVEL_DEBUG") == 0 ) {
591 fprintf(stderr
, "dyld: warning DYLD_TWO_LEVEL_DEBUG not supported\n");
593 else if ( strcmp(key
, "DYLD_LAZY_INITIALIZERS") == 0 ) {
594 fprintf(stderr
, "dyld: warning DYLD_LAZY_INITIALIZERS not supported\n");
596 else if ( strcmp(key
, "DYLD_PRINT_INITIALIZERS") == 0 ) {
597 gLinkContext
.verboseInit
= true;
599 else if ( strcmp(key
, "DYLD_PRINT_STATISTICS") == 0 ) {
600 sEnv
.DYLD_PRINT_STATISTICS
= true;
602 else if ( strcmp(key
, "DYLD_PRINT_SEGMENTS") == 0 ) {
603 gLinkContext
.verboseMapping
= true;
605 else if ( strcmp(key
, "DYLD_PRINT_BINDINGS") == 0 ) {
606 gLinkContext
.verboseBind
= true;
608 else if ( strcmp(key
, "DYLD_PRINT_REBASINGS") == 0 ) {
609 gLinkContext
.verboseRebase
= true;
611 else if ( strcmp(key
, "DYLD_PRINT_APIS") == 0 ) {
614 else if ( strcmp(key
, "DYLD_PRINT_WARNINGS") == 0 ) {
615 gLinkContext
.verboseWarnings
= true;
617 else if ( strcmp(key
, "DYLD_SHARED_REGION") == 0 ) {
618 if ( strcmp(value
, "private") == 0 ) {
619 gLinkContext
.sharedRegionMode
= ImageLoader
::kUsePrivateSharedRegion
;
621 else if ( strcmp(value
, "avoid") == 0 ) {
622 gLinkContext
.sharedRegionMode
= ImageLoader
::kDontUseSharedRegion
;
624 else if ( strcmp(value
, "use") == 0 ) {
625 gLinkContext
.sharedRegionMode
= ImageLoader
::kUseSharedRegion
;
627 else if ( value
[0] == '\0' ) {
628 gLinkContext
.sharedRegionMode
= ImageLoader
::kUseSharedRegion
;
631 fprintf(stderr
, "dyld: warning unknown option to DYLD_SHARED_REGION. Valid options are: use, private, avoid\n");
634 else if ( strcmp(key
, "DYLD_IGNORE_PREBINDING") == 0 ) {
635 if ( strcmp(value
, "all") == 0 ) {
636 gLinkContext
.prebindUsage
= ImageLoader
::kUseNoPrebinding
;
638 else if ( strcmp(value
, "app") == 0 ) {
639 gLinkContext
.prebindUsage
= ImageLoader
::kUseAllButAppPredbinding
;
641 else if ( strcmp(value
, "nonsplit") == 0 ) {
642 gLinkContext
.prebindUsage
= ImageLoader
::kUseSplitSegPrebinding
;
644 else if ( value
[0] == '\0' ) {
645 gLinkContext
.prebindUsage
= ImageLoader
::kUseSplitSegPrebinding
;
648 fprintf(stderr
, "dyld: warning unknown option to DYLD_IGNORE_PREBINDING. Valid options are: all, app, nonsplit\n");
652 fprintf(stderr
, "dyld: warning, unknown environment variable: %s\n", key
);
657 static void checkEnvironmentVariables(const char* envp
[], bool ignoreEnviron
)
659 const char* home
= NULL
;
661 for(p
= envp
; *p
!= NULL
; p
++) {
662 const char* keyEqualsValue
= *p
;
663 if ( strncmp(keyEqualsValue
, "DYLD_", 5) == 0 ) {
664 const char* equals
= strchr(keyEqualsValue
, '=');
665 if ( (equals
!= NULL
) && !ignoreEnviron
) {
666 const char* value
= &equals
[1];
667 const int keyLen
= equals
-keyEqualsValue
;
669 strncpy(key
, keyEqualsValue
, keyLen
);
671 processDyldEnvironmentVarible(key
, value
);
674 else if ( strncmp(keyEqualsValue
, "HOME=", 5) == 0 ) {
675 home
= &keyEqualsValue
[5];
677 else if ( strncmp(keyEqualsValue
, "LD_LIBRARY_PATH=", 16) == 0 ) {
678 const char* path
= &keyEqualsValue
[16];
679 if ( !disableIfBadUser((char*)path
) )
680 sEnv
.LD_LIBRARY_PATH
= parseColonList(path
);
684 // default value for DYLD_FALLBACK_FRAMEWORK_PATH, if not set in environment
685 if ( sEnv
.DYLD_FALLBACK_FRAMEWORK_PATH
== NULL
) {
686 const char** paths
= sFrameworkFallbackPaths
;
688 removePathWithPrefix(paths
, "$HOME");
690 paths_expand_roots(paths
, "$HOME", home
);
691 sEnv
.DYLD_FALLBACK_FRAMEWORK_PATH
= paths
;
694 // default value for DYLD_FALLBACK_LIBRARY_PATH, if not set in environment
695 if ( sEnv
.DYLD_FALLBACK_LIBRARY_PATH
== NULL
) {
696 const char** paths
= sLibraryFallbackPaths
;
698 removePathWithPrefix(paths
, "$HOME");
700 paths_expand_roots(paths
, "$HOME", home
);
701 sEnv
.DYLD_FALLBACK_LIBRARY_PATH
= paths
;
706 static void getHostInfo()
709 struct host_basic_info info
;
710 mach_msg_type_number_t count
= HOST_BASIC_INFO_COUNT
;
711 mach_port_t hostPort
= mach_host_self();
712 kern_return_t result
= host_info(hostPort
, HOST_BASIC_INFO
, (host_info_t
)&info
, &count
);
713 mach_port_deallocate(mach_task_self(), hostPort
);
714 if ( result
!= KERN_SUCCESS
)
715 throw "host_info() failed";
717 sHostCPU
= info
.cpu_type
;
718 sHostCPUsubtype
= info
.cpu_subtype
;
721 size_t valSize
= sizeof(sHostCPU
);
722 if (sysctlbyname ("hw.cputype", &sHostCPU
, &valSize
, NULL
, 0) != 0)
723 throw "sysctlbyname(hw.cputype) failed";
724 valSize
= sizeof(sHostCPUsubtype
);
725 if (sysctlbyname ("hw.cpusubtype", &sHostCPUsubtype
, &valSize
, NULL
, 0) != 0)
726 throw "sysctlbyname(hw.cpusubtype) failed";
729 bool validImage(ImageLoader
* possibleImage
)
731 const unsigned int imageCount
= sAllImages
.size();
732 for(unsigned int i
=0; i
< imageCount
; ++i
) {
733 if ( possibleImage
== sAllImages
[i
] ) {
740 uint32_t getImageCount()
742 if ( sAllImagesMightContainUnlinkedImages
) {
744 for (std
::vector
<ImageLoader
*>::iterator it
=sAllImages
.begin(); it
!= sAllImages
.end(); it
++) {
745 if ( (*it
)->isLinked() )
751 return sAllImages
.size();
755 ImageLoader
* getIndexedImage(unsigned int index
)
757 if ( sAllImagesMightContainUnlinkedImages
) {
759 for (std
::vector
<ImageLoader
*>::iterator it
=sAllImages
.begin(); it
!= sAllImages
.end(); it
++) {
760 if ( (*it
)->isLinked() ) {
761 if ( index
== count
)
768 if ( index
< sAllImages
.size() )
769 return sAllImages
[index
];
774 ImageLoader
* findImageByMachHeader(const struct mach_header
* target
)
776 const unsigned int imageCount
= sAllImages
.size();
777 for(unsigned int i
=0; i
< imageCount
; ++i
) {
778 ImageLoader
* anImage
= sAllImages
[i
];
779 if ( anImage
->machHeader() == target
)
786 ImageLoader
* findImageContainingAddress(const void* addr
)
789 static int cacheHit
= 0;
790 static int cacheMiss
= 0;
791 static int cacheNotMacho
= 0;
792 if ( ((cacheHit
+cacheMiss
+cacheNotMacho
) % 100) == 0 )
793 fprintf(stderr
, "findImageContainingAddress(): cache hit = %d, miss = %d, unknown = %d\n", cacheHit
, cacheMiss
, cacheNotMacho
);
795 // first look in image where last address was found rdar://problem/3685517
796 if ( (sLastImageByAddressCache
!= NULL
) && sLastImageByAddressCache
->containsAddress(addr
) ) {
800 return sLastImageByAddressCache
;
802 // do exhastive search
803 // todo: consider maintaining a list sorted by address ranges and do a binary search on that
804 const unsigned int imageCount
= sAllImages
.size();
805 for(unsigned int i
=0; i
< imageCount
; ++i
) {
806 ImageLoader
* anImage
= sAllImages
[i
];
807 if ( anImage
->containsAddress(addr
) ) {
808 sLastImageByAddressCache
= anImage
;
821 ImageLoader
* findImageContainingAddressThreadSafe(const void* addr
)
823 // do exhastive search
824 // todo: consider maintaining a list sorted by address ranges and do a binary search on that
825 const unsigned int imageCount
= sAllImages
.size();
826 for(unsigned int i
=0; i
< imageCount
; ++i
) {
827 ImageLoader
* anImage
= sAllImages
[i
];
828 if ( anImage
->containsAddress(addr
) ) {
836 void forEachImageDo( void (*callback
)(ImageLoader
*, void* userData
), void* userData
)
838 const unsigned int imageCount
= sAllImages
.size();
839 for(unsigned int i
=0; i
< imageCount
; ++i
) {
840 ImageLoader
* anImage
= sAllImages
[i
];
841 (*callback
)(anImage
, userData
);
845 ImageLoader
* findLoadedImage(const struct stat
& stat_buf
)
847 const unsigned int imageCount
= sAllImages
.size();
848 for(unsigned int i
=0; i
< imageCount
; ++i
){
849 ImageLoader
* anImage
= sAllImages
[i
];
850 if ( anImage
->statMatch(stat_buf
) )
856 // based on ANSI-C strstr()
857 static const char* strrstr(const char* str
, const char* sub
)
859 const int sublen
= strlen(sub
);
860 for(const char* p
= &str
[strlen(str
)]; p
!= str
; --p
) {
861 if ( strncmp(p
, sub
, sublen
) == 0 )
869 // Find framework path
871 // /path/foo.framework/foo => foo.framework/foo
872 // /path/foo.framework/Versions/A/foo => foo.framework/Versions/A/foo
873 // /path/foo.framework/Frameworks/bar.framework/bar => bar.framework/bar
874 // /path/foo.framework/Libraries/bar.dylb => NULL
875 // /path/foo.framework/bar => NULL
877 // Returns NULL if not a framework path
879 static const char* getFrameworkPartialPath(const char* path
)
881 const char* dirDot
= strrstr(path
, ".framework/");
882 if ( dirDot
!= NULL
) {
883 const char* dirStart
= dirDot
;
884 for ( ; dirStart
>= path
; --dirStart
) {
885 if ( (*dirStart
== '/') || (dirStart
== path
) ) {
886 const char* frameworkStart
= &dirStart
[1];
887 if ( dirStart
== path
)
889 int len
= dirDot
- frameworkStart
;
890 char framework
[len
+1];
891 strncpy(framework
, frameworkStart
, len
);
892 framework
[len
] = '\0';
893 const char* leaf
= strrchr(path
, '/');
894 if ( leaf
!= NULL
) {
895 if ( strcmp(framework
, &leaf
[1]) == 0 ) {
896 return frameworkStart
;
898 if ( gLinkContext
.imageSuffix
!= NULL
) {
899 // some debug frameworks have install names that end in _debug
900 if ( strncmp(framework
, &leaf
[1], len
) == 0 ) {
901 if ( strcmp( gLinkContext
.imageSuffix
, &leaf
[len
+1]) == 0 )
902 return frameworkStart
;
913 static const char* getLibraryLeafName(const char* path
)
915 const char* start
= strrchr(path
, '/');
924 const cpu_subtype_t CPU_SUBTYPE_END_OF_LIST
= -1;
928 // A fat file may contain multiple sub-images for the same CPU type.
929 // In that case, dyld picks which sub-image to use by scanning a table
930 // of preferred cpu-sub-types for the running cpu.
932 // There is one row in the table for each cpu-sub-type on which dyld might run.
933 // The first entry in a row is that cpu-sub-type. It is followed by all
934 // cpu-sub-types that can run on that cpu, if preferred order. Each row ends with
935 // a "SUBTYPE_ALL" (to denote that images written to run on any cpu-sub-type are usable),
936 // followed by one or more CPU_SUBTYPE_END_OF_LIST to pad out this row.
941 // 32-bit PowerPC sub-type lists
943 const int kPPC_RowCount
= 4;
944 static const cpu_subtype_t kPPC32
[kPPC_RowCount
][6] = {
945 // G5 can run any code
946 { CPU_SUBTYPE_POWERPC_970
, CPU_SUBTYPE_POWERPC_7450
, CPU_SUBTYPE_POWERPC_7400
, CPU_SUBTYPE_POWERPC_750
, CPU_SUBTYPE_POWERPC_ALL
, CPU_SUBTYPE_END_OF_LIST
},
948 // G4 can run all but G5 code
949 { CPU_SUBTYPE_POWERPC_7450
, CPU_SUBTYPE_POWERPC_7400
, CPU_SUBTYPE_POWERPC_750
, CPU_SUBTYPE_POWERPC_ALL
, CPU_SUBTYPE_END_OF_LIST
, CPU_SUBTYPE_END_OF_LIST
},
950 { CPU_SUBTYPE_POWERPC_7400
, CPU_SUBTYPE_POWERPC_7450
, CPU_SUBTYPE_POWERPC_750
, CPU_SUBTYPE_POWERPC_ALL
, CPU_SUBTYPE_END_OF_LIST
, CPU_SUBTYPE_END_OF_LIST
},
952 // G3 cannot run G4 or G5 code
953 { CPU_SUBTYPE_POWERPC_750
, CPU_SUBTYPE_POWERPC_ALL
, CPU_SUBTYPE_END_OF_LIST
, CPU_SUBTYPE_END_OF_LIST
, CPU_SUBTYPE_END_OF_LIST
, CPU_SUBTYPE_END_OF_LIST
}
958 // 64-bit PowerPC sub-type lists
960 const int kPPC64_RowCount
= 1;
961 static const cpu_subtype_t kPPC64
[kPPC64_RowCount
][3] = {
962 // G5 can run any 64-bit code
963 { CPU_SUBTYPE_POWERPC_970
, CPU_SUBTYPE_POWERPC_ALL
, CPU_SUBTYPE_END_OF_LIST
},
969 // 32-bit x86 sub-type lists
975 // scan the tables above to find the cpu-sub-type-list for this machine
976 static const cpu_subtype_t
* findCPUSubtypeList(cpu_type_t cpu
, cpu_subtype_t subtype
)
979 case CPU_TYPE_POWERPC
:
980 for (int i
=0; i
< kPPC_RowCount
; ++i
) {
981 if ( kPPC32
[i
][0] == subtype
)
985 case CPU_TYPE_POWERPC64
:
986 for (int i
=0; i
< kPPC64_RowCount
; ++i
) {
987 if ( kPPC64
[i
][0] == subtype
)
1001 // scan fat table-of-contents for best most preferred subtype
1002 static bool fatFindBestFromOrderedList(cpu_type_t cpu
, const cpu_subtype_t list
[], const fat_header
* fh
, uint64_t* offset
, uint64_t* len
)
1004 const fat_arch
* const archs
= (fat_arch
*)(((char*)fh
)+sizeof(fat_header
));
1005 for (uint32_t subTypeIndex
=0; list
[subTypeIndex
] != CPU_SUBTYPE_END_OF_LIST
; ++subTypeIndex
) {
1006 for(uint32_t fatIndex
=0; fatIndex
< OSSwapBigToHostInt32(fh
->nfat_arch
); ++fatIndex
) {
1007 if ( ((cpu_type_t
)OSSwapBigToHostInt32(archs
[fatIndex
].cputype
) == cpu
)
1008 && (list
[subTypeIndex
] == archs
[fatIndex
].cpusubtype
) ) {
1009 *offset
= OSSwapBigToHostInt32(archs
[fatIndex
].offset
);
1010 *len
= OSSwapBigToHostInt32(archs
[fatIndex
].size
);
1018 // scan fat table-of-contents for exact match of cpu and cpu-sub-type
1019 static bool fatFindExactMatch(cpu_type_t cpu
, cpu_subtype_t subtype
, const fat_header
* fh
, uint64_t* offset
, uint64_t* len
)
1021 const fat_arch
* archs
= (fat_arch
*)(((char*)fh
)+sizeof(fat_header
));
1022 for(uint32_t i
=0; i
< OSSwapBigToHostInt32(fh
->nfat_arch
); ++i
) {
1023 if ( ((cpu_type_t
)OSSwapBigToHostInt32(archs
[i
].cputype
) == cpu
)
1024 && ((cpu_subtype_t
)OSSwapBigToHostInt32(archs
[i
].cpusubtype
) == subtype
) ) {
1025 *offset
= OSSwapBigToHostInt32(archs
[i
].offset
);
1026 *len
= OSSwapBigToHostInt32(archs
[i
].size
);
1033 // scan fat table-of-contents for image with matching cpu-type and runs-on-all-sub-types
1034 static bool fatFindRunsOnAllCPUs(cpu_type_t cpu
, const fat_header
* fh
, uint64_t* offset
, uint64_t* len
)
1036 const fat_arch
* archs
= (fat_arch
*)(((char*)fh
)+sizeof(fat_header
));
1037 for(uint32_t i
=0; i
< OSSwapBigToHostInt32(fh
->nfat_arch
); ++i
) {
1038 if ( (cpu_type_t
)OSSwapBigToHostInt32(archs
[i
].cputype
) == cpu
) {
1040 case CPU_TYPE_POWERPC
:
1041 case CPU_TYPE_POWERPC64
:
1042 if ( (cpu_subtype_t
)OSSwapBigToHostInt32(archs
[i
].cpusubtype
) == CPU_SUBTYPE_POWERPC_ALL
) {
1043 *offset
= OSSwapBigToHostInt32(archs
[i
].offset
);
1044 *len
= OSSwapBigToHostInt32(archs
[i
].size
);
1049 if ( (cpu_subtype_t
)OSSwapBigToHostInt32(archs
[i
].cpusubtype
) == CPU_SUBTYPE_I386_ALL
) {
1050 *offset
= OSSwapBigToHostInt32(archs
[i
].offset
);
1051 *len
= OSSwapBigToHostInt32(archs
[i
].size
);
1063 // A fat file may contain multiple sub-images for the same cpu-type,
1064 // each optimized for a different cpu-sub-type (e.g G3 or G5).
1065 // This routine picks the optimal sub-image.
1067 static bool fatFindBest(const fat_header
* fh
, uint64_t* offset
, uint64_t* len
)
1069 // assume all dylibs loaded must have same cpu type as main executable
1070 const cpu_type_t cpu
= sMainExecutableMachHeader
->cputype
;
1072 // We only know the subtype to use if the main executable cpu type matches the host
1073 if ( (cpu
& CPU_TYPE_MASK
) == sHostCPU
) {
1074 // get preference ordered list of subtypes
1075 const cpu_subtype_t
* subTypePreferenceList
= findCPUSubtypeList(cpu
, sHostCPUsubtype
);
1077 // use ordered list to find best sub-image in fat file
1078 if ( subTypePreferenceList
!= NULL
)
1079 return fatFindBestFromOrderedList(cpu
, subTypePreferenceList
, fh
, offset
, len
);
1081 // if running cpu is not in list, try for an exact match
1082 if ( fatFindExactMatch(cpu
, sHostCPUsubtype
, fh
, offset
, len
) )
1086 // running on an uknown cpu, can only load generic code
1087 return fatFindRunsOnAllCPUs(cpu
, fh
, offset
, len
);
1093 // This is used to validate if a non-fat (aka thin or raw) mach-o file can be used
1094 // on the current processor. It is deemed compatible if any of the following are true:
1095 // 1) mach_header subtype is in list of compatible subtypes for running processor
1096 // 2) mach_header subtype is same as running processor subtype
1097 // 3) mach_header subtype runs on all processor variants
1100 bool isCompatibleMachO(const uint8_t* firstPage
)
1102 const mach_header
* mh
= (mach_header
*)firstPage
;
1103 if ( mh
->magic
== sMainExecutableMachHeader
->magic
) {
1104 if ( mh
->cputype
== sMainExecutableMachHeader
->cputype
) {
1105 if ( (mh
->cputype
& CPU_TYPE_MASK
) == sHostCPU
) {
1106 // get preference ordered list of subtypes that this machine can use
1107 const cpu_subtype_t
* subTypePreferenceList
= findCPUSubtypeList(mh
->cputype
, sHostCPUsubtype
);
1108 if ( subTypePreferenceList
!= NULL
) {
1109 // if image's subtype is in the list, it is compatible
1110 for (const cpu_subtype_t
* p
= subTypePreferenceList
; *p
!= CPU_SUBTYPE_END_OF_LIST
; ++p
) {
1111 if ( *p
== mh
->cpusubtype
)
1114 // have list and not in list, so not compatible
1115 throw "incompatible cpu-subtype";
1117 // unknown cpu sub-type, but if exact match for current subtype then ok to use
1118 if ( mh
->cpusubtype
== sHostCPUsubtype
)
1122 // cpu unknown, so don't know if subtype is compatible
1123 // only load _ALL variant
1124 switch (mh
->cputype
) {
1125 case CPU_TYPE_POWERPC
:
1126 case CPU_TYPE_POWERPC64
:
1127 if ( mh
->cpusubtype
== CPU_SUBTYPE_POWERPC_ALL
)
1131 if ( mh
->cpusubtype
== CPU_SUBTYPE_I386_ALL
)
1141 // The kernel maps in main executable before dyld gets control. We need to
1142 // make an ImageLoader* for the already mapped in main executable.
1143 static ImageLoader
* instantiateFromLoadedImage(const struct mach_header
* mh
, const char* path
)
1145 // try mach-o loader
1146 if ( isCompatibleMachO((const uint8_t*)mh
) ) {
1147 ImageLoader
* image
= new ImageLoaderMachO(path
, mh
, 0, gLinkContext
);
1152 throw "main executable not a known format";
1158 // map in file and instantiate an ImageLoader
1159 static ImageLoader
* loadPhase6(int fd
, struct stat
& stat_buf
, const char* path
, const LoadContext
& context
)
1161 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1162 uint64_t fileOffset
= 0;
1163 uint64_t fileLength
= stat_buf
.st_size
;
1165 if ( *((uint32_t*)((char*)(&stat_buf
)+0x60)) == 0xFEFEFEFE )
1166 fileLength
= *((uint64_t*)((char*)(&stat_buf
)+0x30)); // HACK work around for kernel stat bug rdar://problem/3845883
1169 // validate it is a file (not directory)
1170 if ( (stat_buf
.st_mode
& S_IFMT
) != S_IFREG
)
1174 if ( fileLength
< 4096 ) {
1175 throw "file to short";
1178 uint8_t firstPage
[4096];
1179 pread(fd
, firstPage
, 4096,0);
1181 // if fat wrapper, find usable sub-file
1182 const fat_header
* fileStartAsFat
= (fat_header
*)firstPage
;
1183 if ( fileStartAsFat
->magic
== OSSwapBigToHostInt32(FAT_MAGIC
) ) {
1184 if ( fatFindBest(fileStartAsFat
, &fileOffset
, &fileLength
) ) {
1185 pread(fd
, firstPage
, 4096, fileOffset
);
1188 throw "no matching architecture in universal wrapper";
1192 // try mach-o loader
1193 if ( isCompatibleMachO(firstPage
) ) {
1194 char realFilePath
[PATH_MAX
];
1195 if ( gLinkContext
.slideAndPackDylibs
) {
1196 // when prebinding, we always want to track the real path of images
1197 if ( realpath(path
, realFilePath
) != NULL
)
1198 path
= realFilePath
;
1201 // instantiate an image
1202 ImageLoader
* image
= new ImageLoaderMachO(path
, fd
, firstPage
, fileOffset
, fileLength
, stat_buf
, gLinkContext
);
1204 // now sanity check that this loaded image does not have the same install path as any existing image
1205 const char* loadedImageInstallPath
= image
->getInstallPath();
1206 if ( image
->isDylib() && (loadedImageInstallPath
!= NULL
) && (loadedImageInstallPath
[0] == '/') ) {
1207 for (std
::vector
<ImageLoader
*>::iterator it
=sAllImages
.begin(); it
!= sAllImages
.end(); it
++) {
1208 ImageLoader
* anImage
= *it
;
1209 const char* installPath
= anImage
->getInstallPath();
1210 if ( installPath
!= NULL
) {
1211 if ( strcmp(loadedImageInstallPath
, installPath
) == 0 ) {
1212 //fprintf(stderr, "duplicate(%s) => %p\n", installPath, anImage);
1220 // some API's restrict what they can load
1221 if ( context
.mustBeBundle
&& !image
->isBundle() )
1222 throw "not a bundle";
1223 if ( context
.mustBeDylib
&& !image
->isDylib() )
1224 throw "not a dylib";
1226 // don't add bundles to global list, they can be loaded but not linked. When linked it will be added to list
1227 if ( ! image
->isBundle() )
1233 // try other file formats...
1236 // throw error about what was found
1237 switch (*(uint32_t*)firstPage
) {
1242 throw "mach-o, but wrong architecture";
1244 throwf("unknown file type, first eight bytes: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X",
1245 firstPage
[0], firstPage
[1], firstPage
[2], firstPage
[3], firstPage
[4], firstPage
[5], firstPage
[6],firstPage
[7]);
1251 static ImageLoader
* loadPhase5open(const char* path
, const LoadContext
& context
, std
::vector
<const char*>* exceptions
)
1253 //fprintf(stdout, "%s(%s)\n", __func__, path);
1254 ImageLoader
* image
= NULL
;
1256 // open file (automagically closed when this function exits)
1257 FileOpener
file(path
);
1259 //fprintf(stderr, "open(%s) => %d\n", path, file.getFileDescriptor() );
1261 if ( file
.getFileDescriptor() == -1 )
1264 struct stat stat_buf
;
1266 memset(&stat_buf
, 254, sizeof(struct stat
)); // hack until rdar://problem/3845883 is fixed
1268 if ( fstat(file
.getFileDescriptor(), &stat_buf
) == -1)
1271 // in case image was renamed or found via symlinks, check for inode match
1272 image
= findLoadedImage(stat_buf
);
1273 if ( image
!= NULL
)
1276 // needed to implement NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED
1277 if ( context
.dontLoad
)
1281 return loadPhase6(file
.getFileDescriptor(), stat_buf
, path
, context
);
1283 catch (const char* msg
) {
1284 char* newMsg
= new char[strlen(msg
) + strlen(path
) + 8];
1285 sprintf(newMsg
, "%s: %s", path
, msg
);
1286 exceptions
->push_back(newMsg
);
1291 // look for path match with existing loaded images
1292 static ImageLoader
* loadPhase5check(const char* path
, const LoadContext
& context
)
1294 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1295 // search path against load-path and install-path of all already loaded images
1296 uint32_t hash
= ImageLoader
::hash(path
);
1297 for (std
::vector
<ImageLoader
*>::iterator it
=sAllImages
.begin(); it
!= sAllImages
.end(); it
++) {
1298 ImageLoader
* anImage
= *it
;
1299 // check has first to cut down on strcmp calls
1300 if ( anImage
->getPathHash() == hash
)
1301 if ( strcmp(path
, anImage
->getPath()) == 0 ) {
1302 // if we are looking for a dylib don't return something else
1303 if ( !context
.mustBeDylib
|| anImage
->isDylib() )
1306 if ( context
.matchByInstallName
|| anImage
->matchInstallPath() ) {
1307 const char* installPath
= anImage
->getInstallPath();
1308 if ( installPath
!= NULL
) {
1309 if ( strcmp(path
, installPath
) == 0 ) {
1310 // if we are looking for a dylib don't return something else
1311 if ( !context
.mustBeDylib
|| anImage
->isDylib() )
1318 //fprintf(stderr, "check(%s) => NULL\n", path);
1323 // open or check existing
1324 static ImageLoader
* loadPhase5(const char* path
, const LoadContext
& context
, std
::vector
<const char*>* exceptions
)
1326 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1327 if ( exceptions
!= NULL
)
1328 return loadPhase5open(path
, context
, exceptions
);
1330 return loadPhase5check(path
, context
);
1333 // try with and without image suffix
1334 static ImageLoader
* loadPhase4(const char* path
, const LoadContext
& context
, std
::vector
<const char*>* exceptions
)
1336 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1337 ImageLoader
* image
= NULL
;
1338 if ( gLinkContext
.imageSuffix
!= NULL
) {
1339 char pathWithSuffix
[strlen(path
)+strlen( gLinkContext
.imageSuffix
)+2];
1340 ImageLoader
::addSuffix(path
, gLinkContext
.imageSuffix
, pathWithSuffix
);
1341 image
= loadPhase5(pathWithSuffix
, context
, exceptions
);
1343 if ( image
== NULL
)
1344 image
= loadPhase5(path
, context
, exceptions
);
1349 // expand @ variables
1350 static ImageLoader
* loadPhase3(const char* path
, const LoadContext
& context
, std
::vector
<const char*>* exceptions
)
1352 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1353 ImageLoader
* image
= NULL
;
1354 if ( strncmp(path
, "@executable_path/", 17) == 0 ) {
1355 // handle @executable_path path prefix
1356 const char* executablePath
= sExecPath
;
1357 char newPath
[strlen(executablePath
) + strlen(path
)];
1358 strcpy(newPath
, executablePath
);
1359 char* addPoint
= strrchr(newPath
,'/');
1360 if ( addPoint
!= NULL
)
1361 strcpy(&addPoint
[1], &path
[17]);
1363 strcpy(newPath
, &path
[17]);
1364 image
= loadPhase4(newPath
, context
, exceptions
);
1365 if ( image
!= NULL
)
1368 // perhaps main executable path is a sym link, find realpath and retry
1369 char resolvedPath
[PATH_MAX
];
1370 if ( realpath(sExecPath
, resolvedPath
) != NULL
) {
1371 char newRealPath
[strlen(resolvedPath
) + strlen(path
)];
1372 strcpy(newRealPath
, resolvedPath
);
1373 char* addPoint
= strrchr(newRealPath
,'/');
1374 if ( addPoint
!= NULL
)
1375 strcpy(&addPoint
[1], &path
[17]);
1377 strcpy(newRealPath
, &path
[17]);
1378 image
= loadPhase4(newRealPath
, context
, exceptions
);
1379 if ( image
!= NULL
)
1383 else if ( (strncmp(path
, "@loader_path/", 13) == 0) && (context
.origin
!= NULL
) ) {
1384 // handle @loader_path path prefix
1385 char newPath
[strlen(context
.origin
) + strlen(path
)];
1386 strcpy(newPath
, context
.origin
);
1387 char* addPoint
= strrchr(newPath
,'/');
1388 if ( addPoint
!= NULL
)
1389 strcpy(&addPoint
[1], &path
[13]);
1391 strcpy(newPath
, &path
[13]);
1392 image
= loadPhase4(newPath
, context
, exceptions
);
1393 if ( image
!= NULL
)
1396 // perhaps loader path is a sym link, find realpath and retry
1397 char resolvedPath
[PATH_MAX
];
1398 if ( realpath(context
.origin
, resolvedPath
) != NULL
) {
1399 char newRealPath
[strlen(resolvedPath
) + strlen(path
)];
1400 strcpy(newRealPath
, resolvedPath
);
1401 char* addPoint
= strrchr(newRealPath
,'/');
1402 if ( addPoint
!= NULL
)
1403 strcpy(&addPoint
[1], &path
[13]);
1405 strcpy(newRealPath
, &path
[13]);
1406 image
= loadPhase4(newRealPath
, context
, exceptions
);
1407 if ( image
!= NULL
)
1412 return loadPhase4(path
, context
, exceptions
);
1417 static ImageLoader
* loadPhase2(const char* path
, const LoadContext
& context
,
1418 const char* const frameworkPaths
[], const char* const libraryPaths
[],
1419 std
::vector
<const char*>* exceptions
)
1421 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1422 ImageLoader
* image
= NULL
;
1423 const char* frameworkPartialPath
= getFrameworkPartialPath(path
);
1424 if ( frameworkPaths
!= NULL
) {
1425 if ( frameworkPartialPath
!= NULL
) {
1426 const int frameworkPartialPathLen
= strlen(frameworkPartialPath
);
1427 for(const char* const* fp
= frameworkPaths
; *fp
!= NULL
; ++fp
) {
1428 char npath
[strlen(*fp
)+frameworkPartialPathLen
+8];
1431 strcat(npath
, frameworkPartialPath
);
1432 //fprintf(stderr, "dyld: fallback framework path used: %s() -> loadPhase4(\"%s\", ...)\n", __func__, npath);
1433 image
= loadPhase4(npath
, context
, exceptions
);
1434 if ( image
!= NULL
)
1439 if ( libraryPaths
!= NULL
) {
1440 const char* libraryLeafName
= getLibraryLeafName(path
);
1441 const int libraryLeafNameLen
= strlen(libraryLeafName
);
1442 for(const char* const* lp
= libraryPaths
; *lp
!= NULL
; ++lp
) {
1443 char libpath
[strlen(*lp
)+libraryLeafNameLen
+8];
1444 strcpy(libpath
, *lp
);
1445 strcat(libpath
, "/");
1446 strcat(libpath
, libraryLeafName
);
1447 //fprintf(stderr, "dyld: fallback library path used: %s() -> loadPhase4(\"%s\", ...)\n", __func__, libpath);
1448 image
= loadPhase4(libpath
, context
, exceptions
);
1449 if ( image
!= NULL
)
1456 // try search overrides and fallbacks
1457 static ImageLoader
* loadPhase1(const char* path
, const LoadContext
& context
, std
::vector
<const char*>* exceptions
)
1459 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1460 ImageLoader
* image
= NULL
;
1462 // handle LD_LIBRARY_PATH environment variables that force searching
1463 if ( context
.useLdLibraryPath
&& (sEnv
.LD_LIBRARY_PATH
!= NULL
) ) {
1464 image
= loadPhase2(path
, context
, NULL
, sEnv
.LD_LIBRARY_PATH
, exceptions
);
1465 if ( image
!= NULL
)
1469 // handle DYLD_ environment variables that force searching
1470 if ( context
.useSearchPaths
&& ((sEnv
.DYLD_FRAMEWORK_PATH
!= NULL
) || (sEnv
.DYLD_LIBRARY_PATH
!= NULL
)) ) {
1471 image
= loadPhase2(path
, context
, sEnv
.DYLD_FRAMEWORK_PATH
, sEnv
.DYLD_LIBRARY_PATH
, exceptions
);
1472 if ( image
!= NULL
)
1477 image
= loadPhase3(path
, context
, exceptions
);
1478 if ( image
!= NULL
)
1481 // try fallback paths during second time (will open file)
1482 if ( (exceptions
!= NULL
) && ((sEnv
.DYLD_FALLBACK_FRAMEWORK_PATH
!= NULL
) || (sEnv
.DYLD_FALLBACK_LIBRARY_PATH
!= NULL
)) ) {
1483 image
= loadPhase2(path
, context
, sEnv
.DYLD_FALLBACK_FRAMEWORK_PATH
, sEnv
.DYLD_FALLBACK_LIBRARY_PATH
, exceptions
);
1484 if ( image
!= NULL
)
1491 // try root substitutions
1492 static ImageLoader
* loadPhase0(const char* path
, const LoadContext
& context
, std
::vector
<const char*>* exceptions
)
1494 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1496 // handle DYLD_ROOT_PATH which forces absolute paths to use a new root
1497 if ( (sEnv
.DYLD_ROOT_PATH
!= NULL
) && (path
[0] == '/') ) {
1498 for(const char* const* rootPath
= sEnv
.DYLD_ROOT_PATH
; *rootPath
!= NULL
; ++rootPath
) {
1499 char newPath
[strlen(*rootPath
) + strlen(path
)+2];
1500 strcpy(newPath
, *rootPath
);
1501 strcat(newPath
, path
);
1502 ImageLoader
* image
= loadPhase1(newPath
, context
, exceptions
);
1503 if ( image
!= NULL
)
1509 return loadPhase1(path
, context
, exceptions
);
1513 // Given all the DYLD_ environment variables, the general case for loading libraries
1514 // is that any given path expands into a list of possible locations to load. We
1515 // also must take care to ensure two copies of the "same" library are never loaded.
1517 // The algorithm used here is that there is a separate function for each "phase" of the
1518 // path expansion. Each phase function calls the next phase with each possible expansion
1519 // of that phase. The result is the last phase is called with all possible paths.
1521 // To catch duplicates the algorithm is run twice. The first time, the last phase checks
1522 // the path against all loaded images. The second time, the last phase calls open() on
1523 // the path. Either time, if an image is found, the phases all unwind without checking
1526 ImageLoader
* load(const char* path
, const LoadContext
& context
)
1528 //fprintf(stderr, "%s(%s)\n", __func__ , path);
1529 char realPath
[PATH_MAX
];
1530 // when DYLD_IMAGE_SUFFIX is in used, do a realpath(), otherwise a load of "Foo.framework/Foo" will not match
1531 if ( context
.useSearchPaths
&& ( gLinkContext
.imageSuffix
!= NULL
) ) {
1532 if ( realpath(path
, realPath
) != NULL
)
1536 // try all path permutations and check against existing loaded images
1537 ImageLoader
* image
= loadPhase0(path
, context
, NULL
);
1538 if ( image
!= NULL
)
1541 // try all path permutations and try open() until first sucesss
1542 std
::vector
<const char*> exceptions
;
1543 image
= loadPhase0(path
, context
, &exceptions
);
1544 if ( image
!= NULL
)
1546 else if ( context
.dontLoad
)
1548 else if ( exceptions
.size() == 0 )
1549 throw "image not found";
1551 const char* msgStart
= "no suitable image found. Did find:";
1552 const char* delim
= "\n\t";
1553 size_t allsizes
= strlen(msgStart
)+8;
1554 for (unsigned int i
=0; i
< exceptions
.size(); ++i
)
1555 allsizes
+= (strlen(exceptions
[i
]) + strlen(delim
));
1556 char* fullMsg
= new char[allsizes
];
1557 strcpy(fullMsg
, msgStart
);
1558 for (unsigned int i
=0; i
< exceptions
.size(); ++i
) {
1559 strcat(fullMsg
, delim
);
1560 strcat(fullMsg
, exceptions
[i
]);
1562 throw (const char*)fullMsg
;
1569 // create when NSLinkModule is called for a second time on a bundle
1570 ImageLoader
* cloneImage(ImageLoader
* image
)
1572 const uint64_t offsetInFat
= image
->getOffsetInFatFile();
1574 // open file (automagically closed when this function exits)
1575 FileOpener
file(image
->getPath());
1577 struct stat stat_buf
;
1579 memset(&stat_buf
, 254, sizeof(struct stat
)); // hack until rdar://problem/3845883 is fixed
1581 if ( fstat(file
.getFileDescriptor(), &stat_buf
) == -1)
1584 // read first page of file
1585 uint8_t firstPage
[4096];
1586 pread(file
.getFileDescriptor(), firstPage
, 4096, offsetInFat
);
1588 // fat length is only used for sanity checking, since this image was already loaded once, just use upper bound
1589 uint64_t lenInFat
= stat_buf
.st_size
- offsetInFat
;
1591 // try mach-o loader
1592 if ( isCompatibleMachO(firstPage
) ) {
1593 ImageLoader
* clone
= new ImageLoaderMachO(image
->getPath(), file
.getFileDescriptor(), firstPage
, offsetInFat
, lenInFat
, stat_buf
, gLinkContext
);
1594 // don't add bundles to global list, they can be loaded but not linked. When linked it will be added to list
1595 if ( ! image
->isBundle() )
1600 // try other file formats...
1601 throw "can't clone image";
1605 ImageLoader
* loadFromMemory(const uint8_t* mem
, uint64_t len
, const char* moduleName
)
1607 // if fat wrapper, find usable sub-file
1608 const fat_header
* memStartAsFat
= (fat_header
*)mem
;
1609 uint64_t fileOffset
= 0;
1610 uint64_t fileLength
= len
;
1611 if ( memStartAsFat
->magic
== OSSwapBigToHostInt32(FAT_MAGIC
) ) {
1612 if ( fatFindBest(memStartAsFat
, &fileOffset
, &fileLength
) ) {
1613 mem
= &mem
[fileOffset
];
1617 throw "no matching architecture in universal wrapper";
1621 // try mach-o each loader
1622 if ( isCompatibleMachO(mem
) ) {
1623 ImageLoader
* image
= new ImageLoaderMachO(moduleName
, (mach_header
*)mem
, len
, gLinkContext
);
1624 // don't add bundles to global list, they can be loaded but not linked. When linked it will be added to list
1625 if ( ! image
->isBundle() )
1630 // try other file formats...
1632 // throw error about what was found
1633 switch (*(uint32_t*)mem
) {
1638 throw "mach-o, but wrong architecture";
1640 throwf("unknown file type, first eight bytes: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X",
1641 mem
[0], mem
[1], mem
[2], mem
[3], mem
[4], mem
[5], mem
[6],mem
[7]);
1646 void registerAddCallback(ImageCallback func
)
1648 // now add to list to get notified when any more images are added
1649 sAddImageCallbacks
.push_back(func
);
1651 // call callback with all existing images, starting at roots
1652 const int rootCount
= sImageRoots
.size();
1653 for(int i
=0; i
< rootCount
; ++i
) {
1654 ImageLoader
* image
= sImageRoots
[i
];
1655 image
->runNotification(gLinkContext
, sAddImageCallbacks
.size());
1658 // for (std::vector<ImageLoader*>::iterator it=sImageRoots.begin(); it != sImageRoots.end(); it++) {
1659 // ImageLoader* image = *it;
1660 // image->runNotification(gLinkContext, sAddImageCallbacks.size());
1664 void registerRemoveCallback(ImageCallback func
)
1666 sRemoveImageCallbacks
.push_back(func
);
1669 void clearErrorMessage()
1671 error_string
[0] = '\0';
1674 void setErrorMessage(const char* message
)
1676 // save off error message in global buffer for CrashReporter to find
1677 strncpy(error_string
, message
, sizeof(error_string
)-1);
1678 error_string
[sizeof(error_string
)-1] = '\0';
1681 const char* getErrorMessage()
1683 return error_string
;
1686 void halt(const char* message
)
1688 fprintf(stderr
, "dyld: %s\n", message
);
1689 setErrorMessage(message
);
1690 strncpy(error_string
, message
, sizeof(error_string
)-1);
1691 error_string
[sizeof(error_string
)-1] = '\0';
1693 #if __ppc__ || __ppc64__
1698 #error unknown architecture
1700 abort(); // needed to suppress warning that noreturn function returns
1704 uintptr_t bindLazySymbol(const mach_header
* mh
, uintptr_t* lazyPointer
)
1706 uintptr_t result
= 0;
1707 // acquire read-lock on dyld's data structures
1708 #if 0 // rdar://problem/3811777 turn off locking until deadlock is resolved
1709 if ( gThreadHelpers
!= NULL
)
1710 (*gThreadHelpers
->lockForReading
)();
1712 // lookup and bind lazy pointer and get target address
1714 ImageLoader
* target
;
1716 // fast stubs pass NULL for mh and image is instead found via the location of stub (aka lazyPointer)
1718 target
= dyld
::findImageContainingAddressThreadSafe(lazyPointer
);
1720 target
= dyld
::findImageByMachHeader(mh
);
1722 // note, target should always be mach-o, because only mach-o lazy handler wired up to this
1723 target
= dyld
::findImageByMachHeader(mh
);
1725 if ( target
== NULL
)
1726 throw "image not found for lazy pointer";
1727 result
= target
->doBindLazySymbol(lazyPointer
, gLinkContext
);
1729 catch (const char* message
) {
1730 fprintf(stderr
, "dyld: lazy symbol binding failed: %s\n", message
);
1733 // release read-lock on dyld's data structures
1735 if ( gThreadHelpers
!= NULL
)
1736 (*gThreadHelpers
->unlockForReading
)();
1738 // return target address to glue which jumps to it with real parameters restored
1743 // SPI used by ZeroLink to lazy load bundles
1744 void registerZeroLinkHandlers(BundleNotificationCallBack notify
, BundleLocatorCallBack locate
)
1746 sBundleNotifier
= notify
;
1747 sBundleLocation
= locate
;
1750 void registerUndefinedHandler(UndefinedHandler handler
)
1752 sUndefinedHandler
= handler
;
1755 static void undefinedHandler(const char* symboName
)
1757 if ( sUndefinedHandler
!= NULL
) {
1758 (*sUndefinedHandler
)(symboName
);
1762 static bool findExportedSymbol(const char* name
, bool onlyInCoalesced
, const ImageLoader
::Symbol
** sym
, ImageLoader
** image
)
1764 // try ZeroLink short cut to finding bundle which exports this symbol
1765 if ( sBundleLocation
!= NULL
) {
1766 ImageLoader
* zlImage
= (*sBundleLocation
)(name
);
1767 if ( zlImage
== ((ImageLoader
*)(-1)) ) {
1768 // -1 is magic value that request symbol is in a bundle not yet linked into process
1769 // try calling handler to link in that symbol
1770 undefinedHandler(name
);
1771 // call locator again
1772 zlImage
= (*sBundleLocation
)(name
);
1774 // if still not found, then ZeroLink has no idea where to find it
1775 if ( zlImage
== ((ImageLoader
*)(-1)) )
1777 if ( zlImage
!= NULL
) {
1778 // ZeroLink cache knows where the symbol is
1779 *sym
= zlImage
->findExportedSymbol(name
, NULL
, false, image
);
1780 if ( *sym
!= NULL
) {
1786 // ZeroLink says it is in some bundle already loaded, but not linked, walk them all
1787 const unsigned int imageCount
= sAllImages
.size();
1788 for(unsigned int i
=0; i
< imageCount
; ++i
){
1789 ImageLoader
* anImage
= sAllImages
[i
];
1790 if ( anImage
->isBundle() && !anImage
->hasHiddenExports() ) {
1791 //fprintf(stderr, "dyld: search for %s in %s\n", name, anImage->getPath());
1792 *sym
= anImage
->findExportedSymbol(name
, NULL
, false, image
);
1793 if ( *sym
!= NULL
) {
1801 // search all images in order
1802 ImageLoader
* firstWeakImage
= NULL
;
1803 const ImageLoader
::Symbol
* firstWeakSym
= NULL
;
1804 const unsigned int imageCount
= sAllImages
.size();
1805 for(unsigned int i
=0; i
< imageCount
; ++i
){
1806 ImageLoader
* anImage
= sAllImages
[i
];
1807 if ( ! anImage
->hasHiddenExports() && (!onlyInCoalesced
|| anImage
->hasCoalescedExports()) ) {
1808 *sym
= anImage
->findExportedSymbol(name
, NULL
, false, image
);
1809 if ( *sym
!= NULL
) {
1810 // if weak definition found, record first one found
1811 if ( ((*image
)->getExportedSymbolInfo(*sym
) & ImageLoader
::kWeakDefinition
) != 0 ) {
1812 if ( firstWeakImage
== NULL
) {
1813 firstWeakImage
= *image
;
1814 firstWeakSym
= *sym
;
1818 // found non-weak, so immediately return with it
1824 if ( firstWeakSym
!= NULL
) {
1825 // found a weak definition, but no non-weak, so return first weak found
1826 *sym
= firstWeakSym
;
1827 *image
= firstWeakImage
;
1834 bool flatFindExportedSymbol(const char* name
, const ImageLoader
::Symbol
** sym
, ImageLoader
** image
)
1836 return findExportedSymbol(name
, false, sym
, image
);
1839 bool findCoalescedExportedSymbol(const char* name
, const ImageLoader
::Symbol
** sym
, ImageLoader
** image
)
1841 return findExportedSymbol(name
, true, sym
, image
);
1845 bool flatFindExportedSymbolWithHint(const char* name
, const char* librarySubstring
, const ImageLoader
::Symbol
** sym
, ImageLoader
** image
)
1847 // search all images in order
1848 const unsigned int imageCount
= sAllImages
.size();
1849 for(unsigned int i
=0; i
< imageCount
; ++i
){
1850 ImageLoader
* anImage
= sAllImages
[i
];
1851 // only look at images whose paths contain the hint string (NULL hint string is wildcard)
1852 if ( ! anImage
->isBundle() && ((librarySubstring
==NULL
) || (strstr(anImage
->getPath(), librarySubstring
) != NULL
)) ) {
1853 *sym
= anImage
->findExportedSymbol(name
, NULL
, false, image
);
1854 if ( *sym
!= NULL
) {
1862 static void getMappedRegions(ImageLoader
::RegionsVector
& regions
)
1864 const unsigned int imageCount
= sAllImages
.size();
1865 for(unsigned int i
=0; i
< imageCount
; ++i
){
1866 ImageLoader
* anImage
= sAllImages
[i
];
1867 anImage
->addMappedRegions(regions
);
1872 static ImageLoader
* libraryLocator(const char* libraryName
, bool search
, const char* origin
, const char* rpath
[])
1874 dyld
::LoadContext context
;
1875 context
.useSearchPaths
= search
;
1876 context
.useLdLibraryPath
= false;
1877 context
.dontLoad
= false;
1878 context
.mustBeBundle
= false;
1879 context
.mustBeDylib
= true;
1880 context
.matchByInstallName
= false;
1881 context
.origin
= origin
;
1882 context
.rpath
= rpath
;
1883 return load(libraryName
, context
);
1887 static void setContext(int argc
, const char* argv
[], const char* envp
[], const char* apple
[])
1889 gLinkContext
.loadLibrary
= &libraryLocator
;
1890 gLinkContext
.imageNotification
= &imageNotification
;
1891 gLinkContext
.terminationRecorder
= &terminationRecorder
;
1892 gLinkContext
.flatExportFinder
= &flatFindExportedSymbol
;
1893 gLinkContext
.coalescedExportFinder
= &findCoalescedExportedSymbol
;
1894 gLinkContext
.undefinedHandler
= &undefinedHandler
;
1895 gLinkContext
.addImageNeedingNotification
= &addImageNeedingNotification
;
1896 gLinkContext
.notifyAdding
= ¬ifyAdding
;
1897 gLinkContext
.getAllMappedRegions
= &getMappedRegions
;
1898 gLinkContext
.bindingHandler
= NULL
;
1899 gLinkContext
.bindingOptions
= ImageLoader
::kBindingNone
;
1900 gLinkContext
.mainExecutable
= sMainExecutable
;
1901 gLinkContext
.argc
= argc
;
1902 gLinkContext
.argv
= argv
;
1903 gLinkContext
.envp
= envp
;
1904 gLinkContext
.apple
= apple
;
1907 static bool checkEmulation()
1910 int mib
[] = { CTL_KERN
, KERN_CLASSIC
, getpid() };
1912 size_t len
= sizeof(int);
1913 int ret
= sysctl(mib
, 3, &is_classic
, &len
, NULL
, 0);
1914 if ((ret
!= -1) && is_classic
) {
1915 // When a 32-bit ppc program is run under emulation on an Intel processor,
1916 // we want any i386 dylibs (e.g. the emulator) to not load in the shared region
1917 // because the shared region is being used by ppc dylibs
1918 gLinkContext
.sharedRegionMode
= ImageLoader
::kDontUseSharedRegion
;
1925 void link(ImageLoader
* image
, ImageLoader
::BindingLaziness bindness
, ImageLoader
::InitializerRunning runInitializers
)
1927 // add to list of known images. This did not happen at creation time for bundles
1928 if ( image
->isBundle() )
1931 // we detect root images as those not linked in yet
1932 if ( !image
->isLinked() )
1933 addRootImage(image
);
1935 // notify ZeroLink of new image with concat of logical and physical name
1936 if ( sBundleNotifier
!= NULL
&& image
->isBundle() ) {
1937 const int logicalLen
= strlen(image
->getLogicalPath());
1938 char logAndPhys
[strlen(image
->getPath())+logicalLen
+2];
1939 strcpy(logAndPhys
, image
->getLogicalPath());
1940 strcpy(&logAndPhys
[logicalLen
+1], image
->getPath());
1941 (*sBundleNotifier
)(logAndPhys
, image
);
1946 image
->link(gLinkContext
, bindness
, runInitializers
, sAddImageCallbacks
.size());
1948 catch (const char* msg
) {
1949 sAllImagesMightContainUnlinkedImages
= true;
1953 #if OLD_GDB_DYLD_INTERFACE
1954 // notify gdb that loaded libraries have changed
1955 gdb_dyld_state_changed();
1961 // _pthread_keys is partitioned in a lower part that dyld will use; libSystem
1962 // will use the upper part. We set __pthread_tsd_first to 1 as the start of
1963 // the lower part. Libc will take #1 and c++ exceptions will take #2. There
1964 // is one free key=3 left.
1967 extern int __pthread_tsd_first
;
1972 // Entry point for dyld. The kernel loads dyld and jumps to __dyld_start which
1973 // sets up some registers and call this function.
1975 // Returns address of main() in target program which __dyld_start jumps to
1978 _main(const struct mach_header
* mainExecutableMH
, int argc
, const char* argv
[], const char* envp
[], const char* apple
[])
1980 // set pthread keys to dyld range
1981 __pthread_tsd_first
= 1;
1983 bool isEmulated
= checkEmulation();
1984 // Pickup the pointer to the exec path.
1985 sExecPath
= apple
[0];
1988 sExecPath
= strdup(apple
[0] + strlen(apple
[0]) + 1);
1990 if ( sExecPath
[0] != '/' ) {
1991 // have relative path, use cwd to make absolute
1992 char cwdbuff
[MAXPATHLEN
];
1993 if ( getcwd(cwdbuff
, MAXPATHLEN
) != NULL
) {
1994 // maybe use static buffer to avoid calling malloc so early...
1995 char* s
= new char[strlen(cwdbuff
) + strlen(sExecPath
) + 2];
1998 strcat(s
, sExecPath
);
2002 uintptr_t result
= 0;
2003 sMainExecutableMachHeader
= mainExecutableMH
;
2004 checkEnvironmentVariables(envp
, isEmulated
);
2005 if ( sEnv
.DYLD_PRINT_OPTS
)
2007 if ( sEnv
.DYLD_PRINT_ENV
)
2008 printEnvironmentVariables(envp
);
2010 setContext(argc
, argv
, envp
, apple
);
2011 ImageLoader
::BindingLaziness bindness
= sEnv
.DYLD_BIND_AT_LAUNCH ? ImageLoader
::kLazyAndNonLazy
: ImageLoader
::kNonLazyOnly
;
2013 // load any inserted libraries before loading the main executable so that they are first in flat namespace
2014 int insertLibrariesCount
= 0;
2015 if ( sEnv
.DYLD_INSERT_LIBRARIES
!= NULL
) {
2016 for (const char* const* lib
= sEnv
.DYLD_INSERT_LIBRARIES
; *lib
!= NULL
; ++lib
) {
2017 insertLibrariesCount
++;
2020 ImageLoader
* insertedImages
[insertLibrariesCount
];
2021 if ( insertLibrariesCount
> 0 ) {
2022 for (int i
=0; i
< insertLibrariesCount
; ++i
) {
2024 LoadContext context
;
2025 context
.useSearchPaths
= false;
2026 context
.useLdLibraryPath
= false;
2027 context
.dontLoad
= false;
2028 context
.mustBeBundle
= false;
2029 context
.mustBeDylib
= true;
2030 context
.matchByInstallName
= false;
2031 context
.origin
= NULL
; // can't use @loader_path with DYLD_INSERT_LIBRARIES
2032 context
.rpath
= NULL
;
2033 insertedImages
[i
] = load(sEnv
.DYLD_INSERT_LIBRARIES
[i
], context
);
2036 char buf
[strlen(sEnv
.DYLD_INSERT_LIBRARIES
[i
])+50];
2037 sprintf(buf
, "could not load inserted library: %s\n", sEnv
.DYLD_INSERT_LIBRARIES
[i
]);
2038 insertedImages
[i
] = NULL
;
2044 // load and link main executable
2046 sMainExecutable
= instantiateFromLoadedImage(mainExecutableMH
, sExecPath
);
2047 gLinkContext
.mainExecutable
= sMainExecutable
;
2048 if ( sMainExecutable
->forceFlat() ) {
2049 gLinkContext
.bindFlat
= true;
2050 gLinkContext
.prebindUsage
= ImageLoader
::kUseNoPrebinding
;
2052 link(sMainExecutable
, bindness
, ImageLoader
::kDontRunInitializers
);
2053 result
= (uintptr_t)sMainExecutable
->getMain();
2055 catch(const char* message
) {
2059 fprintf(stderr
, "dyld: launch failed\n");
2062 // Link in any inserted libraries.
2063 // Do this after link main executable so any extra libraries pulled in by inserted libraries are at end of flat namespace
2064 if ( insertLibrariesCount
> 0 ) {
2065 for (int i
=0; i
< insertLibrariesCount
; ++i
) {
2067 if ( insertedImages
[i
] != NULL
)
2068 link(insertedImages
[i
], bindness
, ImageLoader
::kDontRunInitializers
);
2070 catch (const char* message
) {
2071 char buf
[strlen(sEnv
.DYLD_INSERT_LIBRARIES
[i
])+50+strlen(message
)];
2072 sprintf(buf
, "could not link inserted library: %s\n%s\n", sEnv
.DYLD_INSERT_LIBRARIES
[i
], message
);