projects / apple / dyld.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
dyld-832.7.1.tar.gz
[apple/dyld.git] / src / ImageLoader.h
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2004-2010 Apple Inc. All rights reserved.
4 *
5 * @APPLE_LICENSE_HEADER_START@
6 *
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
12 * file.
13 *
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.
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24
25
26 #ifndef __IMAGELOADER__
27 #define __IMAGELOADER__
28
29 #include <sys/types.h>
30 #include <unistd.h>
31 #include <stdlib.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>
37 #include <mach-o/dyld_images.h>
38 #include <mach-o/dyld_priv.h>
39 #include <stdint.h>
40 #include <stdlib.h>
41 #include <TargetConditionals.h>
42 #include <vector>
43 #include <new>
44 #include <uuid/uuid.h>
45
46 #if !TARGET_OS_DRIVERKIT && (BUILDING_LIBDYLD || BUILDING_DYLD)
47 #include <CrashReporterClient.h>
48 #else
49 #define CRSetCrashLogMessage(x)
50 #define CRSetCrashLogMessage2(x)
51 #endif
52
53 #include "DyldSharedCache.h"
54
55 #include "Map.h"
56
57 #if __arm__
58 #include <mach/vm_page_size.h>
59 #endif
60
61
62 #ifndef SHARED_REGION_BASE_ARM64
63 #define SHARED_REGION_BASE_ARM64 0x7FFF80000000LL
64 #endif
65
66 #ifndef SHARED_REGION_SIZE_ARM64
67 #define SHARED_REGION_SIZE_ARM64 0x10000000LL
68 #endif
69
70
71 #define LOG_BINDINGS 0
72
73
74 #if TARGET_OS_IPHONE
75 #define SPLIT_SEG_SHARED_REGION_SUPPORT 0
76 #define SPLIT_SEG_DYLIB_SUPPORT 0
77 #define PREBOUND_IMAGE_SUPPORT __arm__
78 #define TEXT_RELOC_SUPPORT __i386__
79 #define SUPPORT_OLD_CRT_INITIALIZATION 0
80 #define SUPPORT_LC_DYLD_ENVIRONMENT 1
81 #define SUPPORT_VERSIONED_PATHS 0
82 #define SUPPORT_CLASSIC_MACHO __arm__
83 #define SUPPORT_ZERO_COST_EXCEPTIONS (!__USING_SJLJ_EXCEPTIONS__)
84 #define INITIAL_IMAGE_COUNT 150
85 #define SUPPORT_ACCELERATE_TABLES 0
86 #define SUPPORT_ROOT_PATH TARGET_OS_SIMULATOR
87 #else
88 #define SPLIT_SEG_SHARED_REGION_SUPPORT 0
89 #define SPLIT_SEG_DYLIB_SUPPORT __i386__
90 #define PREBOUND_IMAGE_SUPPORT __i386__
91 #define TEXT_RELOC_SUPPORT __i386__
92 #define SUPPORT_OLD_CRT_INITIALIZATION __i386__
93 #define SUPPORT_LC_DYLD_ENVIRONMENT 1
94 #define SUPPORT_VERSIONED_PATHS 1
95 #define SUPPORT_CLASSIC_MACHO 1
96 #define SUPPORT_ZERO_COST_EXCEPTIONS 1
97 #define INITIAL_IMAGE_COUNT 200
98 #define SUPPORT_ACCELERATE_TABLES 0
99 #define SUPPORT_ROOT_PATH 1
100 #endif
101
102 #define MAX_MACH_O_HEADER_AND_LOAD_COMMANDS_SIZE (32*1024)
103
104
105 // <rdar://problem/13590567> optimize away dyld's initializers
106 #define VECTOR_NEVER_DESTRUCTED(type) \
107 namespace std { \
108 template <> \
109 __vector_base<type, std::allocator<type> >::~__vector_base() { } \
110 }
111 #define VECTOR_NEVER_DESTRUCTED_EXTERN(type) \
112 namespace std { \
113 template <> \
114 __vector_base<type, std::allocator<type> >::~__vector_base(); \
115 }
116 #define VECTOR_NEVER_DESTRUCTED_IMPL(type) \
117 namespace std { \
118 template <> \
119 __vector_base<type, std::allocator<type> >::~__vector_base() { } \
120 }
121
122 // utilities
123 namespace dyld {
124 extern __attribute__((noreturn)) void throwf(const char* format, ...) __attribute__((format(printf, 1, 2)));
125 extern void log(const char* format, ...) __attribute__((format(printf, 1, 2)));
126 extern void warn(const char* format, ...) __attribute__((format(printf, 1, 2)));
127 extern const char* mkstringf(const char* format, ...) __attribute__((format(printf, 1, 2)));
128 #if LOG_BINDINGS
129 extern void logBindings(const char* format, ...) __attribute__((format(printf, 1, 2)));
130 #endif
131 }
132 extern "C" int vm_alloc(vm_address_t* addr, vm_size_t size, uint32_t flags);
133 extern "C" void* xmmap(void* addr, size_t len, int prot, int flags, int fd, off_t offset);
134
135
136 #if __LP64__
137 struct macho_header : public mach_header_64 {};
138 struct macho_nlist : public nlist_64 {};
139 #else
140 struct macho_header : public mach_header {};
141 struct macho_nlist : public nlist {};
142 #endif
143
144
145 #if __arm64__
146 #define dyld_page_trunc(__addr) (__addr & (-16384))
147 #define dyld_page_round(__addr) ((__addr + 16383) & (-16384))
148 #define dyld_page_size 16384
149 #elif __arm__
150 #define dyld_page_trunc(__addr) trunc_page_kernel(__addr)
151 #define dyld_page_round(__addr) round_page_kernel(__addr)
152 #define dyld_page_size vm_kernel_page_size
153 #else
154 #define dyld_page_trunc(__addr) (__addr & (-4096))
155 #define dyld_page_round(__addr) ((__addr + 4095) & (-4096))
156 #define dyld_page_size 4096
157 #endif
158
159
160 #define DYLD_PACKED_VERSION(major, minor, tiny) ((((major) & 0xffff) << 16) | (((minor) & 0xff) << 8) | ((tiny) & 0xff))
161
162 struct ProgramVars
163 {
164 const void* mh;
165 int* NXArgcPtr;
166 const char*** NXArgvPtr;
167 const char*** environPtr;
168 const char** __prognamePtr;
169 };
170
171
172
173 enum dyld_image_states
174 {
175 dyld_image_state_mapped = 10, // No batch notification for this
176 dyld_image_state_dependents_mapped = 20, // Only batch notification for this
177 dyld_image_state_rebased = 30,
178 dyld_image_state_bound = 40,
179 dyld_image_state_dependents_initialized = 45, // Only single notification for this
180 dyld_image_state_initialized = 50,
181 dyld_image_state_terminated = 60 // Only single notification for this
182 };
183 typedef const char* (*dyld_image_state_change_handler)(enum dyld_image_states state, uint32_t infoCount, const struct dyld_image_info info[]);
184
185 //
186 // ImageLoader is an abstract base class. To support loading a particular executable
187 // file format, you make a concrete subclass of ImageLoader.
188 //
189 // For each executable file (dynamic shared object) in use, an ImageLoader is instantiated.
190 //
191 // The ImageLoader base class does the work of linking together images, but it knows nothing
192 // about any particular file format.
193 //
194 //
195 class ImageLoader {
196 public:
197
198 typedef uint32_t DefinitionFlags;
199 static const DefinitionFlags kNoDefinitionOptions = 0;
200 static const DefinitionFlags kWeakDefinition = 1;
201
202 typedef uint32_t ReferenceFlags;
203 static const ReferenceFlags kNoReferenceOptions = 0;
204 static const ReferenceFlags kWeakReference = 1;
205 static const ReferenceFlags kTentativeDefinition = 2;
206
207 enum PrebindMode { kUseAllPrebinding, kUseSplitSegPrebinding, kUseAllButAppPredbinding, kUseNoPrebinding };
208 enum BindingOptions { kBindingNone, kBindingLazyPointers, kBindingNeverSetLazyPointers };
209 enum SharedRegionMode { kUseSharedRegion, kUsePrivateSharedRegion, kDontUseSharedRegion, kSharedRegionIsSharedCache };
210
211 struct Symbol; // abstact symbol
212
213 struct MappedRegion {
214 uintptr_t address;
215 size_t size;
216 };
217
218 struct RPathChain {
219 RPathChain(const RPathChain* n, std::vector<const char*>* p) : next(n), paths(p) {};
220 const RPathChain* next;
221 std::vector<const char*>* paths;
222 };
223
224 struct DOFInfo {
225 void* dof;
226 const mach_header* imageHeader;
227 const char* imageShortName;
228 };
229
230 struct DynamicReference {
231 ImageLoader* from;
232 ImageLoader* to;
233 };
234
235 struct InitializerTimingList
236 {
237 uintptr_t count;
238 struct {
239 const char* shortName;
240 uint64_t initTime;
241 } images[1];
242
243 void addTime(const char* name, uint64_t time);
244 };
245
246 typedef void (^CoalesceNotifier)(const Symbol* implSym, const ImageLoader* implIn, const mach_header* implMh);
247
248 struct HashCString {
249 static size_t hash(const char* v);
250 };
251
252 struct EqualCString {
253 static bool equal(const char* s1, const char* s2);
254 };
255
256 struct LinkContext {
257 ImageLoader* (*loadLibrary)(const char* libraryName, bool search, const char* origin, const RPathChain* rpaths, unsigned& cacheIndex);
258 void (*terminationRecorder)(ImageLoader* image);
259 bool (*flatExportFinder)(const char* name, const Symbol** sym, const ImageLoader** image);
260 bool (*coalescedExportFinder)(const char* name, const Symbol** sym, const ImageLoader** image, CoalesceNotifier);
261 unsigned int (*getCoalescedImages)(ImageLoader* images[], unsigned imageIndex[]);
262 void (*undefinedHandler)(const char* name);
263 MappedRegion* (*getAllMappedRegions)(MappedRegion*);
264 void * (*bindingHandler)(const char *, const char *, void *);
265 void (*notifySingle)(dyld_image_states, const ImageLoader* image, InitializerTimingList*);
266 void (*notifyBatch)(dyld_image_states state, bool preflightOnly);
267 void (*removeImage)(ImageLoader* image);
268 void (*registerDOFs)(const std::vector<DOFInfo>& dofs);
269 void (*clearAllDepths)();
270 void (*printAllDepths)();
271 unsigned int (*imageCount)();
272 void (*setNewProgramVars)(const ProgramVars&);
273 bool (*inSharedCache)(const char* path);
274 void (*setErrorStrings)(unsigned errorCode, const char* errorClientOfDylibPath,
275 const char* errorTargetDylibPath, const char* errorSymbol);
276 ImageLoader* (*findImageContainingAddress)(const void* addr);
277 void (*addDynamicReference)(ImageLoader* from, ImageLoader* to);
278 #if SUPPORT_ACCELERATE_TABLES
279 void (*notifySingleFromCache)(dyld_image_states, const mach_header* mh, const char* path);
280 dyld_image_state_change_handler (*getPreInitNotifyHandler)(unsigned index);
281 dyld_image_state_change_handler (*getBoundBatchHandler)(unsigned index);
282 #endif
283
284 #if SUPPORT_OLD_CRT_INITIALIZATION
285 void (*setRunInitialzersOldWay)();
286 #endif
287 BindingOptions bindingOptions;
288 int argc;
289 const char** argv;
290 const char** envp;
291 const char** apple;
292 const char* progname;
293 ProgramVars programVars;
294 ImageLoader* mainExecutable;
295 const char* const * imageSuffix;
296 #if SUPPORT_ROOT_PATH
297 const char** rootPaths;
298 #endif
299 const DyldSharedCache* dyldCache;
300 const dyld_interpose_tuple* dynamicInterposeArray;
301 size_t dynamicInterposeCount;
302 PrebindMode prebindUsage;
303 SharedRegionMode sharedRegionMode;
304 mutable dyld3::Map<const char*, std::pair<const ImageLoader*, uintptr_t>, HashCString, EqualCString> weakDefMap;
305 mutable bool weakDefMapInitialized = false;
306 mutable bool weakDefMapProcessedLaunchDefs = false;
307 mutable bool useNewWeakBind = false;
308 bool dyldLoadedAtSameAddressNeededBySharedCache;
309 bool strictMachORequired;
310 bool allowAtPaths;
311 bool allowEnvVarsPrint;
312 bool allowEnvVarsPath;
313 bool allowEnvVarsSharedCache;
314 bool allowClassicFallbackPaths;
315 bool allowInsertFailures;
316 bool allowInterposing;
317 bool mainExecutableCodeSigned;
318 bool prebinding;
319 bool bindFlat;
320 bool linkingMainExecutable;
321 bool startedInitializingMainExecutable;
322 #if TARGET_OS_OSX
323 bool iOSonMac;
324 // dyld doesn't build for driverKit, so we use the macOS define to control whether driverKit is supported
325 bool driverKit;
326 #endif
327 bool verboseOpts;
328 bool verboseEnv;
329 bool verboseLoading;
330 bool verboseMapping;
331 bool verboseRebase;
332 bool verboseBind;
333 bool verboseWeakBind;
334 bool verboseInit;
335 bool verboseDOF;
336 bool verbosePrebinding;
337 bool verboseCoreSymbolication;
338 bool verboseWarnings;
339 bool verboseRPaths;
340 bool verboseInterposing;
341 bool verboseCodeSignatures;
342 };
343
344 struct CoalIterator
345 {
346 ImageLoader* image;
347 const char* symbolName;
348 unsigned int loadOrder;
349 bool weakSymbol;
350 bool symbolMatches;
351 bool done;
352 // the following are private to the ImageLoader subclass
353 uintptr_t curIndex;
354 uintptr_t endIndex;
355 uintptr_t address;
356 uintptr_t type;
357 uintptr_t addend;
358 uintptr_t imageIndex;
359 };
360
361 virtual void initializeCoalIterator(CoalIterator&, unsigned int loadOrder, unsigned imageIndex) = 0;
362 virtual bool incrementCoalIterator(CoalIterator&) = 0;
363 virtual uintptr_t getAddressCoalIterator(CoalIterator&, const LinkContext& context) = 0;
364 virtual void updateUsesCoalIterator(CoalIterator&, uintptr_t newAddr, ImageLoader* target, unsigned targetIndex, const LinkContext& context) = 0;
365
366 struct UninitedUpwards
367 {
368 uintptr_t count;
369 std::pair<ImageLoader*, const char*> imagesAndPaths[1];
370 };
371
372
373 // constructor is protected, but anyone can delete an image
374 virtual ~ImageLoader();
375
376 // link() takes a newly instantiated ImageLoader and does all
377 // fixups needed to make it usable by the process
378 void link(const LinkContext& context, bool forceLazysBound, bool preflight, bool neverUnload, const RPathChain& loaderRPaths, const char* imagePath);
379
380 // runInitializers() is normally called in link() but the main executable must
381 // run crt code before initializers
382 void runInitializers(const LinkContext& context, InitializerTimingList& timingInfo);
383
384 // called after link() forces all lazy pointers to be bound
385 void bindAllLazyPointers(const LinkContext& context, bool recursive);
386
387 // used by dyld to see if a requested library is already loaded (might be symlink)
388 bool statMatch(const struct stat& stat_buf) const;
389
390 // get short name of this image
391 const char* getShortName() const;
392
393 // returns leaf name
394 static const char* shortName(const char* fullName);
395
396 // get path used to load this image, not necessarily the "real" path
397 const char* getPath() const { return fPath; }
398
399 uint32_t getPathHash() const { return fPathHash; }
400
401 // get the "real" path for this image (e.g. no @rpath)
402 const char* getRealPath() const;
403
404 // get path this image is intended to be placed on disk or NULL if no preferred install location
405 virtual const char* getInstallPath() const = 0;
406
407 // image was loaded with NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME and all clients are looking for install path
408 bool matchInstallPath() const;
409 void setMatchInstallPath(bool);
410
411 // mark that this image's exported symbols should be ignored when linking other images (e.g. RTLD_LOCAL)
412 void setHideExports(bool hide = true);
413
414 // check if this image's exported symbols should be ignored when linking other images
415 bool hasHiddenExports() const;
416
417 // checks if this image is already linked into the process
418 bool isLinked() const;
419
420 // even if image is deleted, leave segments mapped in
421 void setLeaveMapped();
422
423 // even if image is deleted, leave segments mapped in
424 bool leaveMapped() { return fLeaveMapped; }
425
426 // image resides in dyld shared cache
427 virtual bool inSharedCache() const { return false; };
428
429 // checks if the specifed address is within one of this image's segments
430 virtual bool containsAddress(const void* addr) const;
431
432 // checks if the specifed symbol is within this image's symbol table
433 virtual bool containsSymbol(const void* addr) const = 0;
434
435 // checks if the specifed address range overlaps any of this image's segments
436 virtual bool overlapsWithAddressRange(const void* start, const void* end) const;
437
438 // adds to list of ranges of memory mapped in
439 void getMappedRegions(MappedRegion*& region) const;
440
441 // st_mtime from stat() on file
442 time_t lastModified() const;
443
444 // only valid for main executables, returns a pointer its entry point from LC_MAIN
445 virtual void* getEntryFromLC_MAIN() const = 0;
446
447 // only valid for main executables, returns a pointer its main from LC_UNIXTHREAD
448 virtual void* getEntryFromLC_UNIXTHREAD() const = 0;
449
450 // dyld API's require each image to have an associated mach_header
451 virtual const struct mach_header* machHeader() const = 0;
452
453 // dyld API's require each image to have a slide (actual load address minus preferred load address)
454 virtual uintptr_t getSlide() const = 0;
455
456 // last address mapped by image
457 virtual const void* getEnd() const = 0;
458
459 // image has exports that participate in runtime coalescing
460 virtual bool hasCoalescedExports() const = 0;
461
462 // search symbol table of definitions in this image for requested name
463 virtual bool findExportedSymbolAddress(const LinkContext& context, const char* symbolName,
464 const ImageLoader* requestorImage, int requestorOrdinalOfDef,
465 bool runResolver, const ImageLoader** foundIn, uintptr_t* address) const;
466
467 // search symbol table of definitions in this image for requested name
468 virtual const Symbol* findExportedSymbol(const char* name, bool searchReExports, const char* thisPath, const ImageLoader** foundIn) const = 0;
469
470 // search symbol table of definitions in this image for requested name
471 virtual const Symbol* findExportedSymbol(const char* name, bool searchReExports, const ImageLoader** foundIn) const {
472 return findExportedSymbol(name, searchReExports, this->getPath(), foundIn);
473 }
474
475 // gets address of implementation (code) of the specified exported symbol
476 virtual uintptr_t getExportedSymbolAddress(const Symbol* sym, const LinkContext& context,
477 const ImageLoader* requestor=NULL, bool runResolver=false, const char* symbolName=NULL) const = 0;
478
479 // gets attributes of the specified exported symbol
480 virtual DefinitionFlags getExportedSymbolInfo(const Symbol* sym) const = 0;
481
482 // gets name of the specified exported symbol
483 virtual const char* getExportedSymbolName(const Symbol* sym) const = 0;
484
485 // gets how many symbols are exported by this image
486 virtual uint32_t getExportedSymbolCount() const = 0;
487
488 // gets the i'th exported symbol
489 virtual const Symbol* getIndexedExportedSymbol(uint32_t index) const = 0;
490
491 // find exported symbol as if imported by this image
492 // used by RTLD_NEXT
493 virtual const Symbol* findExportedSymbolInDependentImages(const char* name, const LinkContext& context, const ImageLoader** foundIn) const;
494
495 // find exported symbol as if imported by this image
496 // used by RTLD_SELF
497 virtual const Symbol* findExportedSymbolInImageOrDependentImages(const char* name, const LinkContext& context, const ImageLoader** foundIn) const;
498
499 // gets how many symbols are imported by this image
500 virtual uint32_t getImportedSymbolCount() const = 0;
501
502 // gets the i'th imported symbol
503 virtual const Symbol* getIndexedImportedSymbol(uint32_t index) const = 0;
504
505 // gets attributes of the specified imported symbol
506 virtual ReferenceFlags getImportedSymbolInfo(const Symbol* sym) const = 0;
507
508 // gets name of the specified imported symbol
509 virtual const char* getImportedSymbolName(const Symbol* sym) const = 0;
510
511 // find the closest symbol before addr
512 virtual const char* findClosestSymbol(const void* addr, const void** closestAddr) const = 0;
513
514 // for use with accelerator tables
515 virtual const char* getIndexedPath(unsigned) const { return getPath(); }
516 virtual const char* getIndexedShortName(unsigned) const { return getShortName(); }
517
518 // checks if this image is a bundle and can be loaded but not linked
519 virtual bool isBundle() const = 0;
520
521 // checks if this image is a dylib
522 virtual bool isDylib() const = 0;
523
524 // checks if this image is a main executable
525 virtual bool isExecutable() const = 0;
526
527 // checks if this image is a main executable
528 virtual bool isPositionIndependentExecutable() const = 0;
529
530 // only for main executable
531 virtual bool forceFlat() const = 0;
532
533 // called at runtime when a lazily bound function is first called
534 virtual uintptr_t doBindLazySymbol(uintptr_t* lazyPointer, const LinkContext& context) = 0;
535
536 // called at runtime when a fast lazily bound function is first called
537 virtual uintptr_t doBindFastLazySymbol(uint32_t lazyBindingInfoOffset, const LinkContext& context,
538 void (*lock)(), void (*unlock)()) = 0;
539
540 // calls termination routines (e.g. C++ static destructors for image)
541 virtual void doTermination(const LinkContext& context) = 0;
542
543 // return if this image has initialization routines
544 virtual bool needsInitialization() = 0;
545
546 // return if this image has specified section and set start and length
547 virtual bool getSectionContent(const char* segmentName, const char* sectionName, void** start, size_t* length) = 0;
548
549 // fills in info about __eh_frame and __unwind_info sections
550 virtual void getUnwindInfo(dyld_unwind_sections* info) = 0;
551
552 // given a pointer into an image, find which segment and section it is in
553 virtual const struct macho_section* findSection(const void* imageInterior) const = 0;
554
555 // given a pointer into an image, find which segment and section it is in
556 virtual bool findSection(const void* imageInterior, const char** segmentName, const char** sectionName, size_t* sectionOffset) = 0;
557
558 // the image supports being prebound
559 virtual bool isPrebindable() const = 0;
560
561 // the image is prebindable and its prebinding is valid
562 virtual bool usablePrebinding(const LinkContext& context) const = 0;
563
564 // add all RPATH paths this image contains
565 virtual void getRPaths(const LinkContext& context, std::vector<const char*>&) const = 0;
566
567 // image has or uses weak definitions that need runtime coalescing
568 virtual bool participatesInCoalescing() const = 0;
569
570 // if image has a UUID, copy into parameter and return true
571 virtual bool getUUID(uuid_t) const = 0;
572
573 // dynamic interpose values onto this image
574 virtual void dynamicInterpose(const LinkContext& context) = 0;
575
576 // record interposing for any late binding
577 void addDynamicInterposingTuples(const struct dyld_interpose_tuple array[], size_t count);
578
579 virtual const char* libPath(unsigned int) const = 0;
580
581 // Image has objc sections, so information objc about when it comes and goes
582 virtual bool notifyObjC() const { return false; }
583
584 virtual bool overridesCachedDylib(uint32_t& num) const { return false; }
585 virtual void setOverridesCachedDylib(uint32_t num) { }
586
587
588 //
589 // A segment is a chunk of an executable file that is mapped into memory.
590 //
591 virtual unsigned int segmentCount() const = 0;
592 virtual const char* segName(unsigned int) const = 0;
593 virtual uintptr_t segSize(unsigned int) const = 0;
594 virtual uintptr_t segFileSize(unsigned int) const = 0;
595 virtual bool segHasTrailingZeroFill(unsigned int) = 0;
596 virtual uintptr_t segFileOffset(unsigned int) const = 0;
597 virtual bool segReadable(unsigned int) const = 0;
598 virtual bool segWriteable(unsigned int) const = 0;
599 virtual bool segExecutable(unsigned int) const = 0;
600 virtual bool segUnaccessible(unsigned int) const = 0;
601 virtual bool segHasPreferredLoadAddress(unsigned int) const = 0;
602 virtual uintptr_t segPreferredLoadAddress(unsigned int) const = 0;
603 virtual uintptr_t segActualLoadAddress(unsigned int) const = 0;
604 virtual uintptr_t segActualEndAddress(unsigned int) const = 0;
605
606
607 // info from LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS
608 virtual uint32_t sdkVersion() const = 0;
609 virtual uint32_t minOSVersion() const = 0;
610
611 // if the image contains interposing functions, register them
612 virtual void registerInterposing(const LinkContext& context) = 0;
613
614 virtual bool usesChainedFixups() const { return false; }
615
616 virtual void makeDataReadOnly() const {}
617
618 // when resolving symbols look in subImage if symbol can't be found
619 void reExport(ImageLoader* subImage);
620
621 virtual void recursiveBind(const LinkContext& context, bool forceLazysBound, bool neverUnload, const ImageLoader* parent);
622 void recursiveBindWithAccounting(const LinkContext& context, bool forceLazysBound, bool neverUnload);
623 void recursiveRebaseWithAccounting(const LinkContext& context);
624 void weakBind(const LinkContext& context);
625
626 void applyInterposing(const LinkContext& context);
627
628 dyld_image_states getState() { return (dyld_image_states)fState; }
629
630 ino_t getInode() const { return fInode; }
631 dev_t getDevice() const { return fDevice; }
632
633 // used to sort images bottom-up
634 int compare(const ImageLoader* right) const;
635
636 void incrementDlopenReferenceCount() { ++fDlopenReferenceCount; }
637
638 bool decrementDlopenReferenceCount();
639
640 void printReferenceCounts();
641
642 uint32_t dlopenCount() const { return fDlopenReferenceCount; }
643
644 void setCanUnload() { fNeverUnload = false; fLeaveMapped = false; }
645
646 bool neverUnload() const { return fNeverUnload; }
647
648 void setNeverUnload() { fNeverUnload = true; fLeaveMapped = true; }
649 void setNeverUnloadRecursive();
650
651 void forEachReExportDependent( void (^callback)(const ImageLoader*, bool& stop)) const;
652
653 bool isReferencedDownward() { return fIsReferencedDownward; }
654
655 virtual void recursiveMakeDataReadOnly(const LinkContext& context);
656
657 virtual uintptr_t resolveWeak(const LinkContext& context, const char* symbolName, bool weak_import, bool runResolver,
658 const ImageLoader** foundIn) { return 0; }
659
660 // triggered by DYLD_PRINT_STATISTICS to write info on work done and how fast
661 static void printStatistics(unsigned int imageCount, const InitializerTimingList& timingInfo);
662 static void printStatisticsDetails(unsigned int imageCount, const InitializerTimingList& timingInfo);
663
664 // used with DYLD_IMAGE_SUFFIX
665 static void addSuffix(const char* path, const char* suffix, char* result);
666
667 static uint32_t hash(const char*);
668
669 static const uint8_t* trieWalk(const uint8_t* start, const uint8_t* end, const char* stringToFind);
670
671 // used instead of directly deleting image
672 static void deleteImage(ImageLoader*);
673
674 static bool haveInterposingTuples() { return !fgInterposingTuples.empty(); }
675 static void clearInterposingTuples() { fgInterposingTuples.clear(); }
676
677 static void applyInterposingToDyldCache(const LinkContext& context);
678
679 bool dependsOn(ImageLoader* image);
680
681 void setPath(const char* path);
682 void setPaths(const char* path, const char* realPath);
683 void setPathUnowned(const char* path);
684
685 void clearDepth() { fDepth = 0; }
686 int getDepth() { return fDepth; }
687
688 void setBeingRemoved() { fBeingRemoved = true; }
689 bool isBeingRemoved() const { return fBeingRemoved; }
690
691 void markNotUsed() { fMarkedInUse = false; }
692 void markedUsedRecursive(const std::vector<DynamicReference>&);
693 bool isMarkedInUse() const { return fMarkedInUse; }
694
695 void setAddFuncNotified() { fAddFuncNotified = true; }
696 bool addFuncNotified() const { return fAddFuncNotified; }
697
698 void setObjCMappedNotified() { fObjCMappedNotified = true; }
699 bool objCMappedNotified() const { return fObjCMappedNotified; }
700
701 struct InterposeTuple {
702 uintptr_t replacement;
703 ImageLoader* neverImage; // don't apply replacement to this image
704 ImageLoader* onlyImage; // only apply replacement to this image
705 uintptr_t replacee;
706 };
707
708 static uintptr_t read_uleb128(const uint8_t*& p, const uint8_t* end);
709 static intptr_t read_sleb128(const uint8_t*& p, const uint8_t* end);
710
711 void vmAccountingSetSuspended(const LinkContext& context, bool suspend);
712
713 protected:
714 // abstract base class so all constructors protected
715 ImageLoader(const char* path, unsigned int libCount);
716 ImageLoader(const ImageLoader&);
717 void operator=(const ImageLoader&);
718 void operator delete(void* image) throw() { ::free(image); }
719
720
721 struct LibraryInfo {
722 uint32_t checksum;
723 uint32_t minVersion;
724 uint32_t maxVersion;
725 };
726
727 struct DependentLibrary {
728 ImageLoader* image;
729 uint32_t required : 1,
730 checksumMatches : 1,
731 isReExported : 1,
732 isSubFramework : 1;
733 };
734
735 struct DependentLibraryInfo {
736 const char* name;
737 LibraryInfo info;
738 bool required;
739 bool reExported;
740 bool upward;
741 };
742
743
744 typedef void (*Initializer)(int argc, const char* argv[], const char* envp[], const char* apple[], const ProgramVars* vars);
745 typedef void (*Terminator)(void);
746
747
748
749 unsigned int libraryCount() const { return fLibraryCount; }
750 virtual ImageLoader* libImage(unsigned int) const = 0;
751 virtual bool libReExported(unsigned int) const = 0;
752 virtual bool libIsUpward(unsigned int) const = 0;
753 virtual void setLibImage(unsigned int, ImageLoader*, bool, bool) = 0;
754
755 // To link() an image, its dependent libraries are loaded, it is rebased, bound, and initialized.
756 // These methods do the above, exactly once, and it the right order
757 virtual void recursiveLoadLibraries(const LinkContext& context, bool preflightOnly, const RPathChain& loaderRPaths, const char* loadPath);
758 virtual unsigned recursiveUpdateDepth(unsigned int maxDepth, dyld3::Array<ImageLoader*>& danglingUpwards);
759 virtual unsigned updateDepth(unsigned int maxDepth);
760 virtual void recursiveRebase(const LinkContext& context);
761 virtual void recursiveApplyInterposing(const LinkContext& context);
762 virtual void recursiveGetDOFSections(const LinkContext& context, std::vector<DOFInfo>& dofs);
763 virtual void recursiveInitialization(const LinkContext& context, mach_port_t this_thread, const char* pathToInitialize,
764 ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&);
765
766 // fill in information about dependent libraries (array length is fLibraryCount)
767 virtual void doGetDependentLibraries(DependentLibraryInfo libs[]) = 0;
768
769 // called on images that are libraries, returns info about itself
770 virtual LibraryInfo doGetLibraryInfo(const LibraryInfo& requestorInfo) = 0;
771
772 // do any fix ups in this image that depend only on the load address of the image
773 virtual void doRebase(const LinkContext& context) = 0;
774
775 // do any symbolic fix ups in this image
776 virtual void doBind(const LinkContext& context, bool forceLazysBound, const ImageLoader* reExportParent) = 0;
777
778 // called later via API to force all lazy pointer to be bound
779 virtual void doBindJustLazies(const LinkContext& context) = 0;
780
781 // if image has any dtrace DOF sections, append them to list to be registered
782 virtual void doGetDOFSections(const LinkContext& context, std::vector<DOFInfo>& dofs) = 0;
783
784 // do interpose
785 virtual void doInterpose(const LinkContext& context) = 0;
786
787 // run any initialization routines in this image
788 virtual bool doInitialization(const LinkContext& context) = 0;
789
790 // return if this image has termination routines
791 virtual bool needsTermination() = 0;
792
793 // support for runtimes in which segments don't have to maintain their relative positions
794 virtual bool segmentsMustSlideTogether() const = 0;
795
796 // built with PIC code and can load at any address
797 virtual bool segmentsCanSlide() const = 0;
798
799 // set how much all segments slide
800 virtual void setSlide(intptr_t slide) = 0;
801
802 // returns if all dependent libraries checksum's were as expected and none slide
803 bool allDependentLibrariesAsWhenPreBound() const;
804
805 // in mach-o a child tells it parent to re-export, instead of the other way around...
806 virtual bool isSubframeworkOf(const LinkContext& context, const ImageLoader* image) const = 0;
807
808 // in mach-o a parent library knows name of sub libraries it re-exports..
809 virtual bool hasSubLibrary(const LinkContext& context, const ImageLoader* child) const = 0;
810
811 virtual bool weakSymbolsBound(unsigned index) const { return fWeakSymbolsBound; }
812 virtual void setWeakSymbolsBound(unsigned index) { fWeakSymbolsBound = true; }
813
814 // set fState to dyld_image_state_memory_mapped
815 void setMapped(const LinkContext& context);
816
817 void setFileInfo(dev_t device, ino_t inode, time_t modDate);
818
819 void setDepth(uint16_t depth) { fDepth = depth; }
820
821 static uintptr_t interposedAddress(const LinkContext& context, uintptr_t address, const ImageLoader* notInImage, const ImageLoader* onlyInImage=NULL);
822
823 static uintptr_t fgNextPIEDylibAddress;
824 static uint32_t fgImagesWithUsedPrebinding;
825 static uint32_t fgImagesUsedFromSharedCache;
826 static uint32_t fgImagesHasWeakDefinitions;
827 static uint32_t fgImagesRequiringCoalescing;
828 static uint32_t fgTotalRebaseFixups;
829 static uint32_t fgTotalBindFixups;
830 static uint32_t fgTotalBindSymbolsResolved;
831 static uint32_t fgTotalBindImageSearches;
832 static uint32_t fgTotalLazyBindFixups;
833 static uint32_t fgTotalPossibleLazyBindFixups;
834 static uint32_t fgTotalSegmentsMapped;
835 static uint32_t fgSymbolTrieSearchs;
836 static uint64_t fgTotalBytesMapped;
837 static uint64_t fgTotalLoadLibrariesTime;
838 public:
839 static uint64_t fgTotalObjCSetupTime;
840 static uint64_t fgTotalDebuggerPausedTime;
841 static uint64_t fgTotalRebindCacheTime;
842 static uint64_t fgTotalRebaseTime;
843 static uint64_t fgTotalBindTime;
844 static uint64_t fgTotalWeakBindTime;
845 static uint64_t fgTotalDOF;
846 static uint64_t fgTotalInitTime;
847
848 protected:
849 static std::vector<InterposeTuple> fgInterposingTuples;
850
851 #if __x86_64__
852 const char* fAotPath;
853 #endif
854 const char* fPath;
855 const char* fRealPath;
856 dev_t fDevice;
857 ino_t fInode;
858 time_t fLastModified;
859 uint32_t fPathHash;
860 uint32_t fDlopenReferenceCount; // count of how many dlopens have been done on this image
861
862 struct recursive_lock {
863 recursive_lock(mach_port_t t) : thread(t), count(0) {}
864 mach_port_t thread;
865 int count;
866 };
867 void recursiveSpinLock(recursive_lock&);
868 void recursiveSpinUnLock();
869
870 private:
871 const ImageLoader::Symbol* findExportedSymbolInDependentImagesExcept(const char* name, const ImageLoader** dsiStart,
872 const ImageLoader**& dsiCur, const ImageLoader** dsiEnd, const ImageLoader** foundIn) const;
873
874 void processInitializers(const LinkContext& context, mach_port_t this_thread,
875 InitializerTimingList& timingInfo, ImageLoader::UninitedUpwards& ups);
876
877 void weakBindOld(const LinkContext& context);
878
879
880 recursive_lock* fInitializerRecursiveLock;
881 union {
882 struct {
883 uint16_t fLoadOrder;
884 uint16_t fDepth : 15,
885 fObjCMappedNotified : 1;
886 uint32_t fState : 8,
887 fLibraryCount : 9,
888 fMadeReadOnly : 1,
889 fAllLibraryChecksumsAndLoadAddressesMatch : 1,
890 fLeaveMapped : 1, // when unloaded, leave image mapped in cause some other code may have pointers into it
891 fNeverUnload : 1, // image was statically loaded by main executable
892 fHideSymbols : 1, // ignore this image's exported symbols when linking other images
893 fMatchByInstallName : 1,// look at image's install-path not its load path
894 fInterposed : 1,
895 fRegisteredDOF : 1,
896 fAllLazyPointersBound : 1,
897 fMarkedInUse : 1,
898 fBeingRemoved : 1,
899 fAddFuncNotified : 1,
900 fPathOwnedByImage : 1,
901 fIsReferencedDownward : 1,
902 fWeakSymbolsBound : 1;
903 };
904 uint64_t sizeOfData;
905 };
906 static_assert(sizeof(sizeOfData) == 8, "Bad data size");
907
908 static uint16_t fgLoadOrdinal;
909
910 };
911
912
913 VECTOR_NEVER_DESTRUCTED_EXTERN(ImageLoader::InterposeTuple);
914
915
916 #endif
917
mirror of dyld