]> git.saurik.com Git - apple/dyld.git/blob - src/dyldAPIsInLibSystem.cpp
projects / apple / dyld.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
dyld-732.8.tar.gz
[apple/dyld.git] / src / dyldAPIsInLibSystem.cpp
1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
2 *
3 * Copyright (c) 2004-2012 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 #include <stddef.h>
26 #include <string.h>
27 #include <malloc/malloc.h>
28 #include <sys/mman.h>
29 #include <execinfo.h>
30
31 #include <System/sys/csr.h>
32 #include <crt_externs.h>
33 #include <Availability.h>
34 #if !TARGET_OS_DRIVERKIT
35 #include <vproc_priv.h>
36 #endif
37 #include <dirent.h>
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <fcntl.h>
41 #include <System/sys/codesign.h>
42
43 #include <mach-o/dyld_images.h>
44 #include <mach-o/dyld.h>
45 #include <mach-o/dyld_priv.h>
46
47 #include "dyld_cache_format.h"
48 #include "objc-shared-cache.h"
49
50 #include "ImageLoader.h"
51 #include "dyldLock.h"
52
53 #include "APIs.h"
54 #include "AllImages.h"
55 #include "StartGlue.h"
56 #include "Tracing.h"
57
58
59 // this was in dyld_priv.h but it is no longer exported
60 extern "C" {
61 const struct dyld_all_image_infos* _dyld_get_all_image_infos() __attribute__((visibility("hidden")));
62 }
63
64
65 extern "C" int __cxa_atexit(void (*func)(void *), void *arg, void *dso);
66 extern "C" void __cxa_finalize(const void *dso);
67 extern "C" void __cxa_finalize_ranges(const struct __cxa_range_t ranges[], int count);
68
69 //
70 // private interface between libSystem.dylib and dyld
71 //
72 extern "C" int _dyld_func_lookup(const char* dyld_func_name, void **address);
73
74 #if TARGET_OS_IOS && !TARGET_OS_SIMULATOR
75 namespace dyld3 {
76 extern int compatFuncLookup(const char* name, void** address) __API_AVAILABLE(ios(13.0));
77 }
78 extern "C" void setLookupFunc(void*);
79 #endif
80
81
82 extern bool gUseDyld3;
83
84 // deprecated APIs are still availble on Mac OS X, but not on iPhone OS
85 #if __IPHONE_OS_VERSION_MIN_REQUIRED || TARGET_OS_DRIVERKIT
86 #define DEPRECATED_APIS_SUPPORTED 0
87 #else
88 #define DEPRECATED_APIS_SUPPORTED 1
89 #endif
90
91 /*
92 * names_match() takes an install_name from an LC_LOAD_DYLIB command and a
93 * libraryName (which is -lx or -framework Foo argument passed to the static
94 * link editor for the same library) and determines if they match. This depends
95 * on conventional use of names including major versioning.
96 */
97 static
98 bool
99 names_match(
100 const char *install_name,
101 const char* libraryName)
102 {
103 const char *basename;
104 unsigned long n;
105
106 /*
107 * Conventional install names have these forms:
108 * /System/Library/Frameworks/AppKit.framework/Versions/A/Appkit
109 * /Local/Library/Frameworks/AppKit.framework/Appkit
110 * /lib/libsys_s.A.dylib
111 * /usr/lib/libsys_s.dylib
112 */
113 basename = strrchr(install_name, '/');
114 if(basename == NULL)
115 basename = install_name;
116 else
117 basename++;
118
119 /*
120 * By checking the base name matching the library name we take care
121 * of the -framework cases.
122 */
123 if(strcmp(basename, libraryName) == 0)
124 return true;
125
126 /*
127 * Now check the base name for "lib" if so proceed to check for the
128 * -lx case dealing with a possible .X.dylib and a .dylib extension.
129 */
130 if(strncmp(basename, "lib", 3) ==0){
131 n = strlen(libraryName);
132 if(strncmp(basename+3, libraryName, n) == 0){
133 if(strncmp(basename+3+n, ".dylib", 6) == 0)
134 return true;
135 if(basename[3+n] == '.' &&
136 basename[3+n+1] != '\0' &&
137 strncmp(basename+3+n+2, ".dylib", 6) == 0)
138 return true;
139 }
140 }
141 return false;
142 }
143
144 #if DEPRECATED_APIS_SUPPORTED
145
146 void NSInstallLinkEditErrorHandlers(
147 const NSLinkEditErrorHandlers* handlers)
148 {
149 if ( gUseDyld3 )
150 return dyld3::NSInstallLinkEditErrorHandlers(handlers);
151
152 DYLD_LOCK_THIS_BLOCK;
153 typedef void (*ucallback_t)(const char* symbol_name);
154 typedef NSModule (*mcallback_t)(NSSymbol s, NSModule old, NSModule newhandler);
155 typedef void (*lcallback_t)(NSLinkEditErrors c, int errorNumber,
156 const char* fileName, const char* errorString);
157 static void (*p)(ucallback_t undefined, mcallback_t multiple, lcallback_t linkEdit) = NULL;
158
159 if(p == NULL)
160 _dyld_func_lookup("__dyld_install_handlers", (void**)&p);
161 mcallback_t m = handlers->multiple;
162 p(handlers->undefined, m, handlers->linkEdit);
163 }
164
165 const char*
166 NSNameOfModule(
167 NSModule module)
168 {
169 if ( gUseDyld3 )
170 return dyld3::NSNameOfModule(module);
171
172 DYLD_LOCK_THIS_BLOCK;
173 static const char* (*p)(NSModule module) = NULL;
174
175 if(p == NULL)
176 _dyld_func_lookup("__dyld_NSNameOfModule", (void**)&p);
177 return(p(module));
178 }
179
180 const char*
181 NSLibraryNameForModule(
182 NSModule module)
183 {
184 if ( gUseDyld3 )
185 return dyld3::NSLibraryNameForModule(module);
186
187 DYLD_LOCK_THIS_BLOCK;
188 static const char* (*p)(NSModule module) = NULL;
189
190 if(p == NULL)
191 _dyld_func_lookup("__dyld_NSLibraryNameForModule", (void**)&p);
192 return(p(module));
193 }
194
195 bool
196 NSIsSymbolNameDefined(
197 const char* symbolName)
198 {
199 if ( gUseDyld3 )
200 return dyld3::NSIsSymbolNameDefined(symbolName);
201
202 DYLD_LOCK_THIS_BLOCK;
203 static bool (*p)(const char* symbolName) = NULL;
204
205 if(p == NULL)
206 _dyld_func_lookup("__dyld_NSIsSymbolNameDefined", (void**)&p);
207 return(p(symbolName));
208 }
209
210 bool
211 NSIsSymbolNameDefinedWithHint(
212 const char* symbolName,
213 const char* libraryNameHint)
214 {
215 if ( gUseDyld3 )
216 return dyld3::NSIsSymbolNameDefinedWithHint(symbolName, libraryNameHint);
217
218 DYLD_LOCK_THIS_BLOCK;
219 static bool (*p)(const char* symbolName,
220 const char* libraryNameHint) = NULL;
221
222 if(p == NULL)
223 _dyld_func_lookup("__dyld_NSIsSymbolNameDefinedWithHint", (void**)&p);
224 return(p(symbolName, libraryNameHint));
225 }
226
227 bool
228 NSIsSymbolNameDefinedInImage(
229 const struct mach_header *image,
230 const char* symbolName)
231 {
232 if ( gUseDyld3 )
233 return dyld3::NSIsSymbolNameDefinedInImage(image, symbolName);
234
235 DYLD_LOCK_THIS_BLOCK;
236 static bool (*p)(const struct mach_header *image,
237 const char* symbolName) = NULL;
238
239 if(p == NULL)
240 _dyld_func_lookup("__dyld_NSIsSymbolNameDefinedInImage", (void**)&p);
241 return(p(image, symbolName));
242 }
243
244 NSSymbol
245 NSLookupAndBindSymbol(
246 const char* symbolName)
247 {
248 if ( gUseDyld3 )
249 return dyld3::NSLookupAndBindSymbol(symbolName);
250
251 DYLD_LOCK_THIS_BLOCK;
252 static NSSymbol (*p)(const char* symbolName) = NULL;
253
254 if(p == NULL)
255 _dyld_func_lookup("__dyld_NSLookupAndBindSymbol", (void**)&p);
256 return(p(symbolName));
257 }
258
259 NSSymbol
260 NSLookupAndBindSymbolWithHint(
261 const char* symbolName,
262 const char* libraryNameHint)
263 {
264 if ( gUseDyld3 )
265 return dyld3::NSLookupAndBindSymbolWithHint(symbolName, libraryNameHint);
266
267 DYLD_LOCK_THIS_BLOCK;
268 static NSSymbol (*p)(const char* symbolName,
269 const char* libraryNameHint) = NULL;
270
271 if(p == NULL)
272 _dyld_func_lookup("__dyld_NSLookupAndBindSymbolWithHint", (void**)&p);
273 return(p(symbolName, libraryNameHint));
274 }
275
276 NSSymbol
277 NSLookupSymbolInModule(
278 NSModule module,
279 const char* symbolName)
280 {
281 if ( gUseDyld3 )
282 return dyld3::NSLookupSymbolInModule(module, symbolName);
283
284 DYLD_LOCK_THIS_BLOCK;
285 static NSSymbol (*p)(NSModule module, const char* symbolName) = NULL;
286
287 if(p == NULL)
288 _dyld_func_lookup("__dyld_NSLookupSymbolInModule", (void**)&p);
289 return(p(module, symbolName));
290 }
291
292 NSSymbol
293 NSLookupSymbolInImage(
294 const struct mach_header *image,
295 const char* symbolName,
296 uint32_t options)
297 {
298 if ( gUseDyld3 )
299 return dyld3::NSLookupSymbolInImage(image, symbolName, options);
300
301 DYLD_LOCK_THIS_BLOCK;
302 static NSSymbol (*p)(const struct mach_header *image,
303 const char* symbolName,
304 uint32_t options) = NULL;
305
306 if(p == NULL)
307 _dyld_func_lookup("__dyld_NSLookupSymbolInImage", (void**)&p);
308 return(p(image, symbolName, options));
309 }
310
311 const char*
312 NSNameOfSymbol(
313 NSSymbol symbol)
314 {
315 if ( gUseDyld3 )
316 return dyld3::NSNameOfSymbol(symbol);
317
318 DYLD_LOCK_THIS_BLOCK;
319 static char * (*p)(NSSymbol symbol) = NULL;
320
321 if(p == NULL)
322 _dyld_func_lookup("__dyld_NSNameOfSymbol",(void**)&p);
323 return(p(symbol));
324 }
325
326 void *
327 NSAddressOfSymbol(
328 NSSymbol symbol)
329 {
330 if ( gUseDyld3 )
331 return dyld3::NSAddressOfSymbol(symbol);
332
333 DYLD_LOCK_THIS_BLOCK;
334 static void * (*p)(NSSymbol symbol) = NULL;
335
336 if(p == NULL)
337 _dyld_func_lookup("__dyld_NSAddressOfSymbol", (void**)&p);
338 return(p(symbol));
339 }
340
341 NSModule
342 NSModuleForSymbol(
343 NSSymbol symbol)
344 {
345 if ( gUseDyld3 )
346 return dyld3::NSModuleForSymbol(symbol);
347
348 DYLD_LOCK_THIS_BLOCK;
349 static NSModule (*p)(NSSymbol symbol) = NULL;
350
351 if(p == NULL)
352 _dyld_func_lookup("__dyld_NSModuleForSymbol", (void**)&p);
353 return(p(symbol));
354 }
355
356 bool
357 NSAddLibrary(
358 const char* pathName)
359 {
360 if ( gUseDyld3 )
361 return dyld3::NSAddLibrary(pathName);
362
363 DYLD_LOCK_THIS_BLOCK;
364 static bool (*p)(const char* pathName) = NULL;
365
366 if(p == NULL)
367 _dyld_func_lookup("__dyld_NSAddLibrary", (void**)&p);
368 return(p(pathName));
369 }
370
371 bool
372 NSAddLibraryWithSearching(
373 const char* pathName)
374 {
375 if ( gUseDyld3 )
376 return dyld3::NSAddLibrary(pathName);
377
378 DYLD_LOCK_THIS_BLOCK;
379 static bool (*p)(const char* pathName) = NULL;
380
381 if(p == NULL)
382 _dyld_func_lookup("__dyld_NSAddLibraryWithSearching", (void**)&p);
383 return(p(pathName));
384 }
385
386 const struct mach_header *
387 NSAddImage(
388 const char* image_name,
389 uint32_t options)
390 {
391 if ( gUseDyld3 )
392 return dyld3::NSAddImage(image_name, options);
393
394 DYLD_LOCK_THIS_BLOCK;
395 static const struct mach_header * (*p)(const char* image_name,
396 uint32_t options) = NULL;
397
398 if(p == NULL)
399 _dyld_func_lookup("__dyld_NSAddImage", (void**)&p);
400 return(p(image_name, options));
401 }
402 #endif // DEPRECATED_APIS_SUPPORTED
403
404 /*
405 * This routine returns the current version of the named shared library the
406 * executable it was built with. The libraryName parameter is the same as the
407 * -lx or -framework Foo argument passed to the static link editor when building
408 * the executable (with -lx it would be "x" and with -framework Foo it would be
409 * "Foo"). If this the executable was not built against the specified library
410 * it returns -1. It should be noted that if this only returns the value the
411 * current version of the named shared library the executable was built with
412 * and not a list of current versions that dependent libraries and bundles the
413 * program is using were built with.
414 */
415 int32_t NSVersionOfLinkTimeLibrary(const char* libraryName)
416 {
417 if ( gUseDyld3 )
418 return dyld3::NSVersionOfLinkTimeLibrary(libraryName);
419
420 // Lazily call _NSGetMachExecuteHeader() and cache result
421 #if __LP64__
422 static mach_header_64* mh = NULL;
423 #else
424 static mach_header* mh = NULL;
425 #endif
426 if ( mh == NULL )
427 mh = _NSGetMachExecuteHeader();
428 #if __LP64__
429 const load_command* lc = (load_command*)((char*)mh + sizeof(mach_header_64));
430 #else
431 const load_command* lc = (load_command*)((char*)mh + sizeof(mach_header));
432 #endif
433 for(uint32_t i = 0; i < mh->ncmds; i++){
434 switch ( lc->cmd ) {
435 case LC_LOAD_DYLIB:
436 case LC_LOAD_WEAK_DYLIB:
437 case LC_LOAD_UPWARD_DYLIB:
438 const dylib_command* dl = (dylib_command *)lc;
439 const char* install_name = (char*)dl + dl->dylib.name.offset;
440 if ( names_match(install_name, libraryName) )
441 return dl->dylib.current_version;
442 break;
443 }
444 lc = (load_command*)((char*)lc + lc->cmdsize);
445 }
446 return (-1);
447 }
448
449 /*
450 * This routine returns the current version of the named shared library the
451 * program it is running against. The libraryName parameter is the same as
452 * would be static link editor using the -lx or -framework Foo flags (with -lx
453 * it would be "x" and with -framework Foo it would be "Foo"). If the program
454 * is not using the specified library it returns -1.
455 */
456 int32_t NSVersionOfRunTimeLibrary(const char* libraryName)
457 {
458 if ( gUseDyld3 )
459 return dyld3::NSVersionOfRunTimeLibrary(libraryName);
460
461 uint32_t n = _dyld_image_count();
462 for(uint32_t i = 0; i < n; i++){
463 const mach_header* mh = _dyld_get_image_header(i);
464 if ( mh == NULL )
465 continue;
466 if ( mh->filetype != MH_DYLIB )
467 continue;
468 #if __LP64__
469 const load_command* lc = (load_command*)((char*)mh + sizeof(mach_header_64));
470 #else
471 const load_command* lc = (load_command*)((char*)mh + sizeof(mach_header));
472 #endif
473 for(uint32_t j = 0; j < mh->ncmds; j++){
474 if ( lc->cmd == LC_ID_DYLIB ) {
475 const dylib_command* dl = (dylib_command*)lc;
476 const char* install_name = (char *)dl + dl->dylib.name.offset;
477 if ( names_match(install_name, libraryName) )
478 return dl->dylib.current_version;
479 }
480 lc = (load_command*)((char*)lc + lc->cmdsize);
481 }
482 }
483 return (-1);
484 }
485
486 #if TARGET_OS_WATCH
487 uint32_t dyld_get_program_sdk_watch_os_version()
488 {
489 if (gUseDyld3)
490 return dyld3::dyld_get_program_sdk_watch_os_version();
491
492 __block uint32_t retval = 0;
493 __block bool versionFound = false;
494 dyld3::dyld_get_image_versions((mach_header*)_NSGetMachExecuteHeader(), ^(dyld_platform_t platform, uint32_t sdk_version, uint32_t min_version) {
495 if (versionFound) return;
496
497 if (dyld_get_base_platform(platform) == PLATFORM_WATCHOS) {
498 versionFound = true;
499 retval = sdk_version;
500 }
501 });
502
503 return retval;
504 }
505
506 uint32_t dyld_get_program_min_watch_os_version()
507 {
508 if (gUseDyld3)
509 return dyld3::dyld_get_program_min_watch_os_version();
510
511 __block uint32_t retval = 0;
512 __block bool versionFound = false;
513 dyld3::dyld_get_image_versions((mach_header*)_NSGetMachExecuteHeader(), ^(dyld_platform_t platform, uint32_t sdk_version, uint32_t min_version) {
514 if (versionFound) return;
515
516 if (dyld_get_base_platform(platform) == PLATFORM_WATCHOS) {
517 versionFound = true;
518 retval = min_version;
519 }
520 });
521
522 return retval;
523 }
524 #endif
525
526 #if TARGET_OS_BRIDGE
527 uint32_t dyld_get_program_sdk_bridge_os_version()
528 {
529 if (gUseDyld3)
530 return dyld3::dyld_get_program_sdk_bridge_os_version();
531
532 __block uint32_t retval = 0;
533 __block bool versionFound = false;
534 dyld3::dyld_get_image_versions((mach_header*)_NSGetMachExecuteHeader(), ^(dyld_platform_t platform, uint32_t sdk_version, uint32_t min_version) {
535 if (versionFound) return;
536
537 if (dyld_get_base_platform(platform) == PLATFORM_BRIDGEOS) {
538 versionFound = true;
539 retval = sdk_version;
540 }
541 });
542
543 return retval;
544 }
545
546 uint32_t dyld_get_program_min_bridge_os_version()
547 {
548 if (gUseDyld3)
549 return dyld3::dyld_get_program_min_bridge_os_version();
550
551 __block uint32_t retval = 0;
552 __block bool versionFound = false;
553 dyld3::dyld_get_image_versions((mach_header*)_NSGetMachExecuteHeader(), ^(dyld_platform_t platform, uint32_t sdk_version, uint32_t min_version) {
554 if (versionFound) return;
555
556 if (dyld_get_base_platform(platform) == PLATFORM_BRIDGEOS) {
557 versionFound = true;
558 retval = min_version;
559 }
560 });
561
562 return retval;
563 }
564 #endif
565
566 /*
567 * Returns the sdk version (encode as nibble XXXX.YY.ZZ) the
568 * specified binary was built against.
569 *
570 * First looks for LC_VERSION_MIN_* in binary and if sdk field is
571 * not zero, return that value.
572 * Otherwise, looks for the libSystem.B.dylib the binary linked
573 * against and uses a table to convert that to an sdk version.
574 */
575 uint32_t dyld_get_sdk_version(const mach_header* mh)
576 {
577 return dyld3::dyld_get_sdk_version(mh);
578 }
579
580 uint32_t dyld_get_program_sdk_version()
581 {
582 return dyld3::dyld_get_sdk_version((mach_header*)_NSGetMachExecuteHeader());
583 }
584
585 uint32_t dyld_get_min_os_version(const struct mach_header* mh)
586 {
587 return dyld3::dyld_get_min_os_version(mh);
588 }
589
590
591 uint32_t dyld_get_program_min_os_version()
592 {
593 return dyld3::dyld_get_min_os_version((mach_header*)_NSGetMachExecuteHeader());
594 }
595
596
597 bool _dyld_get_image_uuid(const struct mach_header* mh, uuid_t uuid)
598 {
599 if ( gUseDyld3 )
600 return dyld3::_dyld_get_image_uuid(mh, uuid);
601
602 const load_command* startCmds = NULL;
603 if ( mh->magic == MH_MAGIC_64 )
604 startCmds = (load_command*)((char *)mh + sizeof(mach_header_64));
605 else if ( mh->magic == MH_MAGIC )
606 startCmds = (load_command*)((char *)mh + sizeof(mach_header));
607 else
608 return false; // not a mach-o file, or wrong endianness
609
610 const load_command* const cmdsEnd = (load_command*)((char*)startCmds + mh->sizeofcmds);
611 const load_command* cmd = startCmds;
612 for(uint32_t i = 0; i < mh->ncmds; ++i) {
613 const load_command* nextCmd = (load_command*)((char *)cmd + cmd->cmdsize);
614 if ( (cmd->cmdsize < 8) || (nextCmd > cmdsEnd) || (nextCmd < startCmds)) {
615 return false;
616 }
617 if ( cmd->cmd == LC_UUID ) {
618 const uuid_command* uuidCmd = (uuid_command*)cmd;
619 memcpy(uuid, uuidCmd->uuid, 16);
620 return true;
621 }
622 cmd = nextCmd;
623 }
624 bzero(uuid, 16);
625 return false;
626 }
627
628 dyld_platform_t dyld_get_active_platform(void) {
629 if (gUseDyld3) { return dyld3::dyld_get_active_platform(); }
630 if (_dyld_get_all_image_infos()->version >= 16) { return (dyld_platform_t)_dyld_get_all_image_infos()->platform; }
631
632 __block dyld_platform_t result;
633 // FIXME: Remove this once we only care about version 16 or greater all image infos
634 dyld3::dyld_get_image_versions((mach_header*)_NSGetMachExecuteHeader(), ^(dyld_platform_t platform, uint32_t sdk_version, uint32_t min_version) {
635 result = platform;
636 });
637 return result;
638 }
639
640 dyld_platform_t dyld_get_base_platform(dyld_platform_t platform) {
641 return dyld3::dyld_get_base_platform(platform);
642 }
643
644 bool dyld_is_simulator_platform(dyld_platform_t platform) {
645 return dyld3::dyld_is_simulator_platform(platform);
646 }
647
648 bool dyld_sdk_at_least(const struct mach_header* mh, dyld_build_version_t version) {
649 return dyld3::dyld_sdk_at_least(mh, version);
650 }
651
652 bool dyld_minos_at_least(const struct mach_header* mh, dyld_build_version_t version) {
653 return dyld3::dyld_minos_at_least(mh, version);
654 }
655
656 bool dyld_program_sdk_at_least(dyld_build_version_t version) {
657 return dyld3::dyld_sdk_at_least((mach_header*)_NSGetMachExecuteHeader(),version);
658 }
659
660 bool dyld_program_minos_at_least(dyld_build_version_t version) {
661 return dyld3::dyld_minos_at_least((mach_header*)_NSGetMachExecuteHeader(), version);
662 }
663
664 // Function that walks through the load commands and calls the internal block for every version found
665 // Intended as a fallback for very complex (and rare) version checks, or for tools that need to
666 // print our everything for diagnostic reasons
667 void dyld_get_image_versions(const struct mach_header* mh, void (^callback)(dyld_platform_t platform, uint32_t sdk_version, uint32_t min_version)) {
668 dyld3::dyld_get_image_versions(mh, callback);
669 }
670
671
672
673 #if DEPRECATED_APIS_SUPPORTED
674 /*
675 * NSCreateObjectFileImageFromFile() creates an NSObjectFileImage for the
676 * specified file name if the file is a correct Mach-O file that can be loaded
677 * with NSloadModule(). For return codes of NSObjectFileImageFailure and
678 * NSObjectFileImageFormat an error message is printed to stderr. All
679 * other codes cause no printing.
680 */
681 NSObjectFileImageReturnCode
682 NSCreateObjectFileImageFromFile(
683 const char* pathName,
684 NSObjectFileImage *objectFileImage)
685 {
686 if ( gUseDyld3 )
687 return dyld3::NSCreateObjectFileImageFromFile(pathName, objectFileImage);
688
689 DYLD_LOCK_THIS_BLOCK;
690 static NSObjectFileImageReturnCode (*p)(const char*, NSObjectFileImage*) = NULL;
691
692 if(p == NULL)
693 _dyld_func_lookup("__dyld_NSCreateObjectFileImageFromFile", (void**)&p);
694 return p(pathName, objectFileImage);
695 }
696
697
698 /*
699 * NSCreateObjectFileImageFromMemory() creates an NSObjectFileImage for the
700 * object file mapped into memory at address of size length if the object file
701 * is a correct Mach-O file that can be loaded with NSloadModule(). For return
702 * codes of NSObjectFileImageFailure and NSObjectFileImageFormat an error
703 * message is printed to stderr. All other codes cause no printing.
704 */
705 NSObjectFileImageReturnCode
706 NSCreateObjectFileImageFromMemory(
707 const void* address,
708 size_t size,
709 NSObjectFileImage *objectFileImage)
710 {
711 // <rdar://problem/51812762> NSCreatObjectFileImageFromMemory fail opaquely if Hardened runtime is enabled
712 uint32_t flags;
713 if ( csops(0, CS_OPS_STATUS, &flags, sizeof(flags)) != -1 ) {
714 if ( (flags & (CS_ENFORCEMENT|CS_KILL)) == (CS_ENFORCEMENT|CS_KILL) ) {
715 //fprintf(stderr, "dyld: warning: NSCreatObjectFileImageFromMemory() cannot be used in harden process 0x%08X\n", flags);
716 return NSObjectFileImageAccess;
717 }
718 }
719
720 if ( gUseDyld3 )
721 return dyld3::NSCreateObjectFileImageFromMemory(address, size, objectFileImage);
722
723 DYLD_LOCK_THIS_BLOCK;
724 static NSObjectFileImageReturnCode (*p)(const void*, size_t, NSObjectFileImage*) = NULL;
725
726 if(p == NULL)
727 _dyld_func_lookup("__dyld_NSCreateObjectFileImageFromMemory", (void**)&p);
728 return p(address, size, objectFileImage);
729 }
730
731 #if OBSOLETE_DYLD_API
732 /*
733 * NSCreateCoreFileImageFromFile() creates an NSObjectFileImage for the
734 * specified core file name if the file is a correct Mach-O core file.
735 * For return codes of NSObjectFileImageFailure and NSObjectFileImageFormat
736 * an error message is printed to stderr. All other codes cause no printing.
737 */
738 NSObjectFileImageReturnCode
739 NSCreateCoreFileImageFromFile(
740 const char* pathName,
741 NSObjectFileImage *objectFileImage)
742 {
743 DYLD_LOCK_THIS_BLOCK;
744 static NSObjectFileImageReturnCode (*p)(const char*, NSObjectFileImage*) = NULL;
745
746 if(p == NULL)
747 _dyld_func_lookup("__dyld_NSCreateCoreFileImageFromFile", (void**)&p);
748 return p(pathName, objectFileImage);
749 }
750 #endif
751
752 bool
753 NSDestroyObjectFileImage(
754 NSObjectFileImage objectFileImage)
755 {
756 if ( gUseDyld3 )
757 return dyld3::NSDestroyObjectFileImage(objectFileImage);
758
759 DYLD_LOCK_THIS_BLOCK;
760 static bool (*p)(NSObjectFileImage) = NULL;
761
762 if(p == NULL)
763 _dyld_func_lookup("__dyld_NSDestroyObjectFileImage", (void**)&p);
764 return p(objectFileImage);
765 }
766
767
768 NSModule
769 NSLinkModule(
770 NSObjectFileImage objectFileImage,
771 const char* moduleName,
772 uint32_t options)
773 {
774 if ( gUseDyld3 )
775 return dyld3::NSLinkModule(objectFileImage, moduleName, options);
776
777 DYLD_LOCK_THIS_BLOCK;
778 static NSModule (*p)(NSObjectFileImage, const char*, unsigned long) = NULL;
779
780 if(p == NULL)
781 _dyld_func_lookup("__dyld_NSLinkModule", (void**)&p);
782
783 return p(objectFileImage, moduleName, options);
784 }
785
786
787
788
789 /*
790 * NSSymbolDefinitionCountInObjectFileImage() returns the number of symbol
791 * definitions in the NSObjectFileImage.
792 */
793 uint32_t
794 NSSymbolDefinitionCountInObjectFileImage(
795 NSObjectFileImage objectFileImage)
796 {
797 if ( gUseDyld3 )
798 return dyld3::NSSymbolDefinitionCountInObjectFileImage(objectFileImage);
799
800 DYLD_LOCK_THIS_BLOCK;
801 static uint32_t (*p)(NSObjectFileImage) = NULL;
802
803 if(p == NULL)
804 _dyld_func_lookup("__dyld_NSSymbolDefinitionCountInObjectFileImage", (void**)&p);
805
806 return p(objectFileImage);
807 }
808
809 /*
810 * NSSymbolDefinitionNameInObjectFileImage() returns the name of the i'th
811 * symbol definitions in the NSObjectFileImage. If the ordinal specified is
812 * outside the range [0..NSSymbolDefinitionCountInObjectFileImage], NULL will
813 * be returned.
814 */
815 const char*
816 NSSymbolDefinitionNameInObjectFileImage(
817 NSObjectFileImage objectFileImage,
818 uint32_t ordinal)
819 {
820 if ( gUseDyld3 )
821 return dyld3::NSSymbolDefinitionNameInObjectFileImage(objectFileImage, ordinal);
822
823 DYLD_LOCK_THIS_BLOCK;
824 static const char* (*p)(NSObjectFileImage, uint32_t) = NULL;
825
826 if(p == NULL)
827 _dyld_func_lookup("__dyld_NSSymbolDefinitionNameInObjectFileImage", (void**)&p);
828
829 return p(objectFileImage, ordinal);
830 }
831
832 /*
833 * NSSymbolReferenceCountInObjectFileImage() returns the number of references
834 * to undefined symbols the NSObjectFileImage.
835 */
836 uint32_t
837 NSSymbolReferenceCountInObjectFileImage(
838 NSObjectFileImage objectFileImage)
839 {
840 if ( gUseDyld3 )
841 return dyld3::NSSymbolReferenceCountInObjectFileImage(objectFileImage);
842
843 DYLD_LOCK_THIS_BLOCK;
844 static uint32_t (*p)(NSObjectFileImage) = NULL;
845
846 if(p == NULL)
847 _dyld_func_lookup("__dyld_NSSymbolReferenceCountInObjectFileImage", (void**)&p);
848
849 return p(objectFileImage);
850 }
851
852 /*
853 * NSSymbolReferenceNameInObjectFileImage() returns the name of the i'th
854 * undefined symbol in the NSObjectFileImage. If the ordinal specified is
855 * outside the range [0..NSSymbolReferenceCountInObjectFileImage], NULL will be
856 * returned.
857 */
858 const char*
859 NSSymbolReferenceNameInObjectFileImage(
860 NSObjectFileImage objectFileImage,
861 uint32_t ordinal,
862 bool *tentative_definition) /* can be NULL */
863 {
864 if ( gUseDyld3 )
865 return dyld3::NSSymbolReferenceNameInObjectFileImage(objectFileImage, ordinal, tentative_definition);
866
867 DYLD_LOCK_THIS_BLOCK;
868 static const char* (*p)(NSObjectFileImage, uint32_t, bool*) = NULL;
869
870 if(p == NULL)
871 _dyld_func_lookup("__dyld_NSSymbolReferenceNameInObjectFileImage", (void**)&p);
872
873 return p(objectFileImage, ordinal, tentative_definition);
874 }
875
876 /*
877 * NSIsSymbolDefinedInObjectFileImage() returns TRUE if the specified symbol
878 * name has a definition in the NSObjectFileImage and FALSE otherwise.
879 */
880 bool
881 NSIsSymbolDefinedInObjectFileImage(
882 NSObjectFileImage objectFileImage,
883 const char* symbolName)
884 {
885 if ( gUseDyld3 )
886 return dyld3::NSIsSymbolDefinedInObjectFileImage(objectFileImage, symbolName);
887
888 DYLD_LOCK_THIS_BLOCK;
889 static bool (*p)(NSObjectFileImage, const char*) = NULL;
890
891 if(p == NULL)
892 _dyld_func_lookup("__dyld_NSIsSymbolDefinedInObjectFileImage", (void**)&p);
893
894 return p(objectFileImage, symbolName);
895 }
896
897 /*
898 * NSGetSectionDataInObjectFileImage() returns a pointer to the section contents
899 * in the NSObjectFileImage for the specified segmentName and sectionName if
900 * it exists and it is not a zerofill section. If not it returns NULL. If
901 * the parameter size is not NULL the size of the section is also returned
902 * indirectly through that pointer.
903 */
904 void *
905 NSGetSectionDataInObjectFileImage(
906 NSObjectFileImage objectFileImage,
907 const char* segmentName,
908 const char* sectionName,
909 unsigned long *size) /* can be NULL */
910 {
911 if ( gUseDyld3 )
912 return dyld3::NSGetSectionDataInObjectFileImage(objectFileImage, segmentName, sectionName, size);
913
914 DYLD_LOCK_THIS_BLOCK;
915 static void* (*p)(NSObjectFileImage, const char*, const char*, unsigned long*) = NULL;
916
917 if(p == NULL)
918 _dyld_func_lookup("__dyld_NSGetSectionDataInObjectFileImage", (void**)&p);
919
920 return p(objectFileImage, segmentName, sectionName, size);
921 }
922
923
924 void
925 NSLinkEditError(
926 NSLinkEditErrors *c,
927 int *errorNumber,
928 const char* *fileName,
929 const char* *errorString)
930 {
931 if ( gUseDyld3 )
932 return dyld3::NSLinkEditError(c, errorNumber, fileName, errorString);
933
934 DYLD_LOCK_THIS_BLOCK;
935 static void (*p)(NSLinkEditErrors *c,
936 int *errorNumber,
937 const char* *fileName,
938 const char* *errorString) = NULL;
939
940 if(p == NULL)
941 _dyld_func_lookup("__dyld_link_edit_error", (void**)&p);
942 if(p != NULL)
943 p(c, errorNumber, fileName, errorString);
944 }
945
946 bool
947 NSUnLinkModule(
948 NSModule module,
949 uint32_t options)
950 {
951 if ( gUseDyld3 )
952 return dyld3::NSUnLinkModule(module, options);
953
954 DYLD_LOCK_THIS_BLOCK;
955 static bool (*p)(NSModule module, uint32_t options) = NULL;
956
957 if(p == NULL)
958 _dyld_func_lookup("__dyld_unlink_module", (void**)&p);
959
960 return p(module, options);
961 }
962
963 #if OBSOLETE_DYLD_API
964 NSModule
965 NSReplaceModule(
966 NSModule moduleToReplace,
967 NSObjectFileImage newObjectFileImage,
968 uint32_t options)
969 {
970 return(NULL);
971 }
972 #endif
973
974
975 #endif // DEPRECATED_APIS_SUPPORTED
976
977 /*
978 *_NSGetExecutablePath copies the path of the executable into the buffer and
979 * returns 0 if the path was successfully copied in the provided buffer. If the
980 * buffer is not large enough, -1 is returned and the expected buffer size is
981 * copied in *bufsize. Note that _NSGetExecutablePath will return "a path" to
982 * the executable not a "real path" to the executable. That is the path may be
983 * a symbolic link and not the real file. And with deep directories the total
984 * bufsize needed could be more than MAXPATHLEN.
985 */
986 int
987 _NSGetExecutablePath(
988 char *buf,
989 uint32_t *bufsize)
990 {
991 if ( gUseDyld3 )
992 return dyld3::_NSGetExecutablePath(buf, bufsize);
993
994 DYLD_NO_LOCK_THIS_BLOCK;
995 static int (*p)(char *buf, uint32_t *bufsize) = NULL;
996
997 if(p == NULL)
998 _dyld_func_lookup("__dyld__NSGetExecutablePath", (void**)&p);
999 return(p(buf, bufsize));
1000 }
1001
1002 #if DEPRECATED_APIS_SUPPORTED
1003 void
1004 _dyld_lookup_and_bind(
1005 const char* symbol_name,
1006 void** address,
1007 NSModule* module)
1008 {
1009 DYLD_LOCK_THIS_BLOCK;
1010 static void (*p)(const char*, void** , NSModule*) = NULL;
1011
1012 if(p == NULL)
1013 _dyld_func_lookup("__dyld_lookup_and_bind", (void**)&p);
1014 p(symbol_name, address, module);
1015 }
1016
1017 void
1018 _dyld_lookup_and_bind_with_hint(
1019 const char* symbol_name,
1020 const char* library_name_hint,
1021 void** address,
1022 NSModule* module)
1023 {
1024 DYLD_LOCK_THIS_BLOCK;
1025 static void (*p)(const char*, const char*, void**, NSModule*) = NULL;
1026
1027 if(p == NULL)
1028 _dyld_func_lookup("__dyld_lookup_and_bind_with_hint", (void**)&p);
1029 p(symbol_name, library_name_hint, address, module);
1030 }
1031
1032 #if OBSOLETE_DYLD_API
1033 void
1034 _dyld_lookup_and_bind_objc(
1035 const char* symbol_name,
1036 void** address,
1037 NSModule* module)
1038 {
1039 DYLD_LOCK_THIS_BLOCK;
1040 static void (*p)(const char* , void**, NSModule*) = NULL;
1041
1042 if(p == NULL)
1043 _dyld_func_lookup("__dyld_lookup_and_bind_objc", (void**)&p);
1044 p(symbol_name, address, module);
1045 }
1046 #endif
1047
1048 void
1049 _dyld_lookup_and_bind_fully(
1050 const char* symbol_name,
1051 void** address,
1052 NSModule* module)
1053 {
1054 DYLD_LOCK_THIS_BLOCK;
1055 static void (*p)(const char*, void**, NSModule*) = NULL;
1056
1057 if(p == NULL)
1058 _dyld_func_lookup("__dyld_lookup_and_bind_fully", (void**)&p);
1059 p(symbol_name, address, module);
1060 }
1061
1062 bool
1063 _dyld_bind_fully_image_containing_address(
1064 const void* address)
1065 {
1066 DYLD_LOCK_THIS_BLOCK;
1067 static bool (*p)(const void*) = NULL;
1068
1069 if(p == NULL)
1070 _dyld_func_lookup("__dyld_bind_fully_image_containing_address", (void**)&p);
1071 return p(address);
1072 }
1073 #endif // DEPRECATED_APIS_SUPPORTED
1074
1075
1076 /*
1077 * _dyld_register_func_for_add_image registers the specified function to be
1078 * called when a new image is added (a bundle or a dynamic shared library) to
1079 * the program. When this function is first registered it is called for once
1080 * for each image that is currently part of the program.
1081 */
1082 void
1083 _dyld_register_func_for_add_image(
1084 void (*func)(const struct mach_header *mh, intptr_t vmaddr_slide))
1085 {
1086 if ( gUseDyld3 )
1087 return dyld3::_dyld_register_func_for_add_image(func);
1088
1089 DYLD_LOCK_THIS_BLOCK;
1090 typedef void (*callback_t)(const struct mach_header *mh, intptr_t vmaddr_slide);
1091 static void (*p)(callback_t func) = NULL;
1092
1093 if(p == NULL)
1094 _dyld_func_lookup("__dyld_register_func_for_add_image", (void**)&p);
1095 p(func);
1096 }
1097
1098 /*
1099 * _dyld_register_func_for_remove_image registers the specified function to be
1100 * called when an image is removed (a bundle or a dynamic shared library) from
1101 * the program.
1102 */
1103 void
1104 _dyld_register_func_for_remove_image(
1105 void (*func)(const struct mach_header *mh, intptr_t vmaddr_slide))
1106 {
1107 if ( gUseDyld3 )
1108 return dyld3::_dyld_register_func_for_remove_image(func);
1109
1110 DYLD_LOCK_THIS_BLOCK;
1111 typedef void (*callback_t)(const struct mach_header *mh, intptr_t vmaddr_slide);
1112 static void (*p)(callback_t func) = NULL;
1113
1114 if(p == NULL)
1115 _dyld_func_lookup("__dyld_register_func_for_remove_image", (void**)&p);
1116 p(func);
1117 }
1118
1119 #if OBSOLETE_DYLD_API
1120 /*
1121 * _dyld_register_func_for_link_module registers the specified function to be
1122 * called when a module is bound into the program. When this function is first
1123 * registered it is called for once for each module that is currently bound into
1124 * the program.
1125 */
1126 void
1127 _dyld_register_func_for_link_module(
1128 void (*func)(NSModule module))
1129 {
1130 DYLD_LOCK_THIS_BLOCK;
1131 static void (*p)(void (*func)(NSModule module)) = NULL;
1132
1133 if(p == NULL)
1134 _dyld_func_lookup("__dyld_register_func_for_link_module", (void**)&p);
1135 p(func);
1136 }
1137
1138 /*
1139 * _dyld_register_func_for_unlink_module registers the specified function to be
1140 * called when a module is unbound from the program.
1141 */
1142 void
1143 _dyld_register_func_for_unlink_module(
1144 void (*func)(NSModule module))
1145 {
1146 DYLD_LOCK_THIS_BLOCK;
1147 static void (*p)(void (*func)(NSModule module)) = NULL;
1148
1149 if(p == NULL)
1150 _dyld_func_lookup("__dyld_register_func_for_unlink_module", (void**)&p);
1151 p(func);
1152 }
1153
1154 /*
1155 * _dyld_register_func_for_replace_module registers the specified function to be
1156 * called when a module is to be replace with another module in the program.
1157 */
1158 void
1159 _dyld_register_func_for_replace_module(
1160 void (*func)(NSModule oldmodule, NSModule newmodule))
1161 {
1162 DYLD_LOCK_THIS_BLOCK;
1163 static void (*p)(void (*func)(NSModule oldmodule,
1164 NSModule newmodule)) = NULL;
1165
1166 if(p == NULL)
1167 _dyld_func_lookup("__dyld_register_func_for_replace_module", (void**)&p);
1168 p(func);
1169 }
1170
1171
1172 /*
1173 * _dyld_get_objc_module_sect_for_module is passed a module and sets a
1174 * pointer to the (__OBJC,__module) section and its size for the specified
1175 * module.
1176 */
1177 void
1178 _dyld_get_objc_module_sect_for_module(
1179 NSModule module,
1180 void **objc_module,
1181 unsigned long *size)
1182 {
1183 DYLD_LOCK_THIS_BLOCK;
1184 static void (*p)(NSModule module,
1185 void **objc_module,
1186 unsigned long *size) = NULL;
1187
1188 if(p == NULL)
1189 _dyld_func_lookup("__dyld_get_objc_module_sect_for_module", (void**)&p);
1190 p(module, objc_module, size);
1191 }
1192
1193 #endif
1194
1195 #if DEPRECATED_APIS_SUPPORTED
1196 bool
1197 _dyld_present(void)
1198 {
1199 // this function exists for compatiblity only
1200 return true;
1201 }
1202 #endif
1203
1204 uint32_t
1205 _dyld_image_count(void)
1206 {
1207 if ( gUseDyld3 )
1208 return dyld3::_dyld_image_count();
1209
1210 DYLD_NO_LOCK_THIS_BLOCK;
1211 static uint32_t (*p)(void) = NULL;
1212
1213 if(p == NULL)
1214 _dyld_func_lookup("__dyld_image_count", (void**)&p);
1215 return(p());
1216 }
1217
1218 const struct mach_header *
1219 _dyld_get_image_header(uint32_t image_index)
1220 {
1221 if ( gUseDyld3 )
1222 return dyld3::_dyld_get_image_header(image_index);
1223
1224 DYLD_NO_LOCK_THIS_BLOCK;
1225 static struct mach_header * (*p)(uint32_t image_index) = NULL;
1226
1227 if(p == NULL)
1228 _dyld_func_lookup("__dyld_get_image_header", (void**)&p);
1229 return(p(image_index));
1230 }
1231
1232 intptr_t
1233 _dyld_get_image_vmaddr_slide(uint32_t image_index)
1234 {
1235 if ( gUseDyld3 )
1236 return dyld3::_dyld_get_image_vmaddr_slide(image_index);
1237
1238 DYLD_NO_LOCK_THIS_BLOCK;
1239 static unsigned long (*p)(uint32_t image_index) = NULL;
1240
1241 if(p == NULL)
1242 _dyld_func_lookup("__dyld_get_image_vmaddr_slide", (void**)&p);
1243 return(p(image_index));
1244 }
1245
1246 const char*
1247 _dyld_get_image_name(uint32_t image_index)
1248 {
1249 if ( gUseDyld3 )
1250 return dyld3::_dyld_get_image_name(image_index);
1251
1252 DYLD_NO_LOCK_THIS_BLOCK;
1253 static const char* (*p)(uint32_t image_index) = NULL;
1254
1255 if(p == NULL)
1256 _dyld_func_lookup("__dyld_get_image_name", (void**)&p);
1257 return(p(image_index));
1258 }
1259
1260 // SPI in Mac OS X 10.6
1261 intptr_t _dyld_get_image_slide(const struct mach_header* mh)
1262 {
1263 // always use dyld3 version because it does better error handling
1264 return dyld3::_dyld_get_image_slide(mh);
1265 }
1266
1267
1268 #if DEPRECATED_APIS_SUPPORTED
1269 bool
1270 _dyld_image_containing_address(const void* address)
1271 {
1272 if ( gUseDyld3 )
1273 return dyld3::_dyld_image_containing_address(address);
1274
1275 DYLD_LOCK_THIS_BLOCK;
1276 static bool (*p)(const void*) = NULL;
1277
1278 if(p == NULL)
1279 _dyld_func_lookup("__dyld_image_containing_address", (void**)&p);
1280 return(p(address));
1281 }
1282
1283 const struct mach_header *
1284 _dyld_get_image_header_containing_address(
1285 const void* address)
1286 {
1287 if ( gUseDyld3 )
1288 return dyld3::_dyld_get_image_header_containing_address(address);
1289
1290 DYLD_LOCK_THIS_BLOCK;
1291 static const struct mach_header * (*p)(const void*) = NULL;
1292
1293 if(p == NULL)
1294 _dyld_func_lookup("__dyld_get_image_header_containing_address", (void**)&p);
1295 return p(address);
1296 }
1297
1298 bool _dyld_launched_prebound(void)
1299 {
1300 DYLD_LOCK_THIS_BLOCK;
1301 static bool (*p)(void) = NULL;
1302
1303 if(p == NULL)
1304 _dyld_func_lookup("__dyld_launched_prebound", (void**)&p);
1305 return(p());
1306 }
1307
1308 bool _dyld_all_twolevel_modules_prebound(void)
1309 {
1310 DYLD_LOCK_THIS_BLOCK;
1311 static bool (*p)(void) = NULL;
1312
1313 if(p == NULL)
1314 _dyld_func_lookup("__dyld_all_twolevel_modules_prebound", (void**)&p);
1315 return(p());
1316 }
1317 #endif // DEPRECATED_APIS_SUPPORTED
1318
1319
1320 #include <dlfcn.h>
1321 #include <stddef.h>
1322 #include <pthread.h>
1323 #include <stdlib.h>
1324 #include <mach-o/dyld.h>
1325 #include "dyldLibSystemInterface.h"
1326
1327
1328 // pthread key used to access per-thread dlerror message
1329 static pthread_key_t dlerrorPerThreadKey;
1330 static bool dlerrorPerThreadKeyInitialized = false;
1331
1332 // data kept per-thread
1333 struct dlerrorPerThreadData
1334 {
1335 size_t sizeAllocated;
1336 char message[1];
1337 };
1338
1339 // function called by dyld to get buffer to store dlerror message
1340 static char* getPerThreadBufferFor_dlerror(size_t sizeRequired)
1341 {
1342 // ok to create key lazily because this function is called within dyld lock, so there is no race condition
1343 if (!dlerrorPerThreadKeyInitialized ) {
1344 // create key and tell pthread package to call free() on any data associated with key if thread dies
1345 pthread_key_create(&dlerrorPerThreadKey, &free);
1346 dlerrorPerThreadKeyInitialized = true;
1347 }
1348
1349 const size_t size = (sizeRequired < 256) ? 256 : sizeRequired;
1350 dlerrorPerThreadData* data = (dlerrorPerThreadData*)pthread_getspecific(dlerrorPerThreadKey);
1351 if ( data == NULL ) {
1352 //int mallocSize = offsetof(dlerrorPerThreadData, message[size]);
1353 const size_t mallocSize = sizeof(dlerrorPerThreadData)+size;
1354 data = (dlerrorPerThreadData*)malloc(mallocSize);
1355 data->sizeAllocated = size;
1356 pthread_setspecific(dlerrorPerThreadKey, data);
1357 }
1358 else if ( data->sizeAllocated < sizeRequired ) {
1359 free(data);
1360 //int mallocSize = offsetof(dlerrorPerThreadData, message[size]);
1361 const size_t mallocSize = sizeof(dlerrorPerThreadData)+size;
1362 data = (dlerrorPerThreadData*)malloc(mallocSize);
1363 data->sizeAllocated = size;
1364 pthread_setspecific(dlerrorPerThreadKey, data);
1365 }
1366 return data->message;
1367 }
1368
1369 // <rdar://problem/10595338> dlerror buffer leak
1370 // Only allocate buffer if an actual error message needs to be set
1371 static bool hasPerThreadBufferFor_dlerror()
1372 {
1373 if (!dlerrorPerThreadKeyInitialized )
1374 return false;
1375
1376 return (pthread_getspecific(dlerrorPerThreadKey) != NULL);
1377 }
1378
1379 #if TARGET_OS_DRIVERKIT
1380 static bool isLaunchdOwned()
1381 {
1382 return false;
1383 }
1384 #else
1385 // use non-lazy pointer to vproc_swap_integer so that lazy binding does not recurse
1386 typedef vproc_err_t (*vswapproc)(vproc_t vp, vproc_gsk_t key,int64_t *inval, int64_t *outval);
1387 static vswapproc swapProc = &vproc_swap_integer;
1388
1389 static bool isLaunchdOwned()
1390 {
1391 static bool checked = false;
1392 static bool result = false;
1393 if ( !checked ) {
1394 checked = true;
1395 int64_t val = 0;
1396 (*swapProc)(NULL, VPROC_GSK_IS_MANAGED, NULL, &val);
1397 result = ( val != 0 );
1398 }
1399 return result;
1400 }
1401 #endif
1402
1403 static void shared_cache_missing()
1404 {
1405 // leave until dyld's that might call this are rare
1406 }
1407
1408 static void shared_cache_out_of_date()
1409 {
1410 // leave until dyld's that might call this are rare
1411 }
1412
1413
1414 // the table passed to dyld containing thread helpers
1415 static dyld::LibSystemHelpers sHelpers = { 13, &dyldGlobalLockAcquire, &dyldGlobalLockRelease,
1416 &getPerThreadBufferFor_dlerror, &malloc, &free, &__cxa_atexit,
1417 &shared_cache_missing, &shared_cache_out_of_date,
1418 NULL, NULL,
1419 &pthread_key_create, &pthread_setspecific,
1420 &malloc_size,
1421 &pthread_getspecific,
1422 &__cxa_finalize,
1423 address_of_start,
1424 &hasPerThreadBufferFor_dlerror,
1425 &isLaunchdOwned,
1426 &vm_allocate,
1427 &mmap,
1428 &__cxa_finalize_ranges
1429 };
1430
1431 static const objc_opt::objc_opt_t* gObjCOpt = nullptr;
1432 //
1433 // during initialization of libSystem this routine will run
1434 // and call dyld, registering the helper functions.
1435 //
1436 extern "C" void tlv_initializer();
1437 void _dyld_initializer()
1438 {
1439 void (*p)(dyld::LibSystemHelpers*);
1440
1441 // Get the optimized objc pointer now that the cache is loaded
1442 const dyld_all_image_infos* allInfo = _dyld_get_all_image_infos();
1443 if ( allInfo != nullptr ) {
1444 const DyldSharedCache* cache = (const DyldSharedCache*)(allInfo->sharedCacheBaseAddress);
1445 if ( cache != nullptr )
1446 gObjCOpt = cache->objcOpt();
1447 }
1448
1449 if ( gUseDyld3 ) {
1450 dyld3::gAllImages.applyInitialImages();
1451 #if TARGET_OS_IOS && !TARGET_OS_SIMULATOR
1452 // For binaries built before 13.0, set the lookup function if they need it
1453 if (dyld_get_program_sdk_version() < DYLD_PACKED_VERSION(13,0,0))
1454 setLookupFunc((void*)&dyld3::compatFuncLookup);
1455 #endif
1456 }
1457 else {
1458 _dyld_func_lookup("__dyld_register_thread_helpers", (void**)&p);
1459 if(p != NULL)
1460 p(&sHelpers);
1461 }
1462
1463 tlv_initializer();
1464 }
1465
1466 int dladdr(const void* addr, Dl_info* info)
1467 {
1468 dyld3::ScopedTimer timer(DBG_DYLD_TIMING_DLADDR, (uint64_t)addr, 0, 0);
1469 int result = 0;
1470 if ( gUseDyld3 ) {
1471 result = dyld3::dladdr(addr, info);
1472 } else {
1473 DYLD_LOCK_THIS_BLOCK;
1474 static int (*p)(const void* , Dl_info*) = NULL;
1475
1476 if(p == NULL)
1477 _dyld_func_lookup("__dyld_dladdr", (void**)&p);
1478 result = p(addr, info);
1479 }
1480 timer.setData4(result);
1481 timer.setData5(info != NULL ? info->dli_fbase : 0);
1482 timer.setData6(info != NULL ? info->dli_saddr : 0);
1483 return result;
1484 }
1485
1486 #if !TARGET_OS_DRIVERKIT
1487 char* dlerror()
1488 {
1489 if ( gUseDyld3 )
1490 return dyld3::dlerror();
1491
1492 DYLD_LOCK_THIS_BLOCK;
1493 static char* (*p)() = NULL;
1494
1495 if(p == NULL)
1496 _dyld_func_lookup("__dyld_dlerror", (void**)&p);
1497 return(p());
1498 }
1499
1500 int dlclose(void* handle)
1501 {
1502 dyld3::ScopedTimer timer(DBG_DYLD_TIMING_DLCLOSE, (uint64_t)handle, 0, 0);
1503 int result = 0;
1504 if ( gUseDyld3 ) {
1505 timer.setData4(result);
1506 return dyld3::dlclose(handle);
1507 }
1508
1509 DYLD_LOCK_THIS_BLOCK;
1510 static int (*p)(void* handle) = NULL;
1511
1512 if(p == NULL)
1513 _dyld_func_lookup("__dyld_dlclose", (void**)&p);
1514 result = p(handle);
1515 timer.setData4(result);
1516 return result;
1517 }
1518
1519 void* dlopen(const char* path, int mode)
1520 {
1521 dyld3::ScopedTimer timer(DBG_DYLD_TIMING_DLOPEN, path, mode, 0);
1522 void* result = nullptr;
1523
1524 if ( gUseDyld3 ) {
1525 result = dyld3::dlopen_internal(path, mode, __builtin_return_address(0));
1526 timer.setData4(result);
1527 return result;
1528 }
1529
1530 // dlopen is special. locking is done inside dyld to allow initializer to run without lock
1531 DYLD_NO_LOCK_THIS_BLOCK;
1532
1533 static void* (*p)(const char* path, int, void*) = NULL;
1534
1535 if(p == NULL)
1536 _dyld_func_lookup("__dyld_dlopen_internal", (void**)&p);
1537 result = p(path, mode, __builtin_return_address(0));
1538 // use asm block to prevent tail call optimization
1539 // this is needed because dlopen uses __builtin_return_address() and depends on this glue being in the frame chain
1540 // <rdar://problem/5313172 dlopen() looks too far up stack, can cause crash>
1541 __asm__ volatile("");
1542 timer.setData4(result);
1543
1544 return result;
1545 }
1546
1547 bool dlopen_preflight(const char* path)
1548 {
1549 dyld3::ScopedTimer timer(DBG_DYLD_TIMING_DLOPEN_PREFLIGHT, path, 0, 0);
1550 bool result = false;
1551
1552 if ( gUseDyld3 ) {
1553 result = dyld3::dlopen_preflight_internal(path);
1554 timer.setData4(result);
1555 return result;
1556 }
1557
1558 DYLD_LOCK_THIS_BLOCK;
1559 static bool (*p)(const char* path, void* callerAddress) = NULL;
1560
1561 if(p == NULL)
1562 _dyld_func_lookup("__dyld_dlopen_preflight_internal", (void**)&p);
1563 result = p(path, __builtin_return_address(0));
1564 timer.setData4(result);
1565 return result;
1566 }
1567
1568 void* dlsym(void* handle, const char* symbol)
1569 {
1570 dyld3::ScopedTimer timer(DBG_DYLD_TIMING_DLSYM, handle, symbol, 0);
1571 void* result = nullptr;
1572
1573 if ( gUseDyld3 ) {
1574 result = dyld3::dlsym_internal(handle, symbol, __builtin_return_address(0));
1575 timer.setData4(result);
1576 return result;
1577 }
1578
1579 DYLD_LOCK_THIS_BLOCK;
1580 static void* (*p)(void* handle, const char* symbol, void *callerAddress) = NULL;
1581
1582 if(p == NULL)
1583 _dyld_func_lookup("__dyld_dlsym_internal", (void**)&p);
1584 result = p(handle, symbol, __builtin_return_address(0));
1585 timer.setData4(result);
1586 return result;
1587 }
1588 #endif // !TARGET_OS_DRIVERKIT
1589
1590
1591 const struct dyld_all_image_infos* _dyld_get_all_image_infos()
1592 {
1593 if ( gUseDyld3 )
1594 return dyld3::_dyld_get_all_image_infos();
1595
1596 DYLD_NO_LOCK_THIS_BLOCK;
1597 static struct dyld_all_image_infos* (*p)() = NULL;
1598
1599 if(p == NULL)
1600 _dyld_func_lookup("__dyld_get_all_image_infos", (void**)&p);
1601 return p();
1602 }
1603
1604 #if SUPPORT_ZERO_COST_EXCEPTIONS
1605 bool _dyld_find_unwind_sections(void* addr, dyld_unwind_sections* info)
1606 {
1607 if ( gUseDyld3 )
1608 return dyld3::_dyld_find_unwind_sections(addr, info);
1609
1610 DYLD_NO_LOCK_THIS_BLOCK;
1611 static void* (*p)(void*, dyld_unwind_sections*) = NULL;
1612
1613 if(p == NULL)
1614 _dyld_func_lookup("__dyld_find_unwind_sections", (void**)&p);
1615 return p(addr, info);
1616 }
1617 #endif
1618
1619
1620 #if __i386__ || __x86_64__ || __arm__ || __arm64__
1621 __attribute__((visibility("hidden")))
1622 void* _dyld_fast_stub_entry(void* loadercache, long lazyinfo)
1623 {
1624 DYLD_NO_LOCK_THIS_BLOCK;
1625 static void* (*p)(void*, long) = NULL;
1626
1627 if(p == NULL)
1628 _dyld_func_lookup("__dyld_fast_stub_entry", (void**)&p);
1629 return p(loadercache, lazyinfo);
1630 }
1631 #endif
1632
1633
1634 const char* dyld_image_path_containing_address(const void* addr)
1635 {
1636 if ( gUseDyld3 )
1637 return dyld3::dyld_image_path_containing_address(addr);
1638
1639 DYLD_NO_LOCK_THIS_BLOCK;
1640 static const char* (*p)(const void*) = NULL;
1641
1642 if(p == NULL)
1643 _dyld_func_lookup("__dyld_image_path_containing_address", (void**)&p);
1644 return p(addr);
1645 }
1646
1647 const struct mach_header* dyld_image_header_containing_address(const void* addr)
1648 {
1649 if ( gUseDyld3 )
1650 return dyld3::dyld_image_header_containing_address(addr);
1651
1652 DYLD_NO_LOCK_THIS_BLOCK;
1653 static const mach_header* (*p)(const void*) = NULL;
1654
1655 if(p == NULL)
1656 _dyld_func_lookup("__dyld_get_image_header_containing_address", (void**)&p);
1657 return p(addr);
1658 }
1659
1660
1661 bool dyld_shared_cache_some_image_overridden()
1662 {
1663 if ( gUseDyld3 )
1664 return dyld3::dyld_shared_cache_some_image_overridden();
1665
1666 DYLD_NO_LOCK_THIS_BLOCK;
1667 static bool (*p)() = NULL;
1668
1669 if(p == NULL)
1670 _dyld_func_lookup("__dyld_shared_cache_some_image_overridden", (void**)&p);
1671 return p();
1672 }
1673
1674 bool _dyld_get_shared_cache_uuid(uuid_t uuid)
1675 {
1676 if ( gUseDyld3 )
1677 return dyld3::_dyld_get_shared_cache_uuid(uuid);
1678
1679 DYLD_NO_LOCK_THIS_BLOCK;
1680 static bool (*p)(uuid_t) = NULL;
1681
1682 if(p == NULL)
1683 _dyld_func_lookup("__dyld_get_shared_cache_uuid", (void**)&p);
1684 return p(uuid);
1685 }
1686
1687 const void* _dyld_get_shared_cache_range(size_t* length)
1688 {
1689 if ( gUseDyld3 )
1690 return dyld3::_dyld_get_shared_cache_range(length);
1691
1692 DYLD_NO_LOCK_THIS_BLOCK;
1693 static const void* (*p)(size_t*) = NULL;
1694
1695 if(p == NULL)
1696 _dyld_func_lookup("__dyld_get_shared_cache_range", (void**)&p);
1697 return p(length);
1698 }
1699
1700 bool _dyld_shared_cache_optimized()
1701 {
1702 if ( gUseDyld3 )
1703 return dyld3::_dyld_shared_cache_optimized();
1704
1705 const dyld_all_image_infos* allInfo = _dyld_get_all_image_infos();
1706 if ( allInfo != nullptr ) {
1707 const dyld_cache_header* cacheHeader = (dyld_cache_header*)(allInfo->sharedCacheBaseAddress);
1708 if ( cacheHeader != nullptr )
1709 return (cacheHeader->cacheType == kDyldSharedCacheTypeProduction);
1710 }
1711 return false;
1712 }
1713
1714 bool _dyld_shared_cache_is_locally_built()
1715 {
1716 if ( gUseDyld3 )
1717 return dyld3::_dyld_shared_cache_is_locally_built();
1718
1719 const dyld_all_image_infos* allInfo = _dyld_get_all_image_infos();
1720 if ( allInfo != nullptr ) {
1721 const dyld_cache_header* cacheHeader = (dyld_cache_header*)(allInfo->sharedCacheBaseAddress);
1722 if ( cacheHeader != nullptr )
1723 return (cacheHeader->locallyBuiltCache == 1);
1724 }
1725 return false;
1726 }
1727
1728 void _dyld_images_for_addresses(unsigned count, const void* addresses[], struct dyld_image_uuid_offset infos[])
1729 {
1730 if ( gUseDyld3 )
1731 return dyld3::_dyld_images_for_addresses(count, addresses, infos);
1732
1733 DYLD_NO_LOCK_THIS_BLOCK;
1734 static const void (*p)(unsigned, const void*[], struct dyld_image_uuid_offset[]) = NULL;
1735
1736 if(p == NULL)
1737 _dyld_func_lookup("__dyld_images_for_addresses", (void**)&p);
1738 return p(count, addresses, infos);
1739 }
1740
1741 void _dyld_register_for_image_loads(void (*func)(const mach_header* mh, const char* path, bool unloadable))
1742 {
1743 if ( gUseDyld3 )
1744 return dyld3::_dyld_register_for_image_loads(func);
1745
1746 DYLD_NO_LOCK_THIS_BLOCK;
1747 static const void (*p)(void (*)(const mach_header* mh, const char* path, bool unloadable)) = NULL;
1748
1749 if(p == NULL)
1750 _dyld_func_lookup("__dyld_register_for_image_loads", (void**)&p);
1751 return p(func);
1752 }
1753
1754 void _dyld_register_for_bulk_image_loads(void (*func)(unsigned imageCount, const struct mach_header* mhs[], const char* paths[]))
1755 {
1756 if ( gUseDyld3 )
1757 return dyld3::_dyld_register_for_bulk_image_loads(func);
1758
1759 DYLD_NO_LOCK_THIS_BLOCK;
1760 static const void (*p)(void (*)(unsigned imageCount, const mach_header* mhs[], const char* paths[])) = NULL;
1761
1762 if(p == NULL)
1763 _dyld_func_lookup("__dyld_register_for_bulk_image_loads", (void**)&p);
1764 return p(func);
1765 }
1766
1767 bool dyld_need_closure(const char* execPath, const char* tempDir)
1768 {
1769 return dyld3::dyld_need_closure(execPath, tempDir);
1770 }
1771
1772 bool dyld_process_is_restricted()
1773 {
1774 if ( gUseDyld3 )
1775 return dyld3::dyld_process_is_restricted();
1776
1777 DYLD_NO_LOCK_THIS_BLOCK;
1778 static bool (*p)() = NULL;
1779
1780 if(p == NULL)
1781 _dyld_func_lookup("__dyld_process_is_restricted", (void**)&p);
1782 return p();
1783 }
1784
1785 const char* dyld_shared_cache_file_path()
1786 {
1787 if ( gUseDyld3 )
1788 return dyld3::dyld_shared_cache_file_path();
1789
1790 DYLD_NO_LOCK_THIS_BLOCK;
1791 static const char* (*p)() = NULL;
1792
1793 if(p == NULL)
1794 _dyld_func_lookup("__dyld_shared_cache_file_path", (void**)&p);
1795 return p();
1796 }
1797
1798 bool dyld_has_inserted_or_interposing_libraries()
1799 {
1800 if ( gUseDyld3 )
1801 return dyld3::dyld_has_inserted_or_interposing_libraries();
1802
1803 DYLD_NO_LOCK_THIS_BLOCK;
1804 static bool (*p)() = NULL;
1805
1806 if (p == NULL)
1807 _dyld_func_lookup("__dyld_has_inserted_or_interposing_libraries", (void**)&p);
1808 return p();
1809 }
1810
1811 void dyld_dynamic_interpose(const struct mach_header* mh, const struct dyld_interpose_tuple array[], size_t count)
1812 {
1813 if ( gUseDyld3 )
1814 return dyld3::dyld_dynamic_interpose(mh, array, count);
1815
1816 DYLD_LOCK_THIS_BLOCK;
1817 static void (*p)(const struct mach_header* mh, const struct dyld_interpose_tuple array[], size_t count) = NULL;
1818
1819 if (p == NULL)
1820 _dyld_func_lookup("__dyld_dynamic_interpose", (void**)&p);
1821 p(mh, array, count);
1822 }
1823
1824 // SPI called __fork
1825 void _dyld_atfork_prepare()
1826 {
1827 if ( gUseDyld3 )
1828 return dyld3::_dyld_atfork_prepare();
1829 }
1830
1831 // SPI called __fork
1832 void _dyld_atfork_parent()
1833 {
1834 if ( gUseDyld3 )
1835 return dyld3::_dyld_atfork_parent();
1836 }
1837
1838 // SPI called __fork
1839 void _dyld_fork_child()
1840 {
1841 if ( gUseDyld3 )
1842 return dyld3::_dyld_fork_child();
1843
1844 DYLD_NO_LOCK_THIS_BLOCK;
1845 static void (*p)() = NULL;
1846
1847 if(p == NULL)
1848 _dyld_func_lookup("__dyld_fork_child", (void**)&p);
1849 return p();
1850 }
1851
1852
1853
1854 static void* mapStartOfCache(const char* path, size_t length)
1855 {
1856 struct stat statbuf;
1857 if ( ::stat(path, &statbuf) == -1 )
1858 return NULL;
1859
1860 if ( (size_t)statbuf.st_size < length )
1861 return NULL;
1862
1863 int cache_fd = ::open(path, O_RDONLY);
1864 if ( cache_fd < 0 )
1865 return NULL;
1866
1867 void* result = ::mmap(NULL, length, PROT_READ, MAP_PRIVATE, cache_fd, 0);
1868 close(cache_fd);
1869
1870 if ( result == MAP_FAILED )
1871 return NULL;
1872
1873 return result;
1874 }
1875
1876
1877 static const dyld_cache_header* findCacheInDirAndMap(const uuid_t cacheUuid, const char* dirPath)
1878 {
1879 DIR* dirp = ::opendir(dirPath);
1880 if ( dirp != NULL) {
1881 dirent entry;
1882 dirent* entp = NULL;
1883 char cachePath[PATH_MAX];
1884 while ( ::readdir_r(dirp, &entry, &entp) == 0 ) {
1885 if ( entp == NULL )
1886 break;
1887 if ( entp->d_type != DT_REG )
1888 continue;
1889 if ( strlcpy(cachePath, dirPath, PATH_MAX) >= PATH_MAX )
1890 continue;
1891 if ( strlcat(cachePath, "/", PATH_MAX) >= PATH_MAX )
1892 continue;
1893 if ( strlcat(cachePath, entp->d_name, PATH_MAX) >= PATH_MAX )
1894 continue;
1895 if ( const dyld_cache_header* cacheHeader = (dyld_cache_header*)mapStartOfCache(cachePath, 0x00100000) ) {
1896 if ( ::memcmp(cacheHeader->uuid, cacheUuid, 16) != 0 ) {
1897 // wrong uuid, unmap and keep looking
1898 ::munmap((void*)cacheHeader, 0x00100000);
1899 }
1900 else {
1901 // found cache
1902 closedir(dirp);
1903 return cacheHeader;
1904 }
1905 }
1906 }
1907 closedir(dirp);
1908 }
1909 return NULL;
1910 }
1911
1912 int dyld_shared_cache_find_iterate_text(const uuid_t cacheUuid, const char* extraSearchDirs[], void (^callback)(const dyld_shared_cache_dylib_text_info* info))
1913 {
1914 if ( gUseDyld3 )
1915 return dyld3::dyld_shared_cache_find_iterate_text(cacheUuid, extraSearchDirs, callback);
1916
1917 const dyld_cache_header* cacheHeader = NULL;
1918 bool needToUnmap = true;
1919
1920 // get info from dyld about this process, to see if requested cache is already mapped into this process
1921 const dyld_all_image_infos* allInfo = _dyld_get_all_image_infos();
1922 if ( (allInfo != NULL) && (allInfo->sharedCacheBaseAddress != 0) && (memcmp(allInfo->sharedCacheUUID, cacheUuid, 16) == 0) ) {
1923 // requested cache is already mapped, just re-use it
1924 cacheHeader = (dyld_cache_header*)(allInfo->sharedCacheBaseAddress);
1925 needToUnmap = false;
1926 }
1927 else {
1928 // look first is default location for cache files
1929 #if __IPHONE_OS_VERSION_MIN_REQUIRED
1930 const char* defaultSearchDir = IPHONE_DYLD_SHARED_CACHE_DIR;
1931 #else
1932 const char* defaultSearchDir = MACOSX_DYLD_SHARED_CACHE_DIR;
1933 #endif
1934 cacheHeader = findCacheInDirAndMap(cacheUuid, defaultSearchDir);
1935 // if not there, look in extra search locations
1936 if ( cacheHeader == NULL ) {
1937 for (const char** p = extraSearchDirs; *p != NULL; ++p) {
1938 cacheHeader = findCacheInDirAndMap(cacheUuid, *p);
1939 if ( cacheHeader != NULL )
1940 break;
1941 }
1942 }
1943 }
1944
1945 if ( cacheHeader == NULL )
1946 return -1;
1947
1948 if ( cacheHeader->mappingOffset < sizeof(dyld_cache_header) ) {
1949 // old cache without imagesText array
1950 if ( needToUnmap )
1951 ::munmap((void*)cacheHeader, 0x00100000);
1952 return -1;
1953 }
1954
1955 // walk imageText table and call callback for each entry
1956 const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)cacheHeader + cacheHeader->mappingOffset);
1957 const uint64_t cacheUnslidBaseAddress = mappings[0].address;
1958 const dyld_cache_image_text_info* imagesText = (dyld_cache_image_text_info*)((char*)cacheHeader + cacheHeader->imagesTextOffset);
1959 const dyld_cache_image_text_info* imagesTextEnd = &imagesText[cacheHeader->imagesTextCount];
1960 for (const dyld_cache_image_text_info* p=imagesText; p < imagesTextEnd; ++p) {
1961 dyld_shared_cache_dylib_text_info dylibTextInfo;
1962 dylibTextInfo.version = 2;
1963 dylibTextInfo.loadAddressUnslid = p->loadAddress;
1964 dylibTextInfo.textSegmentSize = p->textSegmentSize;
1965 dylibTextInfo.path = (char*)cacheHeader + p->pathOffset;
1966 ::memcpy(dylibTextInfo.dylibUuid, p->uuid, 16);
1967 dylibTextInfo.textSegmentOffset = p->loadAddress - cacheUnslidBaseAddress;
1968 callback(&dylibTextInfo);
1969 }
1970
1971 if ( needToUnmap )
1972 ::munmap((void*)cacheHeader, 0x00100000);
1973
1974 return 0;
1975 }
1976
1977 int dyld_shared_cache_iterate_text(const uuid_t cacheUuid, void (^callback)(const dyld_shared_cache_dylib_text_info* info))
1978 {
1979 if ( gUseDyld3 )
1980 return dyld3::dyld_shared_cache_iterate_text(cacheUuid, callback);
1981
1982 const char* extraSearchDirs[] = { NULL };
1983 return dyld_shared_cache_find_iterate_text(cacheUuid, extraSearchDirs, callback);
1984 }
1985
1986
1987 bool _dyld_is_memory_immutable(const void* addr, size_t length)
1988 {
1989 if ( gUseDyld3 )
1990 return dyld3::_dyld_is_memory_immutable(addr, length);
1991
1992 DYLD_NO_LOCK_THIS_BLOCK;
1993 static bool (*p)(const void*, size_t) = NULL;
1994
1995 if(p == NULL)
1996 _dyld_func_lookup("__dyld_is_memory_immutable", (void**)&p);
1997 return p(addr, length);
1998 }
1999
2000
2001 void _dyld_objc_notify_register(_dyld_objc_notify_mapped mapped,
2002 _dyld_objc_notify_init init,
2003 _dyld_objc_notify_unmapped unmapped)
2004 {
2005 if ( gUseDyld3 )
2006 return dyld3::_dyld_objc_notify_register(mapped, init, unmapped);
2007
2008 DYLD_LOCK_THIS_BLOCK;
2009 static bool (*p)(_dyld_objc_notify_mapped, _dyld_objc_notify_init, _dyld_objc_notify_unmapped) = NULL;
2010
2011 if(p == NULL)
2012 _dyld_func_lookup("__dyld_objc_notify_register", (void**)&p);
2013 p(mapped, init, unmapped);
2014 }
2015
2016 void _dyld_missing_symbol_abort()
2017 {
2018 return dyld3::_dyld_missing_symbol_abort();
2019 }
2020
2021 const char* _dyld_get_objc_selector(const char* selName)
2022 {
2023 // Check the shared cache table if it exists.
2024 if ( gObjCOpt != nullptr ) {
2025 if ( const objc_opt::objc_selopt_t* selopt = gObjCOpt->selopt() ) {
2026 const char* name = selopt->get(selName);
2027 if (name != nullptr)
2028 return name;
2029 }
2030 }
2031
2032 if ( gUseDyld3 )
2033 return dyld3::_dyld_get_objc_selector(selName);
2034
2035 return nullptr;
2036 }
2037
2038 void _dyld_for_each_objc_class(const char* className,
2039 void (^callback)(void* classPtr, bool isLoaded, bool* stop)) {
2040 if ( gUseDyld3 )
2041 return dyld3::_dyld_for_each_objc_class(className, callback);
2042 }
2043
2044 void _dyld_for_each_objc_protocol(const char* protocolName,
2045 void (^callback)(void* protocolPtr, bool isLoaded, bool* stop)) {
2046 if ( gUseDyld3 )
2047 return dyld3::_dyld_for_each_objc_protocol(protocolName, callback);
2048 }
2049
2050 void _dyld_register_driverkit_main(void (*mainFunc)(void))
2051 {
2052 static bool (*p)(void (*mainFunc)(void)) = NULL;
2053
2054 if(p == NULL)
2055 _dyld_func_lookup("__dyld_register_driverkit_main", (void**)&p);
2056 p(mainFunc);
2057 }
mirror of dyld