![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to objcopt.c 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 objcopt.c 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: #include <stdio.h> ! 25: #include <stdlib.h> ! 26: #include <sys/file.h> ! 27: #include <sys/types.h> ! 28: #include <sys/stat.h> ! 29: #include <mach-o/loader.h> ! 30: #include <objc/objc-runtime.h> ! 31: #include <objc/NXString.h> ! 32: #include <sys/types.h> ! 33: #include "Protocol.h" ! 34: ! 35: /* These are in libc in later updates */ ! 36: void ! 37: swap_mach_header( ! 38: struct mach_header *mh, ! 39: enum NXByteOrder target_byte_order) ! 40: { ! 41: mh->magic = NXSwapLong(mh->magic); ! 42: mh->cputype = NXSwapLong(mh->cputype); ! 43: mh->cpusubtype = NXSwapLong(mh->cpusubtype); ! 44: mh->filetype = NXSwapLong(mh->filetype); ! 45: mh->ncmds = NXSwapLong(mh->ncmds); ! 46: mh->sizeofcmds = NXSwapLong(mh->sizeofcmds); ! 47: mh->flags = NXSwapLong(mh->flags); ! 48: } ! 49: ! 50: void ! 51: swap_load_command( ! 52: struct load_command *lc, ! 53: enum NXByteOrder target_byte_order) ! 54: { ! 55: lc->cmd = NXSwapLong(lc->cmd); ! 56: lc->cmdsize = NXSwapLong(lc->cmdsize); ! 57: } ! 58: ! 59: void ! 60: swap_segment_command( ! 61: struct segment_command *sg, ! 62: enum NXByteOrder target_byte_order) ! 63: { ! 64: /* segname[16] */ ! 65: sg->cmd = NXSwapLong(sg->cmd); ! 66: sg->cmdsize = NXSwapLong(sg->cmdsize); ! 67: sg->vmaddr = NXSwapLong(sg->vmaddr); ! 68: sg->vmsize = NXSwapLong(sg->vmsize); ! 69: sg->fileoff = NXSwapLong(sg->fileoff); ! 70: sg->filesize = NXSwapLong(sg->filesize); ! 71: sg->maxprot = NXSwapLong(sg->maxprot); ! 72: sg->initprot = NXSwapLong(sg->initprot); ! 73: sg->nsects = NXSwapLong(sg->nsects); ! 74: sg->flags = NXSwapLong(sg->flags); ! 75: } ! 76: ! 77: void ! 78: swap_section( ! 79: struct section *s, ! 80: unsigned long nsects, ! 81: enum NXByteOrder target_byte_order) ! 82: { ! 83: unsigned long i; ! 84: ! 85: for(i = 0; i < nsects; i++){ ! 86: /* sectname[16] */ ! 87: /* segname[16] */ ! 88: s[i].addr = NXSwapLong(s[i].addr); ! 89: s[i].size = NXSwapLong(s[i].size); ! 90: s[i].offset = NXSwapLong(s[i].offset); ! 91: s[i].align = NXSwapLong(s[i].align); ! 92: s[i].reloff = NXSwapLong(s[i].reloff); ! 93: s[i].nreloc = NXSwapLong(s[i].nreloc); ! 94: s[i].flags = NXSwapLong(s[i].flags); ! 95: s[i].reserved1 = NXSwapLong(s[i].reserved1); ! 96: s[i].reserved2 = NXSwapLong(s[i].reserved2); ! 97: } ! 98: } ! 99: ! 100: void ! 101: swap_symtab_command( ! 102: struct symtab_command *st, ! 103: enum NXByteOrder target_byte_order) ! 104: { ! 105: st->cmd = NXSwapLong(st->cmd); ! 106: st->cmdsize = NXSwapLong(st->cmdsize); ! 107: st->symoff = NXSwapLong(st->symoff); ! 108: st->nsyms = NXSwapLong(st->nsyms); ! 109: st->stroff = NXSwapLong(st->stroff); ! 110: st->strsize = NXSwapLong(st->strsize); ! 111: } ! 112: ! 113: void ! 114: swap_symseg_command( ! 115: struct symseg_command *ss, ! 116: enum NXByteOrder target_byte_order) ! 117: { ! 118: ss->cmd = NXSwapLong(ss->cmd); ! 119: ss->cmdsize = NXSwapLong(ss->cmdsize); ! 120: ss->offset = NXSwapLong(ss->offset); ! 121: ss->size = NXSwapLong(ss->size); ! 122: } ! 123: ! 124: /* ! 125: * For system call errors the error messages allways contains ! 126: * sys_errlist[errno] as part of the message. ! 127: */ ! 128: extern char *sys_errlist[]; ! 129: extern int errno; ! 130: ! 131: /* Name of this program for error messages (argv[0]) */ ! 132: char *progname; ! 133: ! 134: extern void _sel_writeHashTable( ! 135: int start_addr, ! 136: char *myselectorstraddr, ! 137: char *shlibselectorstraddr, ! 138: void **stuff, ! 139: int *stuffsize ! 140: ); ! 141: ! 142: /* ! 143: * Declarations for the static routines in this file. ! 144: */ ! 145: static void usage(); ! 146: ! 147: static Module get_objc( ! 148: long fd, ! 149: char *filename, ! 150: struct section *objcsects, ! 151: int nsects ! 152: ); ! 153: static void print_method_list( ! 154: struct objc_method_list *mlist_before_reloc, ! 155: struct section *firstobjcsect, ! 156: int nsects ! 157: ); ! 158: static void print_method_list2( ! 159: struct objc_method_description_list *mlist_before_reloc, ! 160: struct section *firstobjcsect, ! 161: int nsects ! 162: ); ! 163: static void getObjcSections( ! 164: struct mach_header *mh, ! 165: struct load_command *lc, ! 166: struct section **objcsects, ! 167: int *nsects ! 168: ); ! 169: static void readObjcData( ! 170: long fd, ! 171: char *filename, ! 172: struct section *objcsects, ! 173: int nsects ! 174: ); ! 175: static void swapObjcData( ! 176: struct section *objcsects, ! 177: int nsects ! 178: ); ! 179: static void swap_objc_modules( ! 180: struct objc_module *modules, ! 181: unsigned long size ! 182: ); ! 183: static void swap_objc_symtabs( ! 184: struct objc_symtab *symtabs, ! 185: unsigned long size ! 186: ); ! 187: static void swap_objc_classes( ! 188: struct objc_class *classes, ! 189: unsigned long size ! 190: ); ! 191: static void swap_objc_categories( ! 192: struct objc_category *categories, ! 193: unsigned long size ! 194: ); ! 195: static void swap_objc_method_lists( ! 196: struct objc_method_list *method_lists, ! 197: unsigned long size ! 198: ); ! 199: static void swap_objc_protocols( ! 200: Protocol *protocols, ! 201: unsigned long size ! 202: ); ! 203: static void swap_objc_ivar_lists( ! 204: struct objc_ivar_list *ivar_lists, ! 205: unsigned long size ! 206: ); ! 207: static void swap_objc_protocol_lists( ! 208: struct objc_protocol_list *protocol_lists, ! 209: unsigned long size ! 210: ); ! 211: static void swap_objc_refs( ! 212: unsigned long *refs, ! 213: unsigned long size ! 214: ); ! 215: static void swap_string_objects( ! 216: NXConstantString *s, ! 217: unsigned long size ! 218: ); ! 219: static void swap_objc_method_description_lists( ! 220: struct objc_method_description_list *mdls, ! 221: unsigned long size ! 222: ); ! 223: struct _hashEntry { ! 224: struct _hashEntry *next; ! 225: char *sel; ! 226: }; ! 227: static void swap_hashEntries( ! 228: struct _hashEntry *_hashEntries, ! 229: unsigned long size ! 230: ); ! 231: static void *getObjcData( ! 232: struct section *objcsects, ! 233: int nsects, ! 234: const void *addr ! 235: ); ! 236: static struct section *getObjcSection( ! 237: struct section *objcsects, ! 238: int nsects, ! 239: char *name ! 240: ); ! 241: ! 242: int swapped = 0; ! 243: ! 244: void ! 245: main(argc, argv) ! 246: int argc; ! 247: char *argv[]; ! 248: { ! 249: long fd; ! 250: char *filename; ! 251: struct mach_header mh; ! 252: struct load_command *lcp; ! 253: ! 254: progname = argv[0]; ! 255: ! 256: if(argc == 1) { ! 257: fprintf(stderr, "%s: At least one file must be specified\n", ! 258: progname); ! 259: usage(); ! 260: exit(1); ! 261: } ! 262: else if (argc == 2) ! 263: filename = argv[1]; ! 264: else ! 265: { ! 266: usage(); ! 267: exit(1); ! 268: } ! 269: ! 270: fd = open(filename, O_RDONLY); ! 271: if(fd < 0){ ! 272: fprintf(stderr, "%s : Can't open %s (%s)\n", progname, ! 273: filename, sys_errlist[errno]); ! 274: } ! 275: lseek(fd, 0, 0); ! 276: if(read(fd, (char *)&mh, sizeof(mh)) != sizeof(mh)){ ! 277: fprintf(stderr, "%s : Can't read mach header of %s (%s)\n", ! 278: progname, filename, sys_errlist[errno]); ! 279: return; ! 280: } ! 281: if(mh.magic == MH_MAGIC){ ! 282: if((lcp = (struct load_command *)malloc(mh.sizeofcmds)) ! 283: == (struct load_command *)0){ ! 284: fprintf(stderr, "%s : Ran out of memory (%s)\n", ! 285: progname, sys_errlist[errno]); ! 286: exit(1); ! 287: } ! 288: if(read(fd, (char *)lcp, mh.sizeofcmds) != mh.sizeofcmds){ ! 289: fprintf(stderr,"%s : Can't read load commands of %s (%s)\n", ! 290: progname, filename, sys_errlist[errno]); ! 291: lcp = (struct load_command *)0; ! 292: } ! 293: } ! 294: else if(mh.magic == NXSwapLong(MH_MAGIC)){ ! 295: if((lcp = (struct load_command *) ! 296: malloc(NXSwapLong(mh.sizeofcmds))) ! 297: == (struct load_command *)0){ ! 298: fprintf(stderr, "%s : Ran out of memory (%s)\n", ! 299: progname, sys_errlist[errno]); ! 300: exit(1); ! 301: } ! 302: if(read(fd, (char *)lcp, NXSwapLong(mh.sizeofcmds)) != ! 303: NXSwapLong(mh.sizeofcmds)){ ! 304: fprintf(stderr,"%s : Can't read load commands of %s (%s)\n", ! 305: progname, filename, sys_errlist[errno]); ! 306: lcp = (struct load_command *)0; ! 307: } ! 308: } ! 309: ! 310: { ! 311: struct section *firstobjcsect; ! 312: int nsects, size; ! 313: long vm_hashaddr; ! 314: void *table; ! 315: struct section *sel, *tmp; ! 316: char *selectors, tempfilename[] = "objcoptXXXXXX"; ! 317: ! 318: getObjcSections(&mh, lcp, &firstobjcsect, &nsects); ! 319: get_objc(fd, filename, firstobjcsect, nsects); ! 320: ! 321: if (strcmp(firstobjcsect[nsects-1].sectname, "__runtime_setup") == 0) ! 322: // we are doing a `replace' ! 323: vm_hashaddr = firstobjcsect[nsects-1].addr; ! 324: else ! 325: vm_hashaddr = round(firstobjcsect[nsects-1].addr + ! 326: firstobjcsect[nsects-1].size, sizeof(long)); ! 327: ! 328: sel = getObjcSection(firstobjcsect, nsects, "__meth_var_names"); ! 329: ! 330: tmp = getObjcSection(firstobjcsect, nsects, "__selector_strs"); ! 331: ! 332: if (sel && tmp) ! 333: { ! 334: fprintf (stderr, ! 335: "Cannot objcopt mixture of new and old strings\n"); ! 336: exit (1); ! 337: } ! 338: ! 339: if (!sel) ! 340: sel = tmp; // Use old-style strings ! 341: ! 342: selectors = (char *)sel->reserved1; ! 343: ! 344: _sel_writeHashTable(vm_hashaddr, (char *)selectors, (char *)sel->addr, ! 345: &table, &size); ! 346: if(swapped) ! 347: swap_hashEntries((struct _hashEntry *)table, size); ! 348: ! 349: mktemp(tempfilename); ! 350: add_objc_runtime_setup(filename,tempfilename,table, size); ! 351: ! 352: close(fd); ! 353: unlink(filename); ! 354: if (rename(tempfilename, filename) == -1) { ! 355: fprintf(stderr, "%s : Cannot rename temporary file from: " ! 356: "%s to %s\n", progname, tempfilename, filename); ! 357: exit(1); ! 358: } ! 359: } ! 360: ! 361: exit(0); ! 362: } ! 363: ! 364: static void getObjcSections( ! 365: struct mach_header *mh, ! 366: struct load_command *lc, ! 367: struct section **objcsects, ! 368: int *nsects ! 369: ) ! 370: { ! 371: int i,j; ! 372: struct segment_command *sg; ! 373: struct section *s; ! 374: struct load_command l, *initlc; ! 375: ! 376: swapped = mh->magic == NXSwapLong(MH_MAGIC); ! 377: if(swapped) ! 378: swap_mach_header(mh, NXHostByteOrder()); ! 379: initlc = lc; ! 380: ! 381: for(i = 0 ; i < mh->ncmds; i++){ ! 382: l = *lc; ! 383: if(swapped) ! 384: swap_load_command(&l, NXHostByteOrder()); ! 385: if(l.cmdsize % sizeof(long) != 0) ! 386: printf("load command %d size not a multiple of sizeof(long)\n", ! 387: i); ! 388: if((char *)lc + l.cmdsize > (char *)initlc + mh->sizeofcmds) ! 389: printf("load command %d extends past end of load commands\n",i); ! 390: if(l.cmd == LC_SEGMENT){ ! 391: sg = (struct segment_command *)lc; ! 392: if(swapped) ! 393: swap_segment_command(sg, NXHostByteOrder()); ! 394: if(mh->filetype == MH_OBJECT || ! 395: strcmp(sg->segname, SEG_OBJC) == 0){ ! 396: ! 397: s = (struct section *) ! 398: ((char *)sg + sizeof(struct segment_command)); ! 399: ! 400: *objcsects = s; ! 401: *nsects = sg->nsects; ! 402: ! 403: for(j = 0 ; j < sg->nsects ; j++){ ! 404: if(swapped) ! 405: swap_section(s, 1, NXHostByteOrder()); ! 406: if((char *)s + sizeof(struct section) > ! 407: (char *)initlc + mh->sizeofcmds){ ! 408: printf("section structure command extends past end " ! 409: "of load commands\n"); ! 410: } ! 411: if((char *)s + sizeof(struct section) > ! 412: (char *)initlc + mh->sizeofcmds) ! 413: break; ! 414: s++; ! 415: } ! 416: } ! 417: } ! 418: if(l.cmdsize <= 0){ ! 419: printf("load command %d size negative or zero (can't " ! 420: "advance to other load commands)\n", i); ! 421: break; ! 422: } ! 423: lc = (struct load_command *)((char *)lc + l.cmdsize); ! 424: if((char *)lc > (char *)initlc + mh->sizeofcmds) ! 425: break; ! 426: } ! 427: if((char *)initlc + mh->sizeofcmds != (char *)lc) ! 428: printf("Inconsistant mh_sizeofcmds\n"); ! 429: } ! 430: ! 431: static void readObjcData( ! 432: long fd, ! 433: char *filename, ! 434: struct section *objcsects, ! 435: int nsects ! 436: ) ! 437: { ! 438: int i; ! 439: ! 440: for (i = 0; i < nsects; i++) { ! 441: ! 442: struct section *s; ! 443: ! 444: s = objcsects + i; ! 445: ! 446: if (s->size > 0) { ! 447: if((s->reserved1 = (long)malloc(s->size)) == 0) { ! 448: fprintf(stderr, "%s : Ran out of memory (%s)\n", ! 449: progname, sys_errlist[errno]); ! 450: exit(1); ! 451: } ! 452: lseek(fd, s->offset, 0); ! 453: if((read(fd, s->reserved1, s->size)) != s->size){ ! 454: fprintf(stderr, "%s : Can't read modules of %s (%s)\n", ! 455: progname, filename, sys_errlist[errno]); ! 456: free((void *)s->reserved1); ! 457: return; ! 458: } ! 459: } ! 460: } ! 461: } ! 462: ! 463: struct objc_protocol ! 464: { ! 465: @defs(Protocol) ! 466: }; ! 467: ! 468: struct objc_string_object ! 469: { ! 470: @defs(NXConstantString) ! 471: }; ! 472: ! 473: static void swapObjcData( ! 474: struct section *objcsects, ! 475: int nsects ! 476: ) ! 477: { ! 478: int i, categories_size = 0, protocols_size = 0; ! 479: struct objc_category *categories = NULL; ! 480: struct objc_protocol *protocols = NULL; ! 481: struct section *s, *cat_inst = NULL, *cat_cls = NULL; ! 482: struct objc_method_list *method_list; ! 483: struct objc_protocol_list *protocol_list; ! 484: struct objc_method_description_list *mdl; ! 485: ! 486: for (i = 0; i < nsects; i++) { ! 487: ! 488: s = objcsects + i; ! 489: if(strncmp(s->sectname, "__class", 16) == 0 || ! 490: strncmp(s->sectname, "__meta_class", 16) == 0){ ! 491: swap_objc_classes((struct objc_class *)s->reserved1, ! 492: s->size); ! 493: } ! 494: else if(strncmp(s->sectname, "__string_object", 16) == 0){ ! 495: swap_string_objects((NXConstantString *)s->reserved1, ! 496: s->size); ! 497: } ! 498: else if(strncmp(s->sectname, "__protocol", 16) == 0){ ! 499: protocols = (struct objc_protocol *)s->reserved1; ! 500: protocols_size = s->size; ! 501: swap_objc_protocols((Protocol *)s->reserved1, ! 502: s->size); ! 503: } ! 504: else if(strncmp(s->sectname, "__cat_cls_meth", 16) == 0){ ! 505: /* handled special below */ ! 506: cat_cls = s; ! 507: } ! 508: else if(strncmp(s->sectname, "__cat_inst_meth", 16) == 0){ ! 509: /* handled special below */ ! 510: cat_inst = s; ! 511: } ! 512: else if(strncmp(s->sectname, "__cls_meth", 16) == 0 || ! 513: strncmp(s->sectname, "__inst_meth", 16) == 0){ ! 514: swap_objc_method_lists((struct objc_method_list *) ! 515: s->reserved1, s->size); ! 516: } ! 517: else if(strncmp(s->sectname, "__message_refs", 16) == 0 || ! 518: strncmp(s->sectname, "__selector_refs", 16) == 0 || ! 519: strncmp(s->sectname, "__cls_refs", 16) == 0){ ! 520: swap_objc_refs((unsigned long *)s->reserved1, s->size); ! 521: } ! 522: else if(strncmp(s->sectname, "__class_names", 16) == 0 || ! 523: strncmp(s->sectname, "__meth_var_names", 16) == 0 || ! 524: strncmp(s->sectname, "__meth_var_types", 16) == 0 || ! 525: strncmp(s->sectname, "__selector_strs", 16) == 0){ ! 526: ; /* character strings, no swapping */ ! 527: } ! 528: else if(strncmp(s->sectname, "__module_info", 16) == 0){ ! 529: swap_objc_modules((struct objc_module *)s->reserved1, ! 530: s->size); ! 531: } ! 532: else if(strncmp(s->sectname, "__symbols", 16) == 0){ ! 533: swap_objc_symtabs((struct objc_symtab *)s->reserved1, ! 534: s->size); ! 535: } ! 536: else if(strncmp(s->sectname, "__category", 16) == 0){ ! 537: categories = (struct objc_category *)s->reserved1; ! 538: categories_size = s->size; ! 539: swap_objc_categories((struct objc_category *)s->reserved1, ! 540: s->size); ! 541: } ! 542: else if(strncmp(s->sectname, "__class_vars", 16) == 0 || ! 543: strncmp(s->sectname, "__instance_vars", 16) == 0){ ! 544: swap_objc_ivar_lists((struct objc_ivar_list *)s->reserved1, ! 545: s->size); ! 546: } ! 547: else if(strncmp(s->sectname, "__runtime_setup", 16) == 0){ ! 548: ; /* do nothing it will be tossed */ ! 549: } ! 550: else if(strncmp(s->sectname, "__cstring_object", 16)) { ! 551: ; /* do nothing */ ! 552: } ! 553: else if(strncmp(s->sectname, "__sel_fixup", 16)) { ! 554: ; /* do nothing */ ! 555: } ! 556: else{ ! 557: fprintf(stderr, "%s : unknown __OBJC section: %s\n", ! 558: progname, s->sectname); ! 559: exit(1); ! 560: } ! 561: } ! 562: ! 563: for (i = 0; i < categories_size; i += sizeof(struct objc_category)){ ! 564: if(categories->instance_methods != 0){ ! 565: method_list = (struct objc_method_list *) ! 566: (cat_inst->reserved1 + ! 567: ((unsigned long)categories->instance_methods - ! 568: (unsigned long)cat_inst->addr)); ! 569: swap_objc_method_lists(method_list, ! 570: sizeof(struct objc_method_list) - ! 571: sizeof(struct objc_method)); ! 572: } ! 573: ! 574: if(categories->class_methods != 0){ ! 575: method_list = (struct objc_method_list *) ! 576: (cat_cls->reserved1 + ! 577: ((unsigned long)categories->class_methods - ! 578: (unsigned long)cat_cls->addr)); ! 579: swap_objc_method_lists(method_list, ! 580: sizeof(struct objc_method_list) - ! 581: sizeof(struct objc_method)); ! 582: } ! 583: ! 584: if(categories->protocols != 0){ ! 585: protocol_list = (struct objc_protocol_list *) ! 586: (cat_cls->reserved1 + ! 587: ((unsigned long)categories->protocols - ! 588: (unsigned long)cat_cls->addr)); ! 589: swap_objc_protocol_lists(protocol_list, ! 590: sizeof(struct objc_protocol_list) - ! 591: sizeof(struct objc_protocol *)); ! 592: } ! 593: categories++; ! 594: } ! 595: for (i = 0; i < protocols_size; i += sizeof(struct objc_protocol)){ ! 596: if(protocols->instance_methods != 0){ ! 597: mdl = (struct objc_method_description_list *) ! 598: (cat_inst->reserved1 + ! 599: ((unsigned long)protocols->instance_methods - ! 600: (unsigned long)cat_inst->addr)); ! 601: swap_objc_method_description_lists(mdl, ! 602: sizeof(struct objc_method_description_list) - ! 603: sizeof(struct objc_method_description)); ! 604: } ! 605: ! 606: if(protocols->class_methods != 0){ ! 607: mdl = (struct objc_method_description_list *) ! 608: (cat_cls->reserved1 + ! 609: ((unsigned long)protocols->class_methods - ! 610: (unsigned long)cat_cls->addr)); ! 611: swap_objc_method_description_lists(mdl, ! 612: sizeof(struct objc_method_description_list) - ! 613: sizeof(struct objc_method_description)); ! 614: } ! 615: protocols++; ! 616: } ! 617: } ! 618: ! 619: static ! 620: void ! 621: swap_objc_module( ! 622: struct objc_module *module, ! 623: enum NXByteOrder target_byte_order) ! 624: { ! 625: module->version = NXSwapLong(module->version); ! 626: module->size = NXSwapLong(module->size); ! 627: module->name = (char *) NXSwapLong((long)module->name); ! 628: module->symtab = (Symtab) NXSwapLong((long)module->symtab); ! 629: } ! 630: ! 631: static ! 632: void ! 633: swap_objc_symtab( ! 634: struct objc_symtab *symtab, ! 635: enum NXByteOrder target_byte_order) ! 636: { ! 637: symtab->sel_ref_cnt = NXSwapLong(symtab->sel_ref_cnt); ! 638: symtab->refs = (SEL *) NXSwapLong((long)symtab->refs); ! 639: symtab->cls_def_cnt = NXSwapShort(symtab->cls_def_cnt); ! 640: symtab->cat_def_cnt = NXSwapShort(symtab->cat_def_cnt); ! 641: } ! 642: ! 643: static ! 644: void ! 645: swap_objc_class( ! 646: struct objc_class *objc_class, ! 647: enum NXByteOrder target_byte_order) ! 648: { ! 649: objc_class->isa = (struct objc_class *) ! 650: NXSwapLong((long)objc_class->isa); ! 651: objc_class->super_class = (struct objc_class *) ! 652: NXSwapLong((long)objc_class->super_class); ! 653: objc_class->name = (const char *) ! 654: NXSwapLong((long)objc_class->name); ! 655: objc_class->version = ! 656: NXSwapLong(objc_class->version); ! 657: objc_class->info = ! 658: NXSwapLong(objc_class->info); ! 659: objc_class->instance_size = ! 660: NXSwapLong(objc_class->instance_size); ! 661: objc_class->ivars = (struct objc_ivar_list *) ! 662: NXSwapLong((long)objc_class->ivars); ! 663: objc_class->methods = (struct objc_method_list *) ! 664: NXSwapLong((long)objc_class->methods); ! 665: objc_class->cache = (struct objc_cache *) ! 666: NXSwapLong((long)objc_class->cache); ! 667: objc_class->protocols = (struct objc_protocol_list *) ! 668: NXSwapLong((long)objc_class->protocols); ! 669: } ! 670: ! 671: static ! 672: void ! 673: swap_objc_category( ! 674: struct objc_category *objc_category, ! 675: enum NXByteOrder target_byte_order) ! 676: { ! 677: objc_category->category_name = (char *) ! 678: NXSwapLong((long)objc_category->category_name); ! 679: objc_category->class_name = (char *) ! 680: NXSwapLong((long)objc_category->class_name); ! 681: objc_category->instance_methods = (struct objc_method_list *) ! 682: NXSwapLong((long)objc_category->instance_methods); ! 683: objc_category->class_methods = (struct objc_method_list *) ! 684: NXSwapLong((long)objc_category->class_methods); ! 685: objc_category->protocols = (struct objc_protocol_list *) ! 686: NXSwapLong((long)objc_category->protocols); ! 687: } ! 688: ! 689: static ! 690: void ! 691: swap_objc_ivar_list( ! 692: struct objc_ivar_list *objc_ivar_list, ! 693: enum NXByteOrder target_byte_order) ! 694: { ! 695: objc_ivar_list->ivar_count = NXSwapLong(objc_ivar_list->ivar_count); ! 696: } ! 697: ! 698: static ! 699: void ! 700: swap_objc_ivar( ! 701: struct objc_ivar *objc_ivar, ! 702: enum NXByteOrder target_byte_order) ! 703: { ! 704: objc_ivar->ivar_name = (char *) ! 705: NXSwapLong((long)objc_ivar->ivar_name); ! 706: objc_ivar->ivar_type = (char *) ! 707: NXSwapLong((long)objc_ivar->ivar_type); ! 708: objc_ivar->ivar_offset = ! 709: NXSwapLong(objc_ivar->ivar_offset); ! 710: } ! 711: ! 712: static ! 713: void ! 714: swap_objc_method_list( ! 715: struct objc_method_list *method_list, ! 716: enum NXByteOrder target_byte_order) ! 717: { ! 718: method_list->method_next = (struct objc_method_list *) ! 719: NXSwapLong((long)method_list->method_next); ! 720: method_list->method_count = ! 721: NXSwapLong(method_list->method_count); ! 722: } ! 723: ! 724: static ! 725: void ! 726: swap_objc_method( ! 727: struct objc_method *method, ! 728: enum NXByteOrder target_byte_order) ! 729: { ! 730: method->method_name = (SEL) ! 731: NXSwapLong((long)method->method_name); ! 732: method->method_types = (char *) ! 733: NXSwapLong((long)method->method_types); ! 734: method->method_imp = (IMP) ! 735: NXSwapLong((long)method->method_imp); ! 736: } ! 737: ! 738: static ! 739: void ! 740: swap_objc_protocol_list( ! 741: struct objc_protocol_list *protocol_list, ! 742: enum NXByteOrder target_byte_order) ! 743: { ! 744: protocol_list->next = (struct objc_protocol_list *) ! 745: NXSwapLong((long)protocol_list->next); ! 746: protocol_list->count = ! 747: NXSwapLong(protocol_list->count); ! 748: } ! 749: ! 750: static ! 751: void ! 752: swap_objc_protocol( ! 753: Protocol *p, ! 754: enum NXByteOrder target_byte_order) ! 755: { ! 756: struct objc_protocol *protocol; ! 757: ! 758: protocol = (struct objc_protocol *)p; ! 759: ! 760: protocol->isa = (struct objc_class *) ! 761: NXSwapLong((long)protocol->isa); ! 762: protocol->protocol_name = (char *) ! 763: NXSwapLong((long)protocol->protocol_name); ! 764: protocol->protocol_list = (struct objc_protocol_list *) ! 765: NXSwapLong((long)protocol->protocol_list); ! 766: protocol->instance_methods = (struct objc_method_description_list *) ! 767: NXSwapLong((long)protocol->instance_methods); ! 768: protocol->class_methods = (struct objc_method_description_list *) ! 769: NXSwapLong((long)protocol->class_methods); ! 770: ! 771: } ! 772: ! 773: static ! 774: void ! 775: swap_objc_method_description_list( ! 776: struct objc_method_description_list *mdl, ! 777: enum NXByteOrder target_byte_order) ! 778: { ! 779: mdl->count = NXSwapLong(mdl->count); ! 780: } ! 781: ! 782: static ! 783: void ! 784: swap_objc_method_description( ! 785: struct objc_method_description *md, ! 786: enum NXByteOrder target_byte_order) ! 787: { ! 788: md->name = (SEL)NXSwapLong((long)md->name); ! 789: md->types = (char *)NXSwapLong((long)md->types); ! 790: } ! 791: ! 792: void ! 793: swap_string_object( ! 794: NXConstantString *p, ! 795: enum NXByteOrder target_byte_order) ! 796: { ! 797: struct objc_string_object *string_object; ! 798: ! 799: string_object = (struct objc_string_object *)p; ! 800: ! 801: string_object->isa = (struct objc_class *) ! 802: NXSwapLong((long)string_object->isa); ! 803: string_object->characters = (char *) ! 804: NXSwapLong((long)string_object->characters); ! 805: string_object->_length = ! 806: NXSwapLong(string_object->_length); ! 807: } ! 808: ! 809: static ! 810: void ! 811: swap_hashEntry( ! 812: struct _hashEntry *_hashEntry, ! 813: enum NXByteOrder target_byte_order) ! 814: { ! 815: _hashEntry->next = (struct _hashEntry *) ! 816: NXSwapLong((long)_hashEntry->next); ! 817: _hashEntry->sel = (char *) ! 818: NXSwapLong((long)_hashEntry->sel); ! 819: } ! 820: ! 821: static void swap_objc_modules( ! 822: struct objc_module *modules, ! 823: unsigned long size ! 824: ) ! 825: { ! 826: int i, j; ! 827: ! 828: for (i = 0, j = 0; i < size; i += sizeof(struct objc_module), j++) ! 829: swap_objc_module(modules + j, NXHostByteOrder()); ! 830: } ! 831: ! 832: static void swap_objc_symtabs( ! 833: struct objc_symtab *symtabs, ! 834: unsigned long size ! 835: ) ! 836: { ! 837: int i, j; ! 838: struct objc_symtab *symtab; ! 839: ! 840: symtab = symtabs; ! 841: while ((unsigned long)symtab - (unsigned long)symtabs < size){ ! 842: swap_objc_symtab(symtab, NXHostByteOrder()); ! 843: for(j = 0; j < symtab->cls_def_cnt; j++){ ! 844: symtab->defs[j] = (struct objc_class *) ! 845: NXSwapLong((long)symtab->defs[j]); ! 846: } ! 847: for(j = 0; j < symtab->cat_def_cnt; j++){ ! 848: symtab->defs[j + symtab->cls_def_cnt] = ! 849: (struct objc_class *) ! 850: NXSwapLong((long)symtab->defs[j + symtab->cls_def_cnt]); ! 851: } ! 852: symtab = (struct objc_symtab *) ! 853: (&(symtab->defs[symtab->cls_def_cnt + ! 854: symtab->cat_def_cnt])); ! 855: } ! 856: } ! 857: ! 858: static void swap_objc_classes( ! 859: struct objc_class *classes, ! 860: unsigned long size ! 861: ) ! 862: { ! 863: int i, j; ! 864: ! 865: for (i = 0, j = 0; i < size; i += sizeof(struct objc_class), j++) ! 866: swap_objc_class(classes + j, NXHostByteOrder()); ! 867: } ! 868: ! 869: static void swap_objc_categories( ! 870: struct objc_category *categories, ! 871: unsigned long size ! 872: ) ! 873: { ! 874: int i, j; ! 875: ! 876: for (i = 0, j = 0; i < size; i += sizeof(struct objc_category), j++) ! 877: swap_objc_category(categories + j, NXHostByteOrder()); ! 878: } ! 879: ! 880: static void swap_objc_method_lists( ! 881: struct objc_method_list *method_lists, ! 882: unsigned long size ! 883: ) ! 884: { ! 885: int i, j; ! 886: struct objc_method_list *method_list; ! 887: ! 888: method_list = method_lists; ! 889: while ((unsigned long)method_list - (unsigned long)method_lists < size){ ! 890: swap_objc_method_list(method_list, NXHostByteOrder()); ! 891: for (j = 0; j < method_list->method_count; j++){ ! 892: swap_objc_method(&(method_list->method_list[j]), ! 893: NXHostByteOrder()); ! 894: } ! 895: method_list = (struct objc_method_list *) ! 896: (&(method_list->method_list[method_list->method_count])); ! 897: } ! 898: } ! 899: ! 900: static void swap_objc_protocols( ! 901: Protocol *protocols, ! 902: unsigned long size ! 903: ) ! 904: { ! 905: int i, j; ! 906: ! 907: for (i = 0, j = 0; i < size; i += sizeof(struct objc_protocol), j++) ! 908: swap_objc_protocol(protocols + j, NXHostByteOrder()); ! 909: } ! 910: ! 911: static void swap_objc_ivar_lists( ! 912: struct objc_ivar_list *ivar_lists, ! 913: unsigned long size ! 914: ) ! 915: { ! 916: int i, j; ! 917: struct objc_ivar_list *ivar_list; ! 918: ! 919: ivar_list = ivar_lists; ! 920: while ((unsigned long)ivar_list - (unsigned long)ivar_lists < size){ ! 921: swap_objc_ivar_list(ivar_list, NXHostByteOrder()); ! 922: for (j = 0; j < ivar_list->ivar_count; j++){ ! 923: swap_objc_ivar(&(ivar_list->ivar_list[j]), ! 924: NXHostByteOrder()); ! 925: } ! 926: ivar_list = (struct objc_ivar_list *) ! 927: (&(ivar_list->ivar_list[ivar_list->ivar_count])); ! 928: } ! 929: } ! 930: ! 931: static void swap_objc_protocol_lists( ! 932: struct objc_protocol_list *protocol_lists, ! 933: unsigned long size ! 934: ) ! 935: { ! 936: int i, j; ! 937: struct objc_protocol_list *protocol_list; ! 938: ! 939: protocol_list = protocol_lists; ! 940: while ((unsigned long)protocol_list - ! 941: (unsigned long)protocol_lists < size){ ! 942: swap_objc_protocol_list(protocol_list, NXHostByteOrder()); ! 943: for (j = 0; j < protocol_list->count; j++){ ! 944: protocol_list->list[j] = (Protocol *) ! 945: NXSwapLong((long)(protocol_list->list[j])); ! 946: } ! 947: protocol_list = (struct objc_protocol_list *) ! 948: (&(protocol_list->list[protocol_list->count])); ! 949: } ! 950: } ! 951: ! 952: static void swap_objc_method_description_lists( ! 953: struct objc_method_description_list *mdls, ! 954: unsigned long size ! 955: ) ! 956: { ! 957: int i, j; ! 958: struct objc_method_description_list *mdl; ! 959: ! 960: mdl = mdls; ! 961: while ((unsigned long)mdl - (unsigned long)mdls < size){ ! 962: swap_objc_method_description_list(mdl, NXHostByteOrder()); ! 963: for (j = 0; j < mdl->count; j++){ ! 964: swap_objc_method_description( &(mdl->list[j]), ! 965: NXHostByteOrder()); ! 966: } ! 967: mdl = (struct objc_method_description_list *) ! 968: (&(mdl->list[mdl->count])); ! 969: } ! 970: } ! 971: ! 972: static void *getObjcData( ! 973: struct section *objcsects, ! 974: int nsects, ! 975: const void *addr ! 976: ) ! 977: { ! 978: int i; ! 979: ! 980: if (addr == 0) ! 981: return 0; ! 982: ! 983: for (i = 0; i < nsects; i++) { ! 984: struct section *s; ! 985: ! 986: s = objcsects + i; ! 987: if (((long)addr >= s->addr) && ! 988: ((long)addr < (s->addr + s->size))) ! 989: return (void *)(s->reserved1 + ((long)addr - s->addr)); ! 990: } ! 991: fprintf(stderr, "%s : Could not `getObjcData'\n", progname); ! 992: exit(1); ! 993: } ! 994: ! 995: static void swap_objc_refs( ! 996: unsigned long *refs, ! 997: unsigned long size ! 998: ) ! 999: { ! 1000: int i,j; ! 1001: ! 1002: for (i = 0, j = 0; i < size; i += sizeof(unsigned long), j++) ! 1003: refs[j] = NXSwapLong(refs[j]); ! 1004: } ! 1005: ! 1006: static struct section *getObjcSection( ! 1007: struct section *objcsects, ! 1008: int nsects, ! 1009: char *name ! 1010: ) ! 1011: { ! 1012: int i; ! 1013: ! 1014: for (i = 0; i < nsects; i++) { ! 1015: struct section *s; ! 1016: ! 1017: s = objcsects + i; ! 1018: if (strncmp(s->sectname,name,16) == 0) ! 1019: return s; ! 1020: } ! 1021: return 0; ! 1022: } ! 1023: ! 1024: static void swap_string_objects( ! 1025: NXConstantString *s, ! 1026: unsigned long size ! 1027: ) ! 1028: { ! 1029: int i, j; ! 1030: ! 1031: for (i = 0, j = 0; i < size; i += sizeof(struct objc_string_object), j++) ! 1032: swap_string_object(s + j, NXHostByteOrder()); ! 1033: } ! 1034: ! 1035: static void swap_hashEntries( ! 1036: struct _hashEntry *_hashEntries, ! 1037: unsigned long size ! 1038: ) ! 1039: { ! 1040: int i, j; ! 1041: enum NXByteOrder target_byte_order; ! 1042: ! 1043: target_byte_order = NXHostByteOrder() == NX_BigEndian ? ! 1044: NX_LittleEndian : NX_BigEndian; ! 1045: ! 1046: for (i = 0, j = 0; i < size; i += sizeof(struct _hashEntry), j++) ! 1047: swap_hashEntry(_hashEntries + j, target_byte_order); ! 1048: } ! 1049: ! 1050: /* ! 1051: * Print the objc segment. ! 1052: */ ! 1053: static ! 1054: struct objc_module * ! 1055: get_objc(fd, filename, firstobjcsect, nsects) ! 1056: long fd; ! 1057: char *filename; ! 1058: struct section *firstobjcsect; ! 1059: int nsects; ! 1060: { ! 1061: long i, j; ! 1062: struct section *modsect, *msgsect, *selsect, *protosect; ! 1063: struct objc_module *modules, *m; ! 1064: struct objc_symtab *t; ! 1065: ! 1066: readObjcData(fd, filename, firstobjcsect, nsects); ! 1067: if(swapped) ! 1068: swapObjcData(firstobjcsect, nsects); ! 1069: ! 1070: modsect = getObjcSection(firstobjcsect, nsects, "__module_info"); ! 1071: msgsect = getObjcSection(firstobjcsect, nsects, "__message_refs"); ! 1072: if (msgsect) { ! 1073: int i, cnt = msgsect->size/sizeof(SEL); ! 1074: SEL *sels = (SEL *)msgsect->reserved1; ! 1075: ! 1076: /* overwrite the string with a unique identifier */ ! 1077: for (i = 0; i < cnt; i++) ! 1078: sels[i] = (SEL)sel_registerName( ! 1079: getObjcData(firstobjcsect, nsects, ! 1080: sels[i])); ! 1081: } ! 1082: selsect = getObjcSection(firstobjcsect, nsects, "__selector_refs"); ! 1083: if (selsect) { ! 1084: int i, cnt = selsect->size/sizeof(SEL); ! 1085: SEL *sels = (SEL *)selsect->reserved1; ! 1086: ! 1087: /* overwrite the string with a unique identifier */ ! 1088: for (i = 0; i < cnt; i++) ! 1089: sels[i] = (SEL)sel_registerName( ! 1090: getObjcData(firstobjcsect, nsects, ! 1091: sels[i])); ! 1092: } ! 1093: modules = (Module)modsect->reserved1; ! 1094: ! 1095: for(m = modules ; ! 1096: (char *)m < (char *)modules + modsect->size; ! 1097: m = (struct objc_module *)((char *)m + m->size) ){ ! 1098: ! 1099: /* relocate fields in module structure */ ! 1100: ! 1101: m->name = (char *)getObjcData(firstobjcsect, nsects, ! 1102: m->name); ! 1103: m->symtab = t = (Symtab)getObjcData(firstobjcsect, nsects, ! 1104: m->symtab); ! 1105: ! 1106: if (t) { ! 1107: ! 1108: /* Simulate map! */ ! 1109: if (m->version == 1) { ! 1110: int i, cnt = m->symtab->sel_ref_cnt; ! 1111: SEL *sels = (SEL *)getObjcData(firstobjcsect, nsects, ! 1112: m->symtab->refs); ! 1113: ! 1114: /* overwrite the string with a unique identifier */ ! 1115: for (i = 0; i < cnt; i++) ! 1116: sels[i] = (SEL)sel_registerName( ! 1117: getObjcData(firstobjcsect, nsects, ! 1118: sels[i])); ! 1119: } ! 1120: ! 1121: for(i = 0; i < t->cls_def_cnt; i++){ ! 1122: ! 1123: struct objc_class *objc_class; ! 1124: ! 1125: t->defs[i] = objc_class = ! 1126: (Class)getObjcData(firstobjcsect, nsects, ! 1127: t->defs[i]); ! 1128: print_objc_class: ! 1129: /* relocate class structure */ ! 1130: ! 1131: if(CLS_GETINFO(objc_class, CLS_META)){ ! 1132: objc_class->isa = (Class)getObjcData( ! 1133: firstobjcsect, nsects, objc_class->isa); ! 1134: } ! 1135: ! 1136: objc_class->super_class = (Class)getObjcData( ! 1137: firstobjcsect, nsects, ! 1138: objc_class->super_class); ! 1139: ! 1140: objc_class->name = (char *)getObjcData( ! 1141: firstobjcsect, nsects, ! 1142: objc_class->name); ! 1143: ! 1144: if (objc_class->ivars) { ! 1145: struct objc_ivar_list *ilist; ! 1146: struct objc_ivar *ivar; ! 1147: ! 1148: objc_class->ivars = ilist = ! 1149: (struct objc_ivar_list *)getObjcData( ! 1150: firstobjcsect, nsects, ! 1151: objc_class->ivars); ! 1152: ! 1153: ivar = ilist->ivar_list; ! 1154: for(j = 0; j < ilist->ivar_count; j++, ivar++){ ! 1155: ivar->ivar_name= (char *)getObjcData( ! 1156: firstobjcsect, nsects, ! 1157: ivar->ivar_name); ! 1158: ! 1159: ivar->ivar_type= (char *)getObjcData( ! 1160: firstobjcsect, nsects, ! 1161: ivar->ivar_type); ! 1162: } ! 1163: } ! 1164: ! 1165: if (objc_class->methods) { ! 1166: print_method_list(objc_class->methods, ! 1167: firstobjcsect, nsects); ! 1168: } ! 1169: ! 1170: if(CLS_GETINFO(objc_class, CLS_CLASS)){ ! 1171: objc_class->isa = objc_class = ! 1172: (Class)getObjcData( ! 1173: firstobjcsect, nsects, ! 1174: objc_class->isa); ! 1175: goto print_objc_class; ! 1176: } ! 1177: } ! 1178: ! 1179: for(i = 0; i < t->cat_def_cnt; i++){ ! 1180: ! 1181: struct objc_category *objc_category; ! 1182: ! 1183: t->defs[i + t->cls_def_cnt] = objc_category = ! 1184: (Category)getObjcData(firstobjcsect, nsects, ! 1185: t->defs[i+t->cls_def_cnt]); ! 1186: ! 1187: objc_category->category_name = (char *)getObjcData( ! 1188: firstobjcsect, nsects, ! 1189: objc_category->category_name); ! 1190: ! 1191: objc_category->class_name = (char *)getObjcData( ! 1192: firstobjcsect, nsects, ! 1193: objc_category->class_name); ! 1194: ! 1195: if (objc_category->instance_methods) { ! 1196: print_method_list(objc_category->instance_methods, ! 1197: firstobjcsect, nsects); ! 1198: } ! 1199: ! 1200: if (objc_category->class_methods) { ! 1201: print_method_list(objc_category->class_methods, ! 1202: firstobjcsect, nsects); ! 1203: } ! 1204: } ! 1205: } ! 1206: } ! 1207: protosect = getObjcSection(firstobjcsect, nsects, "__protocol"); ! 1208: if (protosect) { ! 1209: int i, cnt = protosect->size/sizeof(Protocol); ! 1210: struct proto_template { @defs(Protocol) } *protos; ! 1211: ! 1212: protos = (struct proto_template *) protosect->reserved1; ! 1213: ! 1214: for (i = 0; i < cnt; i++) ! 1215: { ! 1216: if (protos[i].instance_methods) { ! 1217: print_method_list2(protos[i].instance_methods, ! 1218: firstobjcsect, nsects); ! 1219: } ! 1220: ! 1221: if (protos[i].class_methods) { ! 1222: print_method_list2(protos[i].class_methods, ! 1223: firstobjcsect, nsects); ! 1224: } ! 1225: } ! 1226: } ! 1227: return modules; ! 1228: } ! 1229: ! 1230: static ! 1231: void ! 1232: print_method_list(struct objc_method_list *mlist_before_reloc, ! 1233: struct section *firstobjcsect, ! 1234: int nsects) ! 1235: { ! 1236: long i; ! 1237: struct objc_method *method; ! 1238: struct objc_method_list *mlist; ! 1239: ! 1240: mlist = (struct objc_method_list *)getObjcData(firstobjcsect, nsects, ! 1241: mlist_before_reloc); ! 1242: method = mlist->method_list; ! 1243: for(i = 0; i < mlist->method_count; i++, method++){ ! 1244: ! 1245: method->method_name = (SEL)getObjcData(firstobjcsect, nsects, ! 1246: method->method_name); ! 1247: ! 1248: method->method_types = (char *)getObjcData(firstobjcsect, nsects, ! 1249: method->method_types); ! 1250: ! 1251: method->method_name = ! 1252: (SEL)sel_registerName((STR)method->method_name); ! 1253: ! 1254: } ! 1255: } ! 1256: ! 1257: static ! 1258: void ! 1259: print_method_list2(struct objc_method_description_list *mlist_before_reloc, ! 1260: struct section *firstobjcsect, ! 1261: int nsects) ! 1262: { ! 1263: long i; ! 1264: struct objc_method_description *method; ! 1265: struct objc_method_description_list *mlist; ! 1266: ! 1267: mlist = (struct objc_method_description_list *)getObjcData(firstobjcsect, nsects, ! 1268: mlist_before_reloc); ! 1269: method = mlist->list; ! 1270: for(i = 0; i < mlist->count; i++, method++){ ! 1271: ! 1272: method->name = (SEL)getObjcData(firstobjcsect, nsects, ! 1273: method->name); ! 1274: method->name = ! 1275: (SEL)sel_registerName((STR)method->name); ! 1276: ! 1277: } ! 1278: } ! 1279: ! 1280: /* ! 1281: * Print the current usage message. ! 1282: */ ! 1283: static ! 1284: void ! 1285: usage() ! 1286: { ! 1287: fprintf(stderr, ! 1288: "Usage: %s <shlib file>\n", ! 1289: progname); ! 1290: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.