1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
3 * Copyright (c) 2004-2010 Apple 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@
26 #ifndef __IMAGELOADER__
27 #define __IMAGELOADER__
29 #include <sys/types.h>
32 #include <mach/mach_time.h> // struct mach_timebase_info
33 #include <mach/mach_init.h> // struct mach_thread_self
34 #include <mach/shared_region.h>
35 #include <mach-o/loader.h>
36 #include <mach-o/nlist.h>
39 #include <TargetConditionals.h>
42 #include <uuid/uuid.h>
45 #include <mach/vm_page_size.h>
48 #if __x86_64__ || __i386__
49 #include <CrashReporterClient.h>
51 // work around until iOS has CrashReporterClient.h
52 #define CRSetCrashLogMessage(x)
53 #define CRSetCrashLogMessage2(x)
56 #ifndef SHARED_REGION_BASE_ARM64
57 #define SHARED_REGION_BASE_ARM64 0x7FFF80000000LL
60 #ifndef SHARED_REGION_SIZE_ARM64
61 #define SHARED_REGION_SIZE_ARM64 0x10000000LL
65 #define LOG_BINDINGS 0
67 #include "mach-o/dyld_images.h"
68 #include "mach-o/dyld_priv.h"
69 #include "DyldSharedCache.h"
72 #define SHARED_REGION_BASE SHARED_REGION_BASE_I386
73 #define SHARED_REGION_SIZE SHARED_REGION_SIZE_I386
75 #define SHARED_REGION_BASE SHARED_REGION_BASE_X86_64
76 #define SHARED_REGION_SIZE SHARED_REGION_SIZE_X86_64
78 #define SHARED_REGION_BASE SHARED_REGION_BASE_ARM
79 #define SHARED_REGION_SIZE SHARED_REGION_SIZE_ARM
81 #define SHARED_REGION_BASE SHARED_REGION_BASE_ARM64
82 #define SHARED_REGION_SIZE SHARED_REGION_SIZE_ARM64
85 #ifndef EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER
86 #define EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER 0x10
88 #ifndef EXPORT_SYMBOL_FLAGS_REEXPORT
89 #define EXPORT_SYMBOL_FLAGS_REEXPORT 0x08
93 #define LC_MAIN (0x28|LC_REQ_DYLD) /* replacement for LC_UNIXTHREAD */
94 struct entry_point_command
{
95 uint32_t cmd
; /* LC_MAIN only used in MH_EXECUTE filetypes */
96 uint32_t cmdsize
; /* 24 */
97 uint64_t entryoff
; /* file (__TEXT) offset of main() */
98 uint64_t stacksize
;/* if not zero, initial stack size */
102 #if __IPHONE_OS_VERSION_MIN_REQUIRED
103 #define SPLIT_SEG_SHARED_REGION_SUPPORT 0
104 #define SPLIT_SEG_DYLIB_SUPPORT 0
105 #define PREBOUND_IMAGE_SUPPORT __arm__
106 #define TEXT_RELOC_SUPPORT __i386__
107 #define SUPPORT_OLD_CRT_INITIALIZATION 0
108 #define SUPPORT_LC_DYLD_ENVIRONMENT 1
109 #define SUPPORT_VERSIONED_PATHS 1
110 #define SUPPORT_CLASSIC_MACHO __arm__
111 #define SUPPORT_ZERO_COST_EXCEPTIONS (!__USING_SJLJ_EXCEPTIONS__)
112 #define INITIAL_IMAGE_COUNT 150
113 #define SUPPORT_ACCELERATE_TABLES !TARGET_IPHONE_SIMULATOR
114 #define SUPPORT_ROOT_PATH TARGET_IPHONE_SIMULATOR
115 #define USES_CHAINED_BINDS (__arm64e__)
117 #define SPLIT_SEG_SHARED_REGION_SUPPORT 0
118 #define SPLIT_SEG_DYLIB_SUPPORT __i386__
119 #define PREBOUND_IMAGE_SUPPORT __i386__
120 #define TEXT_RELOC_SUPPORT __i386__
121 #define SUPPORT_OLD_CRT_INITIALIZATION __i386__
122 #define SUPPORT_LC_DYLD_ENVIRONMENT (__i386__ || __x86_64__)
123 #define SUPPORT_VERSIONED_PATHS 1
124 #define SUPPORT_CLASSIC_MACHO 1
125 #define SUPPORT_ZERO_COST_EXCEPTIONS 1
126 #define INITIAL_IMAGE_COUNT 200
127 #define SUPPORT_ACCELERATE_TABLES 0
128 #define SUPPORT_ROOT_PATH 1
129 #define USES_CHAINED_BINDS 0
132 #define MAX_MACH_O_HEADER_AND_LOAD_COMMANDS_SIZE (32*1024)
134 #define MH_HAS_OBJC 0x40000000
137 // <rdar://problem/13590567> optimize away dyld's initializers
138 #define VECTOR_NEVER_DESTRUCTED(type) \
141 __vector_base<type, std::allocator<type> >::~__vector_base() { } \
143 #define VECTOR_NEVER_DESTRUCTED_EXTERN(type) \
146 __vector_base<type, std::allocator<type> >::~__vector_base(); \
148 #define VECTOR_NEVER_DESTRUCTED_IMPL(type) \
151 __vector_base<type, std::allocator<type> >::~__vector_base() { } \
156 extern __attribute__((noreturn
)) void throwf(const char* format
, ...) __attribute__((format(printf
, 1, 2)));
157 extern void log(const char* format
, ...) __attribute__((format(printf
, 1, 2)));
158 extern void warn(const char* format
, ...) __attribute__((format(printf
, 1, 2)));
159 extern const char* mkstringf(const char* format
, ...) __attribute__((format(printf
, 1, 2)));
161 extern void logBindings(const char* format
, ...) __attribute__((format(printf
, 1, 2)));
164 extern "C" int vm_alloc(vm_address_t
* addr
, vm_size_t size
, uint32_t flags
);
165 extern "C" void* xmmap(void* addr
, size_t len
, int prot
, int flags
, int fd
, off_t offset
);
169 struct macho_header
: public mach_header_64
{};
170 struct macho_nlist
: public nlist_64
{};
172 struct macho_header
: public mach_header
{};
173 struct macho_nlist
: public nlist
{};
178 #define dyld_page_trunc(__addr) (__addr & (-16384))
179 #define dyld_page_round(__addr) ((__addr + 16383) & (-16384))
180 #define dyld_page_size 16384
182 #define dyld_page_trunc(__addr) trunc_page_kernel(__addr)
183 #define dyld_page_round(__addr) round_page_kernel(__addr)
184 #define dyld_page_size vm_kernel_page_size
186 #define dyld_page_trunc(__addr) (__addr & (-4096))
187 #define dyld_page_round(__addr) ((__addr + 4095) & (-4096))
188 #define dyld_page_size 4096
197 const char*** NXArgvPtr
;
198 const char*** environPtr
;
199 const char** __prognamePtr
;
205 // ImageLoader is an abstract base class. To support loading a particular executable
206 // file format, you make a concrete subclass of ImageLoader.
208 // For each executable file (dynamic shared object) in use, an ImageLoader is instantiated.
210 // The ImageLoader base class does the work of linking together images, but it knows nothing
211 // about any particular file format.
217 typedef uint32_t DefinitionFlags
;
218 static const DefinitionFlags kNoDefinitionOptions
= 0;
219 static const DefinitionFlags kWeakDefinition
= 1;
221 typedef uint32_t ReferenceFlags
;
222 static const ReferenceFlags kNoReferenceOptions
= 0;
223 static const ReferenceFlags kWeakReference
= 1;
224 static const ReferenceFlags kTentativeDefinition
= 2;
226 enum PrebindMode
{ kUseAllPrebinding
, kUseSplitSegPrebinding
, kUseAllButAppPredbinding
, kUseNoPrebinding
};
227 enum BindingOptions
{ kBindingNone
, kBindingLazyPointers
, kBindingNeverSetLazyPointers
};
228 enum SharedRegionMode
{ kUseSharedRegion
, kUsePrivateSharedRegion
, kDontUseSharedRegion
, kSharedRegionIsSharedCache
};
230 struct Symbol
; // abstact symbol
232 struct MappedRegion
{
238 RPathChain(const RPathChain
* n
, std
::vector
<const char*>* p
) : next(n
), paths(p
) {};
239 const RPathChain
* next
;
240 std
::vector
<const char*>* paths
;
245 const mach_header
* imageHeader
;
246 const char* imageShortName
;
249 struct DynamicReference
{
254 struct InitializerTimingList
258 const char* shortName
;
262 void addTime(const char* name
, uint64_t time
);
265 typedef void (^CoalesceNotifier
)(const Symbol
* implSym
, const ImageLoader
* implIn
, const mach_header
* implMh
);
268 ImageLoader
* (*loadLibrary
)(const char* libraryName
, bool search
, const char* origin
, const RPathChain
* rpaths
, bool enforceIOSMac
, unsigned& cacheIndex
);
269 void (*terminationRecorder
)(ImageLoader
* image
);
270 bool (*flatExportFinder
)(const char* name
, const Symbol
** sym
, const ImageLoader
** image
);
271 bool (*coalescedExportFinder
)(const char* name
, const Symbol
** sym
, const ImageLoader
** image
, CoalesceNotifier
);
272 unsigned int (*getCoalescedImages
)(ImageLoader
* images
[], unsigned imageIndex
[]);
273 void (*undefinedHandler
)(const char* name
);
274 MappedRegion
* (*getAllMappedRegions
)(MappedRegion
*);
275 void * (*bindingHandler
)(const char *, const char *, void *);
276 void (*notifySingle
)(dyld_image_states
, const ImageLoader
* image
, InitializerTimingList
*);
277 void (*notifyBatch
)(dyld_image_states state
, bool preflightOnly
);
278 void (*removeImage
)(ImageLoader
* image
);
279 void (*registerDOFs
)(const std
::vector
<DOFInfo
>& dofs
);
280 void (*clearAllDepths
)();
281 void (*printAllDepths
)();
282 unsigned int (*imageCount
)();
283 void (*setNewProgramVars
)(const ProgramVars
&);
284 bool (*inSharedCache
)(const char* path
);
285 void (*setErrorStrings
)(unsigned errorCode
, const char* errorClientOfDylibPath
,
286 const char* errorTargetDylibPath
, const char* errorSymbol
);
287 ImageLoader
* (*findImageContainingAddress
)(const void* addr
);
288 void (*addDynamicReference
)(ImageLoader
* from
, ImageLoader
* to
);
289 #if SUPPORT_ACCELERATE_TABLES
290 void (*notifySingleFromCache
)(dyld_image_states
, const mach_header
* mh
, const char* path
);
291 dyld_image_state_change_handler (*getPreInitNotifyHandler
)(unsigned index
);
292 dyld_image_state_change_handler (*getBoundBatchHandler
)(unsigned index
);
295 #if SUPPORT_OLD_CRT_INITIALIZATION
296 void (*setRunInitialzersOldWay
)();
298 BindingOptions bindingOptions
;
303 const char* progname
;
304 ProgramVars programVars
;
305 ImageLoader
* mainExecutable
;
306 const char* const * imageSuffix
;
307 #if SUPPORT_ROOT_PATH
308 const char** rootPaths
;
310 const DyldSharedCache
* dyldCache
;
311 const dyld_interpose_tuple
* dynamicInterposeArray
;
312 size_t dynamicInterposeCount
;
313 PrebindMode prebindUsage
;
314 SharedRegionMode sharedRegionMode
;
315 bool dyldLoadedAtSameAddressNeededBySharedCache
;
316 bool strictMachORequired
;
318 bool allowEnvVarsPrint
;
319 bool allowEnvVarsPath
;
320 bool allowEnvVarsSharedCache
;
321 bool allowClassicFallbackPaths
;
322 bool allowInsertFailures
;
323 bool mainExecutableCodeSigned
;
324 bool preFetchDisabled
;
327 bool linkingMainExecutable
;
328 bool startedInitializingMainExecutable
;
329 #if __MAC_OS_X_VERSION_MIN_REQUIRED
338 bool verboseWeakBind
;
341 bool verbosePrebinding
;
342 bool verboseCoreSymbolication
;
343 bool verboseWarnings
;
345 bool verboseInterposing
;
346 bool verboseCodeSignatures
;
352 const char* symbolName
;
353 unsigned int loadOrder
;
357 // the following are private to the ImageLoader subclass
363 uintptr_t imageIndex
;
366 virtual void initializeCoalIterator(CoalIterator
&, unsigned int loadOrder
, unsigned imageIndex
) = 0;
367 virtual bool incrementCoalIterator(CoalIterator
&) = 0;
368 virtual uintptr_t getAddressCoalIterator(CoalIterator
&, const LinkContext
& context
) = 0;
369 virtual void updateUsesCoalIterator(CoalIterator
&, uintptr_t newAddr
, ImageLoader
* target
, unsigned targetIndex
, const LinkContext
& context
) = 0;
371 struct UninitedUpwards
374 ImageLoader
* images
[1];
378 // constructor is protected, but anyone can delete an image
379 virtual ~ImageLoader();
381 // link() takes a newly instantiated ImageLoader and does all
382 // fixups needed to make it usable by the process
383 void link(const LinkContext
& context
, bool forceLazysBound
, bool preflight
, bool neverUnload
, const RPathChain
& loaderRPaths
, const char* imagePath
);
385 // runInitializers() is normally called in link() but the main executable must
386 // run crt code before initializers
387 void runInitializers(const LinkContext
& context
, InitializerTimingList
& timingInfo
);
389 // called after link() forces all lazy pointers to be bound
390 void bindAllLazyPointers(const LinkContext
& context
, bool recursive
);
392 // used by dyld to see if a requested library is already loaded (might be symlink)
393 bool statMatch(const struct stat
& stat_buf
) const;
395 // get short name of this image
396 const char* getShortName() const;
399 static const char* shortName(const char* fullName
);
401 // get path used to load this image, not necessarily the "real" path
402 const char* getPath() const { return fPath
; }
404 uint32_t getPathHash() const { return fPathHash
; }
406 // get the "real" path for this image (e.g. no @rpath)
407 const char* getRealPath() const;
409 // get path this image is intended to be placed on disk or NULL if no preferred install location
410 virtual const char* getInstallPath() const = 0;
412 // image was loaded with NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME and all clients are looking for install path
413 bool matchInstallPath() const;
414 void setMatchInstallPath(bool);
416 // mark that this image's exported symbols should be ignored when linking other images (e.g. RTLD_LOCAL)
417 void setHideExports(bool hide
= true);
419 // check if this image's exported symbols should be ignored when linking other images
420 bool hasHiddenExports() const;
422 // checks if this image is already linked into the process
423 bool isLinked() const;
425 // even if image is deleted, leave segments mapped in
426 void setLeaveMapped();
428 // even if image is deleted, leave segments mapped in
429 bool leaveMapped() { return fLeaveMapped
; }
431 // image resides in dyld shared cache
432 virtual bool inSharedCache() const { return false; };
434 // checks if the specifed address is within one of this image's segments
435 virtual bool containsAddress(const void* addr
) const;
437 // checks if the specifed symbol is within this image's symbol table
438 virtual bool containsSymbol(const void* addr
) const = 0;
440 // checks if the specifed address range overlaps any of this image's segments
441 virtual bool overlapsWithAddressRange(const void* start
, const void* end
) const;
443 // adds to list of ranges of memory mapped in
444 void getMappedRegions(MappedRegion
*& region
) const;
446 // st_mtime from stat() on file
447 time_t lastModified() const;
449 // only valid for main executables, returns a pointer its entry point from LC_MAIN
450 virtual void* getEntryFromLC_MAIN() const = 0;
452 // only valid for main executables, returns a pointer its main from LC_UNIXTHREAD
453 virtual void* getEntryFromLC_UNIXTHREAD() const = 0;
455 // dyld API's require each image to have an associated mach_header
456 virtual const struct mach_header
* machHeader() const = 0;
458 // dyld API's require each image to have a slide (actual load address minus preferred load address)
459 virtual uintptr_t getSlide() const = 0;
461 // last address mapped by image
462 virtual const void* getEnd() const = 0;
464 // image has exports that participate in runtime coalescing
465 virtual bool hasCoalescedExports() const = 0;
467 // search symbol table of definitions in this image for requested name
468 virtual bool findExportedSymbolAddress(const LinkContext
& context
, const char* symbolName
,
469 const ImageLoader
* requestorImage
, int requestorOrdinalOfDef
,
470 bool runResolver
, const ImageLoader
** foundIn
, uintptr_t* address
) const;
472 // search symbol table of definitions in this image for requested name
473 virtual const Symbol
* findExportedSymbol(const char* name
, bool searchReExports
, const char* thisPath
, const ImageLoader
** foundIn
) const = 0;
475 // search symbol table of definitions in this image for requested name
476 virtual const Symbol
* findExportedSymbol(const char* name
, bool searchReExports
, const ImageLoader
** foundIn
) const {
477 return findExportedSymbol(name
, searchReExports
, this->getPath(), foundIn
);
480 // gets address of implementation (code) of the specified exported symbol
481 virtual uintptr_t getExportedSymbolAddress(const Symbol
* sym
, const LinkContext
& context
,
482 const ImageLoader
* requestor
=NULL
, bool runResolver
=false, const char* symbolName
=NULL
) const = 0;
484 // gets attributes of the specified exported symbol
485 virtual DefinitionFlags
getExportedSymbolInfo(const Symbol
* sym
) const = 0;
487 // gets name of the specified exported symbol
488 virtual const char* getExportedSymbolName(const Symbol
* sym
) const = 0;
490 // gets how many symbols are exported by this image
491 virtual uint32_t getExportedSymbolCount() const = 0;
493 // gets the i'th exported symbol
494 virtual const Symbol
* getIndexedExportedSymbol(uint32_t index
) const = 0;
496 // find exported symbol as if imported by this image
498 virtual const Symbol
* findExportedSymbolInDependentImages(const char* name
, const LinkContext
& context
, const ImageLoader
** foundIn
) const;
500 // find exported symbol as if imported by this image
502 virtual const Symbol
* findExportedSymbolInImageOrDependentImages(const char* name
, const LinkContext
& context
, const ImageLoader
** foundIn
) const;
504 // gets how many symbols are imported by this image
505 virtual uint32_t getImportedSymbolCount() const = 0;
507 // gets the i'th imported symbol
508 virtual const Symbol
* getIndexedImportedSymbol(uint32_t index
) const = 0;
510 // gets attributes of the specified imported symbol
511 virtual ReferenceFlags
getImportedSymbolInfo(const Symbol
* sym
) const = 0;
513 // gets name of the specified imported symbol
514 virtual const char* getImportedSymbolName(const Symbol
* sym
) const = 0;
516 // find the closest symbol before addr
517 virtual const char* findClosestSymbol(const void* addr
, const void** closestAddr
) const = 0;
519 // for use with accelerator tables
520 virtual const char* getIndexedPath(unsigned) const { return getPath(); }
521 virtual const char* getIndexedShortName(unsigned) const { return getShortName(); }
523 // checks if this image is a bundle and can be loaded but not linked
524 virtual bool isBundle() const = 0;
526 // checks if this image is a dylib
527 virtual bool isDylib() const = 0;
529 // checks if this image is a main executable
530 virtual bool isExecutable() const = 0;
532 // checks if this image is a main executable
533 virtual bool isPositionIndependentExecutable() const = 0;
535 // only for main executable
536 virtual bool forceFlat() const = 0;
538 // called at runtime when a lazily bound function is first called
539 virtual uintptr_t doBindLazySymbol(uintptr_t* lazyPointer
, const LinkContext
& context
) = 0;
541 // called at runtime when a fast lazily bound function is first called
542 virtual uintptr_t doBindFastLazySymbol(uint32_t lazyBindingInfoOffset
, const LinkContext
& context
,
543 void (*lock
)(), void (*unlock
)()) = 0;
545 // calls termination routines (e.g. C++ static destructors for image)
546 virtual void doTermination(const LinkContext
& context
) = 0;
548 // return if this image has initialization routines
549 virtual bool needsInitialization() = 0;
551 // return if this image has specified section and set start and length
552 virtual bool getSectionContent(const char* segmentName
, const char* sectionName
, void** start
, size_t* length
) = 0;
554 // fills in info about __eh_frame and __unwind_info sections
555 virtual void getUnwindInfo(dyld_unwind_sections
* info
) = 0;
557 // given a pointer into an image, find which segment and section it is in
558 virtual const struct macho_section
* findSection(const void* imageInterior
) const = 0;
560 // given a pointer into an image, find which segment and section it is in
561 virtual bool findSection(const void* imageInterior
, const char** segmentName
, const char** sectionName
, size_t* sectionOffset
) = 0;
563 // the image supports being prebound
564 virtual bool isPrebindable() const = 0;
566 // the image is prebindable and its prebinding is valid
567 virtual bool usablePrebinding(const LinkContext
& context
) const = 0;
569 // add all RPATH paths this image contains
570 virtual void getRPaths(const LinkContext
& context
, std
::vector
<const char*>&) const = 0;
572 // image has or uses weak definitions that need runtime coalescing
573 virtual bool participatesInCoalescing() const = 0;
575 // if image has a UUID, copy into parameter and return true
576 virtual bool getUUID(uuid_t
) const = 0;
578 // dynamic interpose values onto this image
579 virtual void dynamicInterpose(const LinkContext
& context
) = 0;
581 // record interposing for any late binding
582 void addDynamicInterposingTuples(const struct dyld_interpose_tuple array
[], size_t count
);
584 virtual const char* libPath(unsigned int) const = 0;
586 // Image has objc sections, so information objc about when it comes and goes
587 virtual bool notifyObjC() const { return false; }
589 virtual bool overridesCachedDylib(uint32_t& num
) const { return false; }
590 virtual void setOverridesCachedDylib(uint32_t num
) { }
594 // A segment is a chunk of an executable file that is mapped into memory.
596 virtual unsigned int segmentCount() const = 0;
597 virtual const char* segName(unsigned int) const = 0;
598 virtual uintptr_t segSize(unsigned int) const = 0;
599 virtual uintptr_t segFileSize(unsigned int) const = 0;
600 virtual bool segHasTrailingZeroFill(unsigned int) = 0;
601 virtual uintptr_t segFileOffset(unsigned int) const = 0;
602 virtual bool segReadable(unsigned int) const = 0;
603 virtual bool segWriteable(unsigned int) const = 0;
604 virtual bool segExecutable(unsigned int) const = 0;
605 virtual bool segUnaccessible(unsigned int) const = 0;
606 virtual bool segHasPreferredLoadAddress(unsigned int) const = 0;
607 virtual uintptr_t segPreferredLoadAddress(unsigned int) const = 0;
608 virtual uintptr_t segActualLoadAddress(unsigned int) const = 0;
609 virtual uintptr_t segActualEndAddress(unsigned int) const = 0;
612 // info from LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS
613 virtual uint32_t sdkVersion() const = 0;
614 virtual uint32_t minOSVersion() const = 0;
616 // if the image contains interposing functions, register them
617 virtual void registerInterposing(const LinkContext
& context
) = 0;
619 virtual bool usesChainedFixups() const { return false; }
622 // when resolving symbols look in subImage if symbol can't be found
623 void reExport(ImageLoader
* subImage
);
625 virtual void recursiveBind(const LinkContext
& context
, bool forceLazysBound
, bool neverUnload
);
626 virtual void recursiveBindWithAccounting(const LinkContext
& context
, bool forceLazysBound
, bool neverUnload
);
627 void weakBind(const LinkContext
& context
);
629 void applyInterposing(const LinkContext
& context
);
631 dyld_image_states
getState() { return (dyld_image_states
)fState
; }
633 ino_t
getInode() const { return fInode
; }
634 dev_t
getDevice() const { return fDevice
; }
636 // used to sort images bottom-up
637 int compare(const ImageLoader
* right
) const;
639 void incrementDlopenReferenceCount() { ++fDlopenReferenceCount
; }
641 bool decrementDlopenReferenceCount();
643 void printReferenceCounts();
645 uint32_t dlopenCount() const { return fDlopenReferenceCount
; }
647 void setCanUnload() { fNeverUnload
= false; fLeaveMapped
= false; }
649 bool neverUnload() const { return fNeverUnload
; }
651 void setNeverUnload() { fNeverUnload
= true; fLeaveMapped
= true; }
652 void setNeverUnloadRecursive();
654 bool isReferencedDownward() { return fIsReferencedDownward
; }
656 virtual uintptr_t resolveWeak(const LinkContext
& context
, const char* symbolName
, bool weak_import
, bool runResolver
,
657 const ImageLoader
** foundIn
) { return 0; }
659 // triggered by DYLD_PRINT_STATISTICS to write info on work done and how fast
660 static void printStatistics(unsigned int imageCount
, const InitializerTimingList
& timingInfo
);
661 static void printStatisticsDetails(unsigned int imageCount
, const InitializerTimingList
& timingInfo
);
663 // used with DYLD_IMAGE_SUFFIX
664 static void addSuffix(const char* path
, const char* suffix
, char* result
);
666 static uint32_t hash(const char*);
668 static const uint8_t* trieWalk(const uint8_t* start
, const uint8_t* end
, const char* stringToFind
);
670 // used instead of directly deleting image
671 static void deleteImage(ImageLoader
*);
673 static bool haveInterposingTuples() { return !fgInterposingTuples
.empty(); }
674 static void clearInterposingTuples() { fgInterposingTuples
.clear(); }
676 static void applyInterposingToDyldCache(const LinkContext
& context
);
678 bool dependsOn(ImageLoader
* image
);
680 void setPath(const char* path
);
681 void setPaths(const char* path
, const char* realPath
);
682 void setPathUnowned(const char* path
);
684 void clearDepth() { fDepth
= 0; }
685 int getDepth() { return fDepth
; }
687 void setBeingRemoved() { fBeingRemoved
= true; }
688 bool isBeingRemoved() const { return fBeingRemoved
; }
690 void markNotUsed() { fMarkedInUse
= false; }
691 void markedUsedRecursive(const std
::vector
<DynamicReference
>&);
692 bool isMarkedInUse() const { return fMarkedInUse
; }
694 void setAddFuncNotified() { fAddFuncNotified
= true; }
695 bool addFuncNotified() const { return fAddFuncNotified
; }
697 struct InterposeTuple
{
698 uintptr_t replacement
;
699 ImageLoader
* neverImage
; // don't apply replacement to this image
700 ImageLoader
* onlyImage
; // only apply replacement to this image
704 static uintptr_t read_uleb128(const uint8_t*& p
, const uint8_t* end
);
705 static intptr_t read_sleb128(const uint8_t*& p
, const uint8_t* end
);
707 void vmAccountingSetSuspended(const LinkContext
& context
, bool suspend
);
710 // abstract base class so all constructors protected
711 ImageLoader(const char* path
, unsigned int libCount
);
712 ImageLoader(const ImageLoader
&);
713 void operator=(const ImageLoader
&);
714 void operator delete(void* image
) throw() { ::free(image
); }
723 struct DependentLibrary
{
725 uint32_t required
: 1,
731 struct DependentLibraryInfo
{
740 typedef void (*Initializer
)(int argc
, const char* argv
[], const char* envp
[], const char* apple
[], const ProgramVars
* vars
);
741 typedef void (*Terminator
)(void);
745 unsigned int libraryCount() const { return fLibraryCount
; }
746 virtual ImageLoader
* libImage(unsigned int) const = 0;
747 virtual bool libReExported(unsigned int) const = 0;
748 virtual bool libIsUpward(unsigned int) const = 0;
749 virtual void setLibImage(unsigned int, ImageLoader
*, bool, bool) = 0;
751 // To link() an image, its dependent libraries are loaded, it is rebased, bound, and initialized.
752 // These methods do the above, exactly once, and it the right order
753 virtual void recursiveLoadLibraries(const LinkContext
& context
, bool preflightOnly
, const RPathChain
& loaderRPaths
, const char* loadPath
);
754 virtual unsigned recursiveUpdateDepth(unsigned int maxDepth
);
755 virtual void recursiveRebase(const LinkContext
& context
);
756 virtual void recursiveApplyInterposing(const LinkContext
& context
);
757 virtual void recursiveGetDOFSections(const LinkContext
& context
, std
::vector
<DOFInfo
>& dofs
);
758 virtual void recursiveInitialization(const LinkContext
& context
, mach_port_t this_thread
, const char* pathToInitialize
,
759 ImageLoader
::InitializerTimingList
&, ImageLoader
::UninitedUpwards
&);
761 // fill in information about dependent libraries (array length is fLibraryCount)
762 virtual void doGetDependentLibraries(DependentLibraryInfo libs
[]) = 0;
764 // called on images that are libraries, returns info about itself
765 virtual LibraryInfo
doGetLibraryInfo(const LibraryInfo
& requestorInfo
) = 0;
767 // do any fix ups in this image that depend only on the load address of the image
768 virtual void doRebase(const LinkContext
& context
) = 0;
770 // do any symbolic fix ups in this image
771 virtual void doBind(const LinkContext
& context
, bool forceLazysBound
) = 0;
773 // called later via API to force all lazy pointer to be bound
774 virtual void doBindJustLazies(const LinkContext
& context
) = 0;
776 // if image has any dtrace DOF sections, append them to list to be registered
777 virtual void doGetDOFSections(const LinkContext
& context
, std
::vector
<DOFInfo
>& dofs
) = 0;
780 virtual void doInterpose(const LinkContext
& context
) = 0;
782 // run any initialization routines in this image
783 virtual bool doInitialization(const LinkContext
& context
) = 0;
785 // return if this image has termination routines
786 virtual bool needsTermination() = 0;
788 // support for runtimes in which segments don't have to maintain their relative positions
789 virtual bool segmentsMustSlideTogether() const = 0;
791 // built with PIC code and can load at any address
792 virtual bool segmentsCanSlide() const = 0;
794 // set how much all segments slide
795 virtual void setSlide(intptr_t slide
) = 0;
797 // returns if all dependent libraries checksum's were as expected and none slide
798 bool allDependentLibrariesAsWhenPreBound() const;
800 // in mach-o a child tells it parent to re-export, instead of the other way around...
801 virtual bool isSubframeworkOf(const LinkContext
& context
, const ImageLoader
* image
) const = 0;
803 // in mach-o a parent library knows name of sub libraries it re-exports..
804 virtual bool hasSubLibrary(const LinkContext
& context
, const ImageLoader
* child
) const = 0;
806 virtual bool weakSymbolsBound(unsigned index
) { return fWeakSymbolsBound
; }
807 virtual void setWeakSymbolsBound(unsigned index
) { fWeakSymbolsBound
= true; }
809 // set fState to dyld_image_state_memory_mapped
810 void setMapped(const LinkContext
& context
);
812 void setFileInfo(dev_t device
, ino_t inode
, time_t modDate
);
814 void setDepth(uint16_t depth
) { fDepth
= depth
; }
816 static uintptr_t interposedAddress(const LinkContext
& context
, uintptr_t address
, const ImageLoader
* notInImage
, const ImageLoader
* onlyInImage
=NULL
);
818 static uintptr_t fgNextPIEDylibAddress
;
819 static uint32_t fgImagesWithUsedPrebinding
;
820 static uint32_t fgImagesUsedFromSharedCache
;
821 static uint32_t fgImagesHasWeakDefinitions
;
822 static uint32_t fgImagesRequiringCoalescing
;
823 static uint32_t fgTotalRebaseFixups
;
824 static uint32_t fgTotalBindFixups
;
825 static uint32_t fgTotalBindSymbolsResolved
;
826 static uint32_t fgTotalBindImageSearches
;
827 static uint32_t fgTotalLazyBindFixups
;
828 static uint32_t fgTotalPossibleLazyBindFixups
;
829 static uint32_t fgTotalSegmentsMapped
;
830 static uint32_t fgSymbolTrieSearchs
;
831 static uint64_t fgTotalBytesMapped
;
832 static uint64_t fgTotalBytesPreFetched
;
833 static uint64_t fgTotalLoadLibrariesTime
;
835 static uint64_t fgTotalObjCSetupTime
;
836 static uint64_t fgTotalDebuggerPausedTime
;
837 static uint64_t fgTotalRebindCacheTime
;
838 static uint64_t fgTotalRebaseTime
;
839 static uint64_t fgTotalBindTime
;
840 static uint64_t fgTotalWeakBindTime
;
841 static uint64_t fgTotalDOF
;
842 static uint64_t fgTotalInitTime
;
845 static std
::vector
<InterposeTuple
> fgInterposingTuples
;
848 const char* fRealPath
;
851 time_t fLastModified
;
853 uint32_t fDlopenReferenceCount
; // count of how many dlopens have been done on this image
855 struct recursive_lock
{
856 recursive_lock(mach_port_t t
) : thread(t
), count(0) {}
860 void recursiveSpinLock(recursive_lock
&);
861 void recursiveSpinUnLock();
864 const ImageLoader
::Symbol
* findExportedSymbolInDependentImagesExcept(const char* name
, const ImageLoader
** dsiStart
,
865 const ImageLoader
**& dsiCur
, const ImageLoader
** dsiEnd
, const ImageLoader
** foundIn
) const;
867 void processInitializers(const LinkContext
& context
, mach_port_t this_thread
,
868 InitializerTimingList
& timingInfo
, ImageLoader
::UninitedUpwards
& ups
);
871 recursive_lock
* fInitializerRecursiveLock
;
876 fAllLibraryChecksumsAndLoadAddressesMatch
: 1,
877 fLeaveMapped
: 1, // when unloaded, leave image mapped in cause some other code may have pointers into it
878 fNeverUnload
: 1, // image was statically loaded by main executable
879 fHideSymbols
: 1, // ignore this image's exported symbols when linking other images
880 fMatchByInstallName
: 1,// look at image's install-path not its load path
883 fAllLazyPointersBound
: 1,
886 fAddFuncNotified
: 1,
887 fPathOwnedByImage
: 1,
888 fIsReferencedDownward
: 1,
889 fWeakSymbolsBound
: 1;
891 static uint16_t fgLoadOrdinal
;
895 VECTOR_NEVER_DESTRUCTED_EXTERN(ImageLoader
::InterposeTuple
);