![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to objc-runtime.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / objc|
Return to objc-runtime.m CVS log | Up to [Apple Darwin 0.x] / objc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.0 (the 'License'). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this 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 OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License." ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: /* ! 25: * objc-runtime.m ! 26: * Copyright 1988, NeXT, Inc. ! 27: * Author: s. naroff ! 28: * ! 29: */ ! 30: ! 31: #ifdef SHLIB ! 32: #import "shlib.h" ! 33: #endif SHLIB ! 34: ! 35: #import "objc-private.h" ! 36: #include <mach-o/ldsyms.h> ! 37: #import "objc-runtime.h" ! 38: #import "hashtable.h" ! 39: #import "maptable.h" ! 40: #import "Object.h" ! 41: #import "Protocol.h" ! 42: ! 43: void *getsectdatafromheader(const struct mach_header *, char *, char *, int *); ! 44: static const struct segment_command * ! 45: getobjcsegmentfromheader(const struct mach_header *mhp); ! 46: ! 47: void (*callbackFunction)( Class, Category ) = 0; ! 48: ! 49: void *getsectdatafromheaderinfo(const struct header_info * info, ! 50: char * segname, ! 51: char * sectname, ! 52: int * size) ! 53: { ! 54: char *addr = getsectdatafromheader (info->mhdr, segname, sectname, size); ! 55: if (addr) ! 56: addr += info->image_slide; ! 57: return addr; ! 58: } ! 59: ! 60: /* Turn on support for literal string objects. */ ! 61: #define LITERAL_STRING_OBJECTS ! 62: ! 63: /* system vectors...created at runtime by reading the `__OBJC' segments ! 64: * that are a part of the application. ! 65: */ ! 66: ! 67: /* These two variables are now obsolete. ! 68: They have been replaced by header_vector and header_count. */ ! 69: ! 70: static unsigned int module_count; ! 71: static Module *module_vector; ! 72: ! 73: /* We do not lock these variables, since they are only set during startup. */ ! 74: ! 75: static struct header_info *header_vector = 0; ! 76: static unsigned int header_count = 0; ! 77: ! 78: /* ! 79: * Hash table of classes... ! 80: */ ! 81: static NXHashTable *class_hash = 0; ! 82: ! 83: /* Mask which specifies whether we are multi-threaded or not. ! 84: A value of -1 means single-threaded, 0 means multi-threaded. */ ! 85: int _objc_multithread_mask = -1; ! 86: ! 87: /* Lock for class hashtable. (Private extern) */ ! 88: ! 89: OBJC_DECLARE_LOCK (classLock); ! 90: ! 91: static unsigned classHash (void *info, Class data) ! 92: { ! 93: return (data) ? _objc_strhash ((unsigned char *)((Class) data)->name) : 0; ! 94: } ! 95: ! 96: static int classIsEqual (void *info, Class name, Class cls) ! 97: { ! 98: return ((name->name[0] == cls->name[0]) && ! 99: (strcmp(name->name, cls->name) == 0)); ! 100: } ! 101: ! 102: static NXHashTablePrototype classHashPrototype = ! 103: { ! 104: (unsigned (*)(const void *, const void *))classHash, ! 105: (int (*)(const void *, const void *, const void *))classIsEqual, ! 106: NXNoEffectFree, 0 ! 107: }; ! 108: ! 109: /* This function is very dangerous, since you cannot safely use the hashtable ! 110: without locking it, and the lock is private! */ ! 111: ! 112: NXHashTable *objc_getClasses (void) ! 113: { ! 114: return class_hash; ! 115: } ! 116: ! 117: static int _objc_defaultClassHandler(const char *clsName) ! 118: { ! 119: _objc_inform("class `%s' not linked into application", clsName); ! 120: return 0; ! 121: } ! 122: ! 123: static int (*objc_classHandler)(const char *) = _objc_defaultClassHandler; ! 124: ! 125: void objc_setClassHandler(int (*userSuppliedHandler)(const char *)) ! 126: { ! 127: objc_classHandler = userSuppliedHandler; ! 128: } ! 129: ! 130: id objc_getClass(const char *aClassName) ! 131: { ! 132: struct objc_class cls; ! 133: id ret; ! 134: ! 135: OBJC_LOCK (&classLock); ! 136: cls.name = aClassName; ! 137: ! 138: if (!(ret = (id)NXHashGet(class_hash, &cls))) ! 139: { ! 140: int result; ! 141: ! 142: OBJC_UNLOCK (&classLock); ! 143: result = (*objc_classHandler)(aClassName); ! 144: OBJC_LOCK (&classLock); ! 145: ! 146: if (result) ! 147: ret = (id)NXHashGet(class_hash, &cls); ! 148: } ! 149: ! 150: OBJC_UNLOCK (&classLock); ! 151: return ret; ! 152: } ! 153: ! 154: /* Formerly objc_getClassWithoutWarning(). */ ! 155: ! 156: id objc_lookUpClass (const char *aClassName) ! 157: { ! 158: struct objc_class cls; ! 159: id ret; ! 160: ! 161: OBJC_LOCK (&classLock); ! 162: cls.name = aClassName; ! 163: ! 164: ret = (id)NXHashGet(class_hash, &cls); ! 165: ! 166: OBJC_UNLOCK (&classLock); ! 167: return ret; ! 168: } ! 169: ! 170: id objc_getMetaClass(const char *aClassName) ! 171: { ! 172: Class class = objc_getClass (aClassName); ! 173: ! 174: if (class) ! 175: return class->isa; ! 176: else ! 177: return Nil; ! 178: } ! 179: ! 180: void objc_addClass (Class class) ! 181: { ! 182: OBJC_LOCK (&classLock); ! 183: ! 184: // make sure both the class and the metaclass have caches! ! 185: // Clear all bits of the info fields except CLS_CLASS and CLS_META. ! 186: // Normally these bits are already clear but if someone tries to cons ! 187: // up their own class on the fly they may need to be cleared. ! 188: ! 189: if (class->cache == NULL) { ! 190: class->cache = (Cache) &emptyCache; ! 191: class->info = CLS_CLASS; ! 192: } ! 193: if (class->isa->cache == NULL) { ! 194: class->isa->cache = (Cache) &emptyCache; ! 195: class->isa->info = CLS_META; ! 196: } ! 197: ! 198: NXHashInsert (class_hash, class); ! 199: OBJC_UNLOCK (&classLock); ! 200: ! 201: } ! 202: ! 203: /* Private extern used by objc_unloadModules(). */ ! 204: void _objc_removeClass (Class class) ! 205: { ! 206: OBJC_LOCK (&classLock); ! 207: NXHashRemove (class_hash, class); ! 208: OBJC_UNLOCK (&classLock); ! 209: ! 210: } ! 211: ! 212: /* This only returns the statically linked modules. ! 213: I do not believe this is used now. ! 214: It has been replaced by _objc_headerVector(). */ ! 215: ! 216: Module *objc_getModules (void) ! 217: { ! 218: if (!module_vector) { ! 219: Module mods; ! 220: unsigned int hidx, midx; ! 221: Module *mvp; ! 222: ! 223: for (hidx = 0; hidx < header_count; hidx++) ! 224: module_count += header_vector[hidx].mod_count; ! 225: ! 226: if (!(module_vector = NXZoneMalloc(_objc_create_zone(), sizeof(Module) * (module_count+1)))) ! 227: _objc_fatal("unable to allocate module vector"); ! 228: ! 229: for (hidx = 0, mvp = module_vector; ! 230: hidx < header_count; hidx++) { ! 231: for (mods = header_vector[hidx].mod_ptr, midx = 0; ! 232: midx < header_vector[hidx].mod_count; ! 233: midx++, mvp++) { ! 234: ! 235: *mvp = mods+midx; ! 236: } ! 237: } ! 238: *mvp = 0; ! 239: } ! 240: return module_vector; ! 241: } ! 242: ! 243: /* What could this be used for? It is not currently used. */ ! 244: ! 245: Module *objc_addModule(Module myModule) ! 246: { ! 247: module_count++; ! 248: if (module_vector) { ! 249: module_vector = (Module *)NXZoneRealloc(_objc_create_zone(), ! 250: module_vector, ! 251: sizeof(Module) * (module_count + 1)); ! 252: } else { ! 253: module_vector = (Module *)NXZoneMalloc(_objc_create_zone(), ! 254: sizeof(Module) * (module_count + 1)); ! 255: } ! 256: if (!module_vector) ! 257: _objc_fatal("unable to reallocate module vector"); ! 258: ! 259: module_vector[module_count-1] = myModule; ! 260: module_vector[module_count] = 0; ! 261: return module_vector; ! 262: } ! 263: ! 264: /* Private extern used by objc_unloadModules(). */ ! 265: ! 266: void _objc_remove_category(struct objc_category *category, int version) ! 267: { ! 268: Class cls; ! 269: ! 270: if ((cls = objc_getClass(category->class_name))) { ! 271: if (category->instance_methods) ! 272: class_removeMethods(cls, category->instance_methods); ! 273: ! 274: if (category->class_methods) ! 275: class_removeMethods(cls->isa, category->class_methods); ! 276: if (version >= 5 && category->protocols) ! 277: _class_removeProtocols (cls, category->protocols); ! 278: } else { ! 279: _objc_inform("unable to remove category %s...\n", ! 280: category->category_name); ! 281: _objc_inform("class `%s' not linked into application\n", ! 282: category->class_name); ! 283: } ! 284: } ! 285: ! 286: static inline void ! 287: __objc_add_category(struct objc_category *category, int version) ! 288: { ! 289: Class cls; ! 290: ! 291: if ((cls = (Class)objc_getClass(category->class_name))) { ! 292: if (category->instance_methods) { ! 293: category->instance_methods->method_next = cls->methods; ! 294: cls->methods = category->instance_methods; ! 295: } ! 296: if (category->class_methods) { ! 297: category->class_methods->method_next = cls->isa->methods; ! 298: cls->isa->methods = category->class_methods; ! 299: } ! 300: if (version >= 5 && category->protocols) ! 301: { ! 302: if (cls->isa->version >= 5) ! 303: { ! 304: category->protocols->next = cls->protocols; ! 305: cls->protocols = category->protocols; ! 306: cls->isa->protocols = category->protocols; ! 307: } ! 308: else ! 309: { ! 310: _objc_inform ("unable to add protocols from category %s...\n", ! 311: category->category_name); ! 312: _objc_inform ("class `%s' must be recompiled\n", ! 313: category->class_name); ! 314: } ! 315: } ! 316: } else { ! 317: _objc_inform("unable to add category %s...\n", ! 318: category->category_name); ! 319: _objc_inform("class `%s' not linked into application\n", ! 320: category->class_name); ! 321: } ! 322: } ! 323: ! 324: /* Private extern used by objc_loadModules(). */ ! 325: ! 326: void _objc_add_category(struct objc_category *category, int version) ! 327: { ! 328: __objc_add_category (category, version); ! 329: ! 330: _objc_flush_caches (objc_getClass (category->class_name)); ! 331: } ! 332: ! 333: struct _objc_unresolved_category { ! 334: struct _objc_unresolved_category* next; ! 335: struct objc_category* cat; ! 336: long version; ! 337: }; ! 338: ! 339: static NXMapTable* category_hash = 0; ! 340: ! 341: static void _objc_resolve_categories_for_class (Class cls) ! 342: { ! 343: struct _objc_unresolved_category *cat, *next; ! 344: ! 345: if (!category_hash) ! 346: return; ! 347: ! 348: cat = NXMapRemove (category_hash, cls->name); ! 349: ! 350: while (cat) ! 351: { ! 352: _objc_add_category (cat->cat, cat->version); ! 353: ! 354: next = cat->next; ! 355: free (cat); ! 356: cat = next; ! 357: } ! 358: } ! 359: ! 360: ! 361: static void _objc_register_category (struct objc_category *cat, long version) ! 362: { ! 363: struct _objc_unresolved_category *new_cat, *old; ! 364: ! 365: if (objc_lookUpClass (cat->class_name)) ! 366: { ! 367: _objc_add_category (cat, version); ! 368: return; ! 369: } ! 370: ! 371: if (!category_hash) ! 372: category_hash = NXCreateMapTableFromZone (NXStrValueMapPrototype, ! 373: 128, ! 374: _objc_create_zone ()); ! 375: ! 376: old = NXMapGet (category_hash, cat->class_name); ! 377: new_cat = NXZoneMalloc (_objc_create_zone(), sizeof (struct _objc_unresolved_category)); ! 378: new_cat->next = old; ! 379: new_cat->cat = cat; ! 380: new_cat->version = version; ! 381: NXMapInsert (category_hash, cat->class_name , new_cat); ! 382: } ! 383: ! 384: ! 385: static void _objc_add_categories_from_image (struct header_info *hi) ! 386: { ! 387: Module mods; ! 388: unsigned int midx; ! 389: ! 390: for (mods = hi->mod_ptr, midx = 0; ! 391: midx < hi->mod_count; ! 392: midx++) { ! 393: unsigned int i, total; ! 394: ! 395: if (mods[midx].symtab == NULL) ! 396: continue; ! 397: ! 398: total = mods[midx].symtab->cls_def_cnt + ! 399: mods[midx].symtab->cat_def_cnt; ! 400: ! 401: /* add categories */ ! 402: for (i = mods[midx].symtab->cls_def_cnt; ! 403: i < total; i++) ! 404: _objc_register_category(mods[midx].symtab->defs[i], ! 405: mods[midx].version); ! 406: } ! 407: } ! 408: ! 409: static const struct header_info *_headerForClass(Class class) ! 410: { ! 411: const struct mach_header *foundHeader; ! 412: const struct segment_command *objcSeg; ! 413: unsigned int hidx; ! 414: ! 415: for (foundHeader = NULL, hidx = 0; ! 416: !foundHeader && (hidx < header_count); ! 417: hidx++) ! 418: { ! 419: unsigned long slide = header_vector[hidx].image_slide; ! 420: objcSeg = getobjcsegmentfromheader(header_vector[hidx].mhdr); ! 421: if ((objcSeg->vmaddr + slide <= (unsigned long)class) ! 422: && ((unsigned long)class < (objcSeg->vmaddr + slide + objcSeg->vmsize))) ! 423: { ! 424: return &(header_vector[hidx]); ! 425: } ! 426: } ! 427: ! 428: return 0; ! 429: } ! 430: ! 431: static const struct mach_header *_getExecHeader () ! 432: { ! 433: unsigned int hidx; ! 434: for (hidx = 0; hidx < header_count; hidx++) ! 435: if (header_vector[hidx].mhdr->filetype != MH_FVMLIB) ! 436: { ! 437: return header_vector[hidx].mhdr; ! 438: } ! 439: return NULL; ! 440: } ! 441: ! 442: /* private extern. */ ! 443: ! 444: const char *_nameForHeader(const struct mach_header *header) ! 445: { ! 446: const struct mach_header *execHeader; ! 447: const struct fvmlib_command *libCmd, *endOfCmds; ! 448: char **argv; ! 449: #if defined(__DYNAMIC__) ! 450: extern char ***_NSGetArgv(); ! 451: argv = *_NSGetArgv(); ! 452: #else ! 453: extern char **NXArgv; ! 454: argv = NXArgv; ! 455: #endif ! 456: if (header && header->filetype == MH_FVMLIB) { ! 457: execHeader = _getExecHeader(); ! 458: for (libCmd = (const struct fvmlib_command *)(execHeader + 1), ! 459: endOfCmds = ((void *)libCmd) + execHeader->sizeofcmds; ! 460: libCmd < endOfCmds; ! 461: ((void *)libCmd) += libCmd->cmdsize) { ! 462: if ((libCmd->cmd == LC_LOADFVMLIB) ! 463: && (libCmd->fvmlib.header_addr ! 464: == (unsigned long)header)) { ! 465: return (char *)libCmd ! 466: + libCmd->fvmlib.name.offset; ! 467: } ! 468: } ! 469: return NULL; ! 470: } else ! 471: return argv[0]; ! 472: } ! 473: ! 474: static void _resolveClassConflict(NXHashTable *clsHash, ! 475: Class oldClass, ! 476: Class newClass) ! 477: { ! 478: const struct header_info *oldHeader = _headerForClass(oldClass); ! 479: const struct header_info *newHeader = _headerForClass(newClass); ! 480: const char *oldName = _nameForHeader(oldHeader->mhdr); ! 481: const char *newName = _nameForHeader(newHeader->mhdr); ! 482: ! 483: _objc_inform("Both %s and %s have implementations of class %s.", ! 484: oldName, newName, oldClass->name); ! 485: if (newHeader->mhdr->filetype == MH_FVMLIB) { ! 486: NXHashInsert(clsHash, oldClass); ! 487: _objc_inform("Using implementation from %s.", oldName); ! 488: } else ! 489: _objc_inform("Using implementation from %s.", newName); ! 490: } ! 491: ! 492: static NXHashTable *_objc_init_class_hash () ! 493: { ! 494: return NXCreateHashTableFromZone(classHashPrototype, 8, nil, _objc_create_zone()); ! 495: } ! 496: ! 497: ! 498: static NXHashTable *_objc_get_classes_from_image (NXHashTable *clsHash, ! 499: struct header_info* hi) ! 500: { ! 501: unsigned int i; ! 502: Module mods; ! 503: unsigned int midx; ! 504: Class oldCls, newCls; ! 505: ! 506: for (mods = hi->mod_ptr, midx = 0; ! 507: midx < hi->mod_count; ! 508: midx++) ! 509: { ! 510: if (mods[midx].symtab == NULL) ! 511: continue; ! 512: ! 513: for (i = 0; i < mods[midx].symtab->cls_def_cnt; i++) { ! 514: oldCls = NXHashInsert(clsHash, ! 515: mods[midx].symtab->defs[i]); ! 516: if (oldCls) ! 517: { ! 518: _resolveClassConflict(clsHash, ! 519: oldCls, ! 520: mods[midx].symtab->defs[i]); ! 521: newCls = objc_lookUpClass (oldCls->name); ! 522: } ! 523: else ! 524: { ! 525: newCls = mods[midx].symtab->defs[i]; ! 526: } ! 527: ! 528: if (newCls != oldCls) ! 529: { ! 530: newCls->isa->version = mods[midx].version; ! 531: } ! 532: ! 533: _objc_resolve_categories_for_class (newCls); ! 534: } ! 535: } ! 536: ! 537: return clsHash; ! 538: } ! 539: ! 540: ! 541: #ifdef LITERAL_STRING_OBJECTS ! 542: ! 543: /* Initialize the isa pointers of all NXConstantString objects. */ ! 544: ! 545: #include <NXString.h> ! 546: ! 547: static void _objc_fixup_string_objects_for_image (struct header_info* hi) ! 548: { ! 549: NXConstantString *section; ! 550: unsigned int size; ! 551: ! 552: section = getsectdatafromheaderinfo (hi, ! 553: SEG_OBJC, "__string_object", &size); ! 554: if (section != 0 && size != 0) ! 555: { ! 556: Class constantStringClass = objc_getClass ("NXConstantString"); ! 557: unsigned int i; ! 558: ! 559: for (i = 0; i < size / sizeof (NXConstantString); i++) ! 560: *((Class *) §ion[i]) = constantStringClass; ! 561: } ! 562: } ! 563: #endif /* LITERAL_STRING_OBJECTS */ ! 564: ! 565: #ifdef OBJC_CLASS_REFS ! 566: static void _objc_map_class_refs_for_image (struct header_info* hi) ! 567: { ! 568: Class *cls_refs; ! 569: unsigned int size; ! 570: ! 571: cls_refs = (Class *) getsectdatafromheaderinfo (hi, ! 572: SEG_OBJC, ! 573: "__cls_refs", ! 574: &size); ! 575: ! 576: if (cls_refs) ! 577: { ! 578: unsigned int i; ! 579: ! 580: for (i = 0; i < size / sizeof (Class); i++) { ! 581: const char *ref = (const char *) cls_refs[i]; ! 582: Class cls = objc_lookUpClass( ref ); ! 583: cls_refs[i] = cls; ! 584: } ! 585: } ! 586: } ! 587: #endif /* OBJC_CLASS_REFS */ ! 588: ! 589: ! 590: static inline void map_selrefs (SEL *sels, unsigned int cnt) ! 591: { ! 592: unsigned int i; ! 593: ! 594: /* Overwrite the string with a unique identifier. */ ! 595: for (i = 0; i < cnt; i++) ! 596: { ! 597: SEL sel = _sel_registerName ((const char *) sels[i]); ! 598: ! 599: if (sels[i] != sel) ! 600: sels[i] = sel; ! 601: } ! 602: } ! 603: ! 604: ! 605: static inline void map_methods (struct objc_method_list *methods) ! 606: { ! 607: unsigned int i; ! 608: ! 609: for (i = 0; i < methods->method_count; i++) ! 610: { ! 611: Method method = &methods->method_list[i]; ! 612: SEL sel = _sel_registerName ((const char *) method->method_name); ! 613: ! 614: if (method->method_name != sel) ! 615: method->method_name = sel; ! 616: } ! 617: } ! 618: ! 619: ! 620: static inline void map_method_descs (struct objc_method_description_list *methods) ! 621: { ! 622: unsigned int i; ! 623: ! 624: for (i = 0; i < methods->count; i++) ! 625: { ! 626: struct objc_method_description *method = &methods->list[i]; ! 627: SEL sel = _sel_registerName ((const char *) method->name); ! 628: ! 629: if (method->name != sel) ! 630: method->name = sel; ! 631: } ! 632: } ! 633: ! 634: #import "Protocol.h" ! 635: ! 636: struct objc_protocol ! 637: { ! 638: @defs(Protocol) ! 639: }; ! 640: ! 641: @interface Protocol(RuntimePrivate) ! 642: + _fixup: (Protocol *)protos numElements: (int) nentries; ! 643: @end ! 644: ! 645: static void ! 646: _objc_fixup_protocol_objects_for_image (struct header_info* hi) ! 647: { ! 648: unsigned int size; ! 649: /* Fixup protocol objects. */ ! 650: struct objc_protocol * protos = (struct objc_protocol *) ! 651: getsectdatafromheaderinfo (hi, SEG_OBJC, "__protocol", &size); ! 652: ! 653: if (protos) ! 654: { ! 655: unsigned int i; ! 656: ! 657: for (i = 0; i < size / sizeof (Protocol); i++) { ! 658: ! 659: /* can't use map_methods, the sizes differ. */ ! 660: if (protos[i].instance_methods) ! 661: map_method_descs (protos[i].instance_methods); ! 662: if (protos[i].class_methods) ! 663: map_method_descs (protos[i].class_methods); ! 664: } ! 665: [Protocol _fixup: (Protocol *)protos numElements: size / sizeof (Protocol)]; ! 666: } ! 667: } ! 668: ! 669: ! 670: ! 671: static const struct segment_command * ! 672: getobjcsegmentfromheader(const struct mach_header *mhp) ! 673: { ! 674: struct segment_command *sgp; ! 675: unsigned long i; ! 676: ! 677: sgp = (struct segment_command *) ! 678: ((char *)mhp + sizeof(struct mach_header)); ! 679: for(i = 0; i < mhp->ncmds; i++){ ! 680: if(sgp->cmd == LC_SEGMENT) ! 681: if(strncmp(sgp->segname, "__OBJC", sizeof(sgp->segname)) == 0) ! 682: return sgp; ! 683: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 684: } ! 685: return((struct segment_command *)0); ! 686: } ! 687: ! 688: ! 689: /* Comparison function for sorting headers. Place all headers which have ! 690: freeze-dried hashtables before any which don't. Otherwise sort by ! 691: decreasing size. */ ! 692: ! 693: static int compareHeaders (const void *x1, const void *x2) ! 694: { ! 695: const struct header_info *header1 = x1, *header2 = x2; ! 696: ! 697: if (header1->frozenTable && !header2->frozenTable) ! 698: return -1; ! 699: else if (header2->frozenTable && !header1->frozenTable) ! 700: return 1; ! 701: ! 702: return (header2->objcSize - header1->objcSize); ! 703: } ! 704: ! 705: ! 706: /* Build the header vector, sorting it as _objc_map_selectors() expects. */ ! 707: ! 708: struct header_info *_objc_headerVector (const struct mach_header * const *machhdrs) ! 709: { ! 710: unsigned int hidx; ! 711: struct header_info *hdrVec; ! 712: ! 713: if (header_vector) ! 714: return header_vector; ! 715: ! 716: for (hidx = 0; machhdrs[hidx]; hidx++) ! 717: header_count++; ! 718: ! 719: hdrVec = NXZoneMalloc (_objc_create_zone(), ! 720: header_count * sizeof (struct header_info)); ! 721: if (!hdrVec) ! 722: _objc_fatal ("unable to allocate module vector"); ! 723: ! 724: for (hidx = 0; hidx < header_count; hidx++) ! 725: { ! 726: int size; ! 727: const struct segment_command *objcSeg; ! 728: ! 729: hdrVec[hidx].mhdr = machhdrs[hidx]; ! 730: hdrVec[hidx].image_slide = 0; ! 731: hdrVec[hidx].mod_ptr = (Module) getsectdatafromheader (machhdrs[hidx], ! 732: SEG_OBJC, SECT_OBJC_MODULES, &size); ! 733: hdrVec[hidx].mod_count = size / sizeof (struct objc_module); ! 734: hdrVec[hidx].frozenTable = getsectdatafromheader (machhdrs[hidx], ! 735: SEG_OBJC, "__runtime_setup", &size); ! 736: objcSeg = getobjcsegmentfromheader (machhdrs[hidx]); ! 737: if (objcSeg) ! 738: hdrVec[hidx].objcSize = objcSeg->filesize; ! 739: else ! 740: hdrVec[hidx].objcSize = 0; ! 741: } ! 742: ! 743: /* Sort the headers for _objc_map_selectors(). */ ! 744: qsort (hdrVec, header_count, sizeof (struct header_info), &compareHeaders); ! 745: ! 746: return hdrVec; ! 747: } ! 748: ! 749: ! 750: unsigned int _objc_headerCount (void) ! 751: { ! 752: return header_count; ! 753: } ! 754: ! 755: ! 756: void _objc_addHeader (const struct mach_header *header, long vmaddr_slide) ! 757: { ! 758: header_count++; ! 759: if (header_vector == 0) ! 760: header_vector = NXZoneMalloc (_objc_create_zone(), ! 761: header_count * sizeof (struct header_info)); ! 762: else ! 763: { ! 764: void *old = (void*)header_vector; ! 765: header_vector = NXZoneMalloc (_objc_create_zone(), ! 766: header_count * sizeof (struct header_info)); ! 767: ! 768: memcpy ((void*)header_vector, old, (header_count-1) * sizeof (struct header_info)); ! 769: NXZoneFree (_objc_create_zone(), old); ! 770: // header_vector = NXZoneRealloc (_objc_create_zone(), header_vector, ! 771: // header_count * sizeof (struct header_info)); ! 772: } ! 773: ! 774: header_vector[header_count - 1].mhdr = header; ! 775: header_vector[header_count - 1].mod_ptr = NULL; ! 776: header_vector[header_count - 1].mod_count = 0; ! 777: header_vector[header_count - 1].frozenTable = NULL; ! 778: header_vector[header_count - 1].image_slide = 0; ! 779: header_vector[header_count - 1].objcSize = 0; ! 780: } ! 781: ! 782: ! 783: void _objc_removeHeader (const struct mach_header *header) ! 784: { ! 785: unsigned int i, j; ! 786: ! 787: for (i = 0; i < header_count; i++) ! 788: if (header_vector[i].mhdr == header) ! 789: for (j = i; j < header_count - 1; j++) ! 790: header_vector[j] = header_vector[j + 1]; ! 791: ! 792: header_count--; ! 793: header_vector = NXZoneRealloc (_objc_create_zone(), header_vector, ! 794: header_count * sizeof (struct header_info)); ! 795: } ! 796: ! 797: ! 798: /* Register all of the selectors in each image, and fix them all up. ! 799: We must register all images which have freeze-dried hashtables before any ! 800: which don't, since the freeze-dried hashtables are searched before the ! 801: dynamic hashtable. We also want to register the freeze-dried hashtables ! 802: in decreasing order of size to minimize selector lookup time. We don't ! 803: need to fixup the selectors in the first image we register, since those ! 804: strings will always be used. If the first image has a freeze-dried ! 805: hashtable, then we don't need to run over its selectors at all, since ! 806: we can register them all at once. */ ! 807: ! 808: static void _objc_map_install_selectors (struct header_info* hi) ! 809: { ! 810: Module mods = hi->mod_ptr; ! 811: unsigned int midx; ! 812: unsigned int size; ! 813: ! 814: /* Register selectors from freeze-dried hashtables. */ ! 815: if (hi->frozenTable) ! 816: { ! 817: const char *strings = (const char *) ! 818: getsectdatafromheaderinfo (hi, ! 819: SEG_OBJC, "__meth_var_names", &size); ! 820: ! 821: if (!strings) ! 822: { ! 823: /* Try old-style strings. */ ! 824: strings = (const char *) ! 825: getsectdatafromheaderinfo (hi, ! 826: SEG_OBJC, ! 827: "__selector_strs", &size); ! 828: } ! 829: ! 830: _sel_init (hi->mhdr, ! 831: strings, ! 832: size, ! 833: hi->frozenTable); ! 834: } ! 835: } ! 836: ! 837: static void _objc_map_selectors_from_image (struct header_info* hi) ! 838: { ! 839: Module mods = hi->mod_ptr; ! 840: unsigned int midx; ! 841: unsigned int size; ! 842: SEL *messages_refs; ! 843: struct proto_template { @defs (Protocol) } *protos; ! 844: ! 845: /* Map message refs. */ ! 846: messages_refs = (SEL *) getsectdatafromheaderinfo (hi, ! 847: SEG_OBJC, ! 848: "__message_refs", ! 849: &size); ! 850: if (messages_refs) ! 851: map_selrefs (messages_refs, size / sizeof (SEL)); ! 852: ! 853: for (midx = 0; midx < hi->mod_count; midx++) ! 854: { ! 855: unsigned int i; ! 856: struct objc_method_list* mlist; ! 857: ! 858: if (mods[midx].symtab == NULL) ! 859: continue; ! 860: ! 861: /* Map class defs. */ ! 862: for (i = 0; i < mods[midx].symtab->cls_def_cnt; i++) ! 863: { ! 864: Class cls = mods[midx].symtab->defs[i]; ! 865: ! 866: if (cls->methods) ! 867: { ! 868: mlist = cls->methods; ! 869: while (mlist->method_next) mlist = mlist->method_next; ! 870: map_methods (mlist); ! 871: } ! 872: ! 873: if (cls->isa->methods) ! 874: { ! 875: mlist = cls->isa->methods; ! 876: while (mlist->method_next) mlist = mlist->method_next; ! 877: map_methods (mlist); ! 878: } ! 879: } ! 880: ! 881: /* Map category defs. */ ! 882: for (i = mods[midx].symtab->cls_def_cnt; ! 883: i < (mods[midx].symtab->cls_def_cnt + ! 884: mods[midx].symtab->cat_def_cnt); ! 885: i++) ! 886: { ! 887: Category cat = mods[midx].symtab->defs[i]; ! 888: ! 889: if (cat->instance_methods) ! 890: map_methods (cat->instance_methods); ! 891: if (cat->class_methods) ! 892: map_methods (cat->class_methods); ! 893: } ! 894: } ! 895: ! 896: /* Fixup protocols. */ ! 897: protos = (struct proto_template *) getsectdatafromheaderinfo ( hi, ! 898: SEG_OBJC, ! 899: "__protocol", ! 900: &size); ! 901: if (protos) ! 902: { ! 903: unsigned int i; ! 904: ! 905: for (i = 0; i < size / sizeof (Protocol); i++) ! 906: { ! 907: if (protos[i].instance_methods) ! 908: map_method_descs (protos[i].instance_methods); ! 909: if (protos[i].class_methods) ! 910: map_method_descs (protos[i].class_methods); ! 911: } ! 912: } ! 913: } ! 914: ! 915: #if 0 ! 916: /* ! 917: * Purpose: The idea here is to call objc_msgSend() with the ! 918: * arguments in args. The args must already be in the ! 919: * appropriate format for the stack (perhaps copied ! 920: * form some other stack frame). ! 921: * ! 922: * The final call to objc_msgSend () is thus equivalent to ! 923: * objc_msgSend (self, op, arg[0], arg[1], ..., arg[size - 1]). ! 924: * ! 925: * Assumptions: Do not compile this with -fomit-frame-pointer! ! 926: */ ! 927: id objc_msgSendv (id self, SEL sel, unsigned size, marg_list args) ! 928: { ! 929: unsigned int i; ! 930: ! 931: size -= (sizeof(id) + sizeof(SEL)); ! 932: args += (sizeof(id) + sizeof(SEL)); ! 933: ! 934: #ifdef m68k ! 935: /* Push the args onto the stack. */ ! 936: for (i = (size + 1) / sizeof (short); i > 0; i--) ! 937: asm ("movew %0,sp@-" : : "a" (((short *) args)[i-1])); ! 938: #else ! 939: panic ("objc_msgSendv"); ! 940: #endif ! 941: return objc_msgSend (self, sel); ! 942: } ! 943: #endif ! 944: ! 945: static void _objc_call_loads_for_image (struct header_info* header) ! 946: { ! 947: extern IMP class_lookupMethodInMethodList(struct objc_method_list *mlist, ! 948: SEL sel); ! 949: Class class, *pClass; ! 950: Category *pCategory; ! 951: IMP load_method; ! 952: struct objc_method_list *methods; ! 953: unsigned int nModules, nClasses, nCategories; ! 954: struct objc_module *module; ! 955: struct objc_symtab *symtab; ! 956: ! 957: for (nModules = header->mod_count, module = header->mod_ptr; ! 958: nModules; ! 959: nModules--, module++) { ! 960: ! 961: symtab = module->symtab; ! 962: if (symtab == NULL) ! 963: continue; ! 964: for (nClasses = symtab->cls_def_cnt, pClass = (Class *)symtab->defs; ! 965: nClasses; ! 966: nClasses--, pClass++) ! 967: { ! 968: class = *pClass; ! 969: ! 970: if (methods = class->isa->methods) ! 971: { ! 972: while (methods->method_next) ! 973: methods = methods->method_next; ! 974: ! 975: load_method = class_lookupMethodInMethodList(methods, ! 976: @selector(load)); ! 977: if (load_method) ! 978: (*load_method)((id)class, @selector(load)); ! 979: } ! 980: } ! 981: ! 982: for (nCategories = symtab->cat_def_cnt, ! 983: pCategory = (Category *)&symtab->defs[symtab->cls_def_cnt]; ! 984: nCategories; ! 985: nCategories--, pCategory++) ! 986: { ! 987: class = objc_getClass ((*pCategory)->class_name); ! 988: ! 989: if (methods = (*pCategory)->class_methods) ! 990: { ! 991: load_method = class_lookupMethodInMethodList(methods, ! 992: @selector(load)); ! 993: if (load_method) ! 994: (*load_method)((id)class, @selector(load)); ! 995: } ! 996: } ! 997: } ! 998: } ! 999: ! 1000: ! 1001: void objc_setMultithreaded (BOOL flag) ! 1002: { ! 1003: if (flag == YES) ! 1004: _objc_multithread_mask = 0; ! 1005: else ! 1006: _objc_multithread_mask = -1; ! 1007: } ! 1008: ! 1009: ! 1010: static void ! 1011: _objc_map_image_callback (struct header_info *h); ! 1012: ! 1013: void _objcInit (void) ! 1014: { ! 1015: int hidx; ! 1016: class_hash = _objc_init_class_hash(); ! 1017: ! 1018: { ! 1019: extern struct mach_header **getmachheaders (void); ! 1020: struct mach_header **machheaders; ! 1021: ! 1022: if ((machheaders = getmachheaders())) { ! 1023: int i = -1; ! 1024: header_vector = _objc_headerVector( machheaders ); ! 1025: while ( ++i < header_count ) ! 1026: _objc_map_install_selectors (&header_vector[i]); ! 1027: ! 1028: i = -1; ! 1029: while ( ++i < header_count ) ! 1030: _objc_map_image_callback (&header_vector[i]); ! 1031: ! 1032: free (machheaders); ! 1033: } ! 1034: ! 1035: for (hidx = 0; hidx < header_count; hidx++) ! 1036: { ! 1037: int nModules, i; ! 1038: struct objc_module* module; ! 1039: ! 1040: for (nModules = header_vector[hidx].mod_count, module = header_vector[hidx]. mod_ptr; ! 1041: nModules; ! 1042: nModules--, module++) ! 1043: { ! 1044: for (i = 0; i < module->symtab->cls_def_cnt; i++) ! 1045: { ! 1046: Class cls = (Class)module->symtab->defs[i]; ! 1047: _class_install_relationships (cls, module->version); ! 1048: } ! 1049: } ! 1050: ! 1051: #ifdef LITERAL_STRING_OBJECTS ! 1052: _objc_fixup_string_objects_for_image (&header_vector[hidx]); ! 1053: #endif /* LITERAL_STRING_OBJECTS */ ! 1054: #ifdef OBJC_CLASS_REFS ! 1055: _objc_map_class_refs_for_image (&header_vector[hidx]); ! 1056: #endif /* OBJC_CLASS_REFS */ ! 1057: } ! 1058: ! 1059: for (hidx = 0; hidx < header_count; hidx++) ! 1060: _objc_fixup_protocol_objects_for_image (&header_vector[hidx]); ! 1061: ! 1062: for (hidx = 0; hidx < header_count; hidx++) ! 1063: _objc_call_loads_for_image (&header_vector[hidx]); ! 1064: } ! 1065: } ! 1066: ! 1067: static void ! 1068: _objc_map_image_callback (struct header_info *h ) ! 1069: { ! 1070: class_hash = _objc_get_classes_from_image (class_hash, h); ! 1071: ! 1072: _objc_map_selectors_from_image (h); ! 1073: _objc_add_categories_from_image (h); ! 1074: } ! 1075: ! 1076:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.