1 /* Mach-O support for BFD. 2 Copyright 1999, 2000, 2001, 2002, 2003 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21 #include "mach-o.h" 22 #include "bfd.h" 23 #include "sysdep.h" 24 #include "libbfd.h" 25 #include "libiberty.h" 26 #include <ctype.h> 27 28 #ifndef BFD_IO_FUNCS 29 #define BFD_IO_FUNCS 0 30 #endif 31 32 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive 33 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr 34 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap 35 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table 36 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table 37 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname 38 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap 39 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index 40 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt 41 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp 42 #define bfd_mach_o_close_and_cleanup _bfd_generic_close_and_cleanup 43 #define bfd_mach_o_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 44 #define bfd_mach_o_new_section_hook _bfd_generic_new_section_hook 45 #define bfd_mach_o_get_section_contents_in_window _bfd_generic_get_section_contents_in_window 46 #define bfd_mach_o_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name 47 #define bfd_mach_o_get_lineno _bfd_nosymbols_get_lineno 48 #define bfd_mach_o_find_nearest_line _bfd_nosymbols_find_nearest_line 49 #define bfd_mach_o_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol 50 #define bfd_mach_o_read_minisymbols _bfd_generic_read_minisymbols 51 #define bfd_mach_o_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 52 #define bfd_mach_o_get_reloc_upper_bound _bfd_norelocs_get_reloc_upper_bound 53 #define bfd_mach_o_canonicalize_reloc _bfd_norelocs_canonicalize_reloc 54 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 55 #define bfd_mach_o_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents 56 #define bfd_mach_o_bfd_relax_section bfd_generic_relax_section 57 #define bfd_mach_o_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 58 #define bfd_mach_o_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 59 #define bfd_mach_o_bfd_link_add_symbols _bfd_generic_link_add_symbols 60 #define bfd_mach_o_bfd_link_just_syms _bfd_generic_link_just_syms 61 #define bfd_mach_o_bfd_final_link _bfd_generic_final_link 62 #define bfd_mach_o_bfd_link_split_section _bfd_generic_link_split_section 63 #define bfd_mach_o_set_arch_mach bfd_default_set_arch_mach 64 #define bfd_mach_o_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 65 #define bfd_mach_o_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 66 #define bfd_mach_o_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 67 #define bfd_mach_o_get_section_contents _bfd_generic_get_section_contents 68 #define bfd_mach_o_set_section_contents _bfd_generic_set_section_contents 69 #define bfd_mach_o_bfd_gc_sections bfd_generic_gc_sections 70 #define bfd_mach_o_bfd_merge_sections bfd_generic_merge_sections 71 #define bfd_mach_o_bfd_discard_group bfd_generic_discard_group 72 73 static bfd_boolean bfd_mach_o_bfd_copy_private_symbol_data 74 PARAMS ((bfd *, asymbol *, bfd *, asymbol *)); 75 static bfd_boolean bfd_mach_o_bfd_copy_private_section_data 76 PARAMS ((bfd *, asection *, bfd *, asection *)); 77 static bfd_boolean bfd_mach_o_bfd_copy_private_bfd_data 78 PARAMS ((bfd *, bfd *)); 79 static long bfd_mach_o_count_symbols 80 PARAMS ((bfd *)); 81 static long bfd_mach_o_get_symtab_upper_bound 82 PARAMS ((bfd *)); 83 static long bfd_mach_o_canonicalize_symtab 84 PARAMS ((bfd *, asymbol **)); 85 static void bfd_mach_o_get_symbol_info 86 PARAMS ((bfd *, asymbol *, symbol_info *)); 87 static void bfd_mach_o_print_symbol 88 PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type)); 89 static void bfd_mach_o_convert_architecture 90 PARAMS ((bfd_mach_o_cpu_type, bfd_mach_o_cpu_subtype, 91 enum bfd_architecture *, unsigned long *)); 92 static bfd_boolean bfd_mach_o_write_contents 93 PARAMS ((bfd *)); 94 static int bfd_mach_o_sizeof_headers 95 PARAMS ((bfd *, bfd_boolean)); 96 static asymbol * bfd_mach_o_make_empty_symbol 97 PARAMS ((bfd *)); 98 static int bfd_mach_o_write_header 99 PARAMS ((bfd *, bfd_mach_o_header *)); 100 static int bfd_mach_o_read_header 101 PARAMS ((bfd *, bfd_mach_o_header *)); 102 static asection * bfd_mach_o_make_bfd_section 103 PARAMS ((bfd *, bfd_mach_o_section *)); 104 static int bfd_mach_o_scan_read_section 105 PARAMS ((bfd *, bfd_mach_o_section *, bfd_vma)); 106 static int bfd_mach_o_scan_write_section 107 PARAMS ((bfd *, bfd_mach_o_section *, bfd_vma)); 108 static int bfd_mach_o_scan_write_symtab_symbols 109 PARAMS ((bfd *, bfd_mach_o_load_command *)); 110 static int bfd_mach_o_scan_write_thread 111 PARAMS ((bfd *, bfd_mach_o_load_command *)); 112 static int bfd_mach_o_scan_read_dylinker 113 PARAMS ((bfd *, bfd_mach_o_load_command *)); 114 static int bfd_mach_o_scan_read_dylib 115 PARAMS ((bfd *, bfd_mach_o_load_command *)); 116 static int bfd_mach_o_scan_read_prebound_dylib 117 PARAMS ((bfd *, bfd_mach_o_load_command *)); 118 static int bfd_mach_o_scan_read_thread 119 PARAMS ((bfd *, bfd_mach_o_load_command *)); 120 static int bfd_mach_o_scan_write_symtab 121 PARAMS ((bfd *, bfd_mach_o_load_command *)); 122 static int bfd_mach_o_scan_read_dysymtab 123 PARAMS ((bfd *, bfd_mach_o_load_command *)); 124 static int bfd_mach_o_scan_read_symtab 125 PARAMS ((bfd *, bfd_mach_o_load_command *)); 126 static int bfd_mach_o_scan_read_segment 127 PARAMS ((bfd *, bfd_mach_o_load_command *)); 128 static int bfd_mach_o_scan_write_segment 129 PARAMS ((bfd *, bfd_mach_o_load_command *)); 130 static int bfd_mach_o_scan_read_command 131 PARAMS ((bfd *, bfd_mach_o_load_command *)); 132 static void bfd_mach_o_flatten_sections 133 PARAMS ((bfd *)); 134 static const char * bfd_mach_o_i386_flavour_string 135 PARAMS ((unsigned int)); 136 static const char * bfd_mach_o_ppc_flavour_string 137 PARAMS ((unsigned int)); 138 139 /* The flags field of a section structure is separated into two parts a section 140 type and section attributes. The section types are mutually exclusive (it 141 can only have one type) but the section attributes are not (it may have more 142 than one attribute). */ 143 144 #define SECTION_TYPE 0x000000ff /* 256 section types. */ 145 #define SECTION_ATTRIBUTES 0xffffff00 /* 24 section attributes. */ 146 147 /* Constants for the section attributes part of the flags field of a section 148 structure. */ 149 150 #define SECTION_ATTRIBUTES_USR 0xff000000 /* User-settable attributes. */ 151 #define S_ATTR_PURE_INSTRUCTIONS 0x80000000 /* Section contains only true machine instructions. */ 152 #define SECTION_ATTRIBUTES_SYS 0x00ffff00 /* System setable attributes. */ 153 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400 /* Section contains some machine instructions. */ 154 #define S_ATTR_EXT_RELOC 0x00000200 /* Section has external relocation entries. */ 155 #define S_ATTR_LOC_RELOC 0x00000100 /* Section has local relocation entries. */ 156 157 #define N_STAB 0xe0 158 #define N_TYPE 0x1e 159 #define N_EXT 0x01 160 #define N_UNDF 0x0 161 #define N_ABS 0x2 162 #define N_SECT 0xe 163 #define N_INDR 0xa 164 165 bfd_boolean 166 bfd_mach_o_valid (abfd) 167 bfd *abfd; 168 { 169 if (abfd == NULL || abfd->xvec == NULL) 170 return 0; 171 172 if (! ((abfd->xvec == &mach_o_be_vec) 173 || (abfd->xvec == &mach_o_le_vec) 174 || (abfd->xvec == &mach_o_fat_vec))) 175 return 0; 176 177 if (abfd->tdata.mach_o_data == NULL) 178 return 0; 179 return 1; 180 } 181 182 /* Copy any private info we understand from the input symbol 183 to the output symbol. */ 184 185 static bfd_boolean 186 bfd_mach_o_bfd_copy_private_symbol_data (ibfd, isymbol, obfd, osymbol) 187 bfd *ibfd ATTRIBUTE_UNUSED; 188 asymbol *isymbol ATTRIBUTE_UNUSED; 189 bfd *obfd ATTRIBUTE_UNUSED; 190 asymbol *osymbol ATTRIBUTE_UNUSED; 191 { 192 return TRUE; 193 } 194 195 /* Copy any private info we understand from the input section 196 to the output section. */ 197 198 static bfd_boolean 199 bfd_mach_o_bfd_copy_private_section_data (ibfd, isection, obfd, osection) 200 bfd *ibfd ATTRIBUTE_UNUSED; 201 asection *isection ATTRIBUTE_UNUSED; 202 bfd *obfd ATTRIBUTE_UNUSED; 203 asection *osection ATTRIBUTE_UNUSED; 204 { 205 return TRUE; 206 } 207 208 /* Copy any private info we understand from the input bfd 209 to the output bfd. */ 210 211 static bfd_boolean 212 bfd_mach_o_bfd_copy_private_bfd_data (ibfd, obfd) 213 bfd *ibfd; 214 bfd *obfd; 215 { 216 BFD_ASSERT (bfd_mach_o_valid (ibfd)); 217 BFD_ASSERT (bfd_mach_o_valid (obfd)); 218 219 obfd->tdata.mach_o_data = ibfd->tdata.mach_o_data; 220 obfd->tdata.mach_o_data->ibfd = ibfd; 221 return TRUE; 222 } 223 224 static long 225 bfd_mach_o_count_symbols (abfd) 226 bfd *abfd; 227 { 228 bfd_mach_o_data_struct *mdata = NULL; 229 long nsyms = 0; 230 unsigned long i; 231 232 BFD_ASSERT (bfd_mach_o_valid (abfd)); 233 mdata = abfd->tdata.mach_o_data; 234 235 for (i = 0; i < mdata->header.ncmds; i++) 236 if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB) 237 { 238 bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab; 239 nsyms += sym->nsyms; 240 } 241 242 return nsyms; 243 } 244 245 static long 246 bfd_mach_o_get_symtab_upper_bound (abfd) 247 bfd *abfd; 248 { 249 long nsyms = bfd_mach_o_count_symbols (abfd); 250 251 if (nsyms < 0) 252 return nsyms; 253 254 return ((nsyms + 1) * sizeof (asymbol *)); 255 } 256 257 static long 258 bfd_mach_o_canonicalize_symtab (abfd, alocation) 259 bfd *abfd; 260 asymbol **alocation; 261 { 262 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; 263 long nsyms = bfd_mach_o_count_symbols (abfd); 264 asymbol **csym = alocation; 265 unsigned long i, j; 266 267 if (nsyms < 0) 268 return nsyms; 269 270 for (i = 0; i < mdata->header.ncmds; i++) 271 { 272 if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB) 273 { 274 bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab; 275 276 if (bfd_mach_o_scan_read_symtab_symbols (abfd, &mdata->commands[i].command.symtab) != 0) 277 { 278 fprintf (stderr, "bfd_mach_o_canonicalize_symtab: unable to load symbols for section %lu\n", i); 279 return 0; 280 } 281 282 BFD_ASSERT (sym->symbols != NULL); 283 284 for (j = 0; j < sym->nsyms; j++) 285 { 286 BFD_ASSERT (csym < (alocation + nsyms)); 287 *csym++ = &sym->symbols[j]; 288 } 289 } 290 } 291 292 *csym++ = NULL; 293 294 return nsyms; 295 } 296 297 static void 298 bfd_mach_o_get_symbol_info (abfd, symbol, ret) 299 bfd *abfd ATTRIBUTE_UNUSED; 300 asymbol *symbol; 301 symbol_info *ret; 302 { 303 bfd_symbol_info (symbol, ret); 304 } 305 306 static void 307 bfd_mach_o_print_symbol (abfd, afile, symbol, how) 308 bfd *abfd; 309 PTR afile; 310 asymbol *symbol; 311 bfd_print_symbol_type how; 312 { 313 FILE *file = (FILE *) afile; 314 315 switch (how) 316 { 317 case bfd_print_symbol_name: 318 fprintf (file, "%s", symbol->name); 319 break; 320 default: 321 bfd_print_symbol_vandf (abfd, (PTR) file, symbol); 322 fprintf (file, " %-5s %s", symbol->section->name, symbol->name); 323 } 324 } 325 326 static void 327 bfd_mach_o_convert_architecture (mtype, msubtype, type, subtype) 328 bfd_mach_o_cpu_type mtype; 329 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED; 330 enum bfd_architecture *type; 331 unsigned long *subtype; 332 { 333 *subtype = bfd_arch_unknown; 334 335 switch (mtype) 336 { 337 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break; 338 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break; 339 case BFD_MACH_O_CPU_TYPE_I386: *type = bfd_arch_i386; break; 340 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break; 341 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break; 342 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break; 343 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break; 344 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break; 345 case BFD_MACH_O_CPU_TYPE_SPARC: *type = bfd_arch_sparc; break; 346 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break; 347 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break; 348 case BFD_MACH_O_CPU_TYPE_POWERPC: *type = bfd_arch_powerpc; break; 349 default: *type = bfd_arch_unknown; break; 350 } 351 352 switch (*type) 353 { 354 case bfd_arch_i386: *subtype = bfd_mach_i386_i386; break; 355 case bfd_arch_sparc: *subtype = bfd_mach_sparc; break; 356 default: 357 *subtype = bfd_arch_unknown; 358 } 359 } 360 361 static bfd_boolean 362 bfd_mach_o_write_contents (abfd) 363 bfd *abfd; 364 { 365 unsigned int i; 366 asection *s; 367 368 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; 369 370 /* Write data sections first in case they overlap header data to be 371 written later. */ 372 373 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 374 ; 375 376 #if 0 377 for (i = 0; i < mdata->header.ncmds; i++) 378 { 379 bfd_mach_o_load_command *cur = &mdata->commands[i]; 380 if (cur->type != BFD_MACH_O_LC_SEGMENT) 381 break; 382 383 { 384 bfd_mach_o_segment_command *seg = &cur->command.segment; 385 char buf[1024]; 386 bfd_vma nbytes = seg->filesize; 387 bfd_vma curoff = seg->fileoff; 388 389 while (nbytes > 0) 390 { 391 bfd_vma thisread = nbytes; 392 393 if (thisread > 1024) 394 thisread = 1024; 395 396 bfd_seek (abfd, curoff, SEEK_SET); 397 if (bfd_bread ((PTR) buf, thisread, abfd) != thisread) 398 return FALSE; 399 400 bfd_seek (abfd, curoff, SEEK_SET); 401 if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread) 402 return FALSE; 403 404 nbytes -= thisread; 405 curoff += thisread; 406 } 407 } 408 } 409 #endif 410 411 /* Now write header information. */ 412 if (bfd_mach_o_write_header (abfd, &mdata->header) != 0) 413 return FALSE; 414 415 for (i = 0; i < mdata->header.ncmds; i++) 416 { 417 unsigned char buf[8]; 418 bfd_mach_o_load_command *cur = &mdata->commands[i]; 419 unsigned long typeflag; 420 421 typeflag = cur->type_required ? cur->type & BFD_MACH_O_LC_REQ_DYLD : cur->type; 422 423 bfd_h_put_32 (abfd, typeflag, buf); 424 bfd_h_put_32 (abfd, cur->len, buf + 4); 425 426 bfd_seek (abfd, cur->offset, SEEK_SET); 427 if (bfd_bwrite ((PTR) buf, 8, abfd) != 8) 428 return FALSE; 429 430 switch (cur->type) 431 { 432 case BFD_MACH_O_LC_SEGMENT: 433 if (bfd_mach_o_scan_write_segment (abfd, cur) != 0) 434 return FALSE; 435 break; 436 case BFD_MACH_O_LC_SYMTAB: 437 if (bfd_mach_o_scan_write_symtab (abfd, cur) != 0) 438 return FALSE; 439 break; 440 case BFD_MACH_O_LC_SYMSEG: 441 break; 442 case BFD_MACH_O_LC_THREAD: 443 case BFD_MACH_O_LC_UNIXTHREAD: 444 if (bfd_mach_o_scan_write_thread (abfd, cur) != 0) 445 return FALSE; 446 break; 447 case BFD_MACH_O_LC_LOADFVMLIB: 448 case BFD_MACH_O_LC_IDFVMLIB: 449 case BFD_MACH_O_LC_IDENT: 450 case BFD_MACH_O_LC_FVMFILE: 451 case BFD_MACH_O_LC_PREPAGE: 452 case BFD_MACH_O_LC_DYSYMTAB: 453 case BFD_MACH_O_LC_LOAD_DYLIB: 454 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: 455 case BFD_MACH_O_LC_ID_DYLIB: 456 case BFD_MACH_O_LC_LOAD_DYLINKER: 457 case BFD_MACH_O_LC_ID_DYLINKER: 458 case BFD_MACH_O_LC_PREBOUND_DYLIB: 459 case BFD_MACH_O_LC_ROUTINES: 460 case BFD_MACH_O_LC_SUB_FRAMEWORK: 461 break; 462 default: 463 fprintf (stderr, 464 "unable to write unknown load command 0x%lx\n", 465 (long) cur->type); 466 return FALSE; 467 } 468 } 469 470 return TRUE; 471 } 472 473 static int 474 bfd_mach_o_sizeof_headers (a, b) 475 bfd *a ATTRIBUTE_UNUSED; 476 bfd_boolean b ATTRIBUTE_UNUSED; 477 { 478 return 0; 479 } 480 481 /* Make an empty symbol. This is required only because 482 bfd_make_section_anyway wants to create a symbol for the section. */ 483 484 static asymbol * 485 bfd_mach_o_make_empty_symbol (abfd) 486 bfd *abfd; 487 { 488 asymbol *new; 489 490 new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol)); 491 if (new == NULL) 492 return new; 493 new->the_bfd = abfd; 494 return new; 495 } 496 497 static int 498 bfd_mach_o_write_header (abfd, header) 499 bfd *abfd; 500 bfd_mach_o_header *header; 501 { 502 unsigned char buf[28]; 503 504 bfd_h_put_32 (abfd, header->magic, buf + 0); 505 bfd_h_put_32 (abfd, header->cputype, buf + 4); 506 bfd_h_put_32 (abfd, header->cpusubtype, buf + 8); 507 bfd_h_put_32 (abfd, header->filetype, buf + 12); 508 bfd_h_put_32 (abfd, header->ncmds, buf + 16); 509 bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20); 510 bfd_h_put_32 (abfd, header->flags, buf + 24); 511 512 bfd_seek (abfd, 0, SEEK_SET); 513 if (bfd_bwrite ((PTR) buf, 28, abfd) != 28) 514 return -1; 515 516 return 0; 517 } 518 519 static int 520 bfd_mach_o_read_header (abfd, header) 521 bfd *abfd; 522 bfd_mach_o_header *header; 523 { 524 unsigned char buf[28]; 525 bfd_vma (*get32) (const void *) = NULL; 526 527 bfd_seek (abfd, 0, SEEK_SET); 528 529 if (bfd_bread ((PTR) buf, 28, abfd) != 28) 530 return -1; 531 532 if (bfd_getb32 (buf) == 0xfeedface) 533 { 534 header->byteorder = BFD_ENDIAN_BIG; 535 header->magic = 0xfeedface; 536 get32 = bfd_getb32; 537 } 538 else if (bfd_getl32 (buf) == 0xfeedface) 539 { 540 header->byteorder = BFD_ENDIAN_LITTLE; 541 header->magic = 0xfeedface; 542 get32 = bfd_getl32; 543 } 544 else 545 { 546 header->byteorder = BFD_ENDIAN_UNKNOWN; 547 return -1; 548 } 549 550 header->cputype = (*get32) (buf + 4); 551 header->cpusubtype = (*get32) (buf + 8); 552 header->filetype = (*get32) (buf + 12); 553 header->ncmds = (*get32) (buf + 16); 554 header->sizeofcmds = (*get32) (buf + 20); 555 header->flags = (*get32) (buf + 24); 556 557 return 0; 558 } 559 560 static asection * 561 bfd_mach_o_make_bfd_section (abfd, section) 562 bfd *abfd; 563 bfd_mach_o_section *section; 564 { 565 asection *bfdsec; 566 char *sname; 567 const char *prefix = "LC_SEGMENT"; 568 unsigned int snamelen; 569 570 snamelen = strlen (prefix) + 1 571 + strlen (section->segname) + 1 572 + strlen (section->sectname) + 1; 573 574 sname = (char *) bfd_alloc (abfd, snamelen); 575 if (sname == NULL) 576 return NULL; 577 sprintf (sname, "%s.%s.%s", prefix, section->segname, section->sectname); 578 579 bfdsec = bfd_make_section_anyway (abfd, sname); 580 if (bfdsec == NULL) 581 return NULL; 582 583 bfdsec->vma = section->addr; 584 bfdsec->lma = section->addr; 585 bfdsec->_raw_size = section->size; 586 bfdsec->filepos = section->offset; 587 bfdsec->alignment_power = section->align; 588 589 if (section->flags & BFD_MACH_O_S_ZEROFILL) 590 bfdsec->flags = SEC_ALLOC; 591 else 592 bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE; 593 594 return bfdsec; 595 } 596 597 static int 598 bfd_mach_o_scan_read_section (abfd, section, offset) 599 bfd *abfd; 600 bfd_mach_o_section *section; 601 bfd_vma offset; 602 { 603 unsigned char buf[68]; 604 605 bfd_seek (abfd, offset, SEEK_SET); 606 if (bfd_bread ((PTR) buf, 68, abfd) != 68) 607 return -1; 608 609 memcpy (section->sectname, buf, 16); 610 section->sectname[16] = '\0'; 611 memcpy (section->segname, buf + 16, 16); 612 section->segname[16] = '\0'; 613 section->addr = bfd_h_get_32 (abfd, buf + 32); 614 section->size = bfd_h_get_32 (abfd, buf + 36); 615 section->offset = bfd_h_get_32 (abfd, buf + 40); 616 section->align = bfd_h_get_32 (abfd, buf + 44); 617 section->reloff = bfd_h_get_32 (abfd, buf + 48); 618 section->nreloc = bfd_h_get_32 (abfd, buf + 52); 619 section->flags = bfd_h_get_32 (abfd, buf + 56); 620 section->reserved1 = bfd_h_get_32 (abfd, buf + 60); 621 section->reserved2 = bfd_h_get_32 (abfd, buf + 64); 622 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section); 623 624 if (section->bfdsection == NULL) 625 return -1; 626 627 return 0; 628 } 629 630 static int 631 bfd_mach_o_scan_write_section (abfd, section, offset) 632 bfd *abfd; 633 bfd_mach_o_section *section; 634 bfd_vma offset; 635 { 636 unsigned char buf[68]; 637 638 memcpy (buf, section->sectname, 16); 639 memcpy (buf + 16, section->segname, 16); 640 bfd_h_put_32 (abfd, section->addr, buf + 32); 641 bfd_h_put_32 (abfd, section->size, buf + 36); 642 bfd_h_put_32 (abfd, section->offset, buf + 40); 643 bfd_h_put_32 (abfd, section->align, buf + 44); 644 bfd_h_put_32 (abfd, section->reloff, buf + 48); 645 bfd_h_put_32 (abfd, section->nreloc, buf + 52); 646 bfd_h_put_32 (abfd, section->flags, buf + 56); 647 /* bfd_h_put_32 (abfd, section->reserved1, buf + 60); */ 648 /* bfd_h_put_32 (abfd, section->reserved2, buf + 64); */ 649 650 bfd_seek (abfd, offset, SEEK_SET); 651 if (bfd_bwrite ((PTR) buf, 68, abfd) != 68) 652 return -1; 653 654 return 0; 655 } 656 657 static int 658 bfd_mach_o_scan_write_symtab_symbols (abfd, command) 659 bfd *abfd; 660 bfd_mach_o_load_command *command; 661 { 662 bfd_mach_o_symtab_command *sym = &command->command.symtab; 663 asymbol *s = NULL; 664 unsigned long i; 665 666 for (i = 0; i < sym->nsyms; i++) 667 { 668 unsigned char buf[12]; 669 bfd_vma symoff = sym->symoff + (i * 12); 670 unsigned char ntype = 0; 671 unsigned char nsect = 0; 672 short ndesc = 0; 673 674 s = &sym->symbols[i]; 675 676 /* Don't set this from the symbol information; use stored values. */ 677 #if 0 678 if (s->flags & BSF_GLOBAL) 679 ntype |= N_EXT; 680 if (s->flags & BSF_DEBUGGING) 681 ntype |= N_STAB; 682 683 if (s->section == bfd_und_section_ptr) 684 ntype |= N_UNDF; 685 else if (s->section == bfd_abs_section_ptr) 686 ntype |= N_ABS; 687 else 688 ntype |= N_SECT; 689 #endif 690 691 /* Instead just set from the stored values. */ 692 ntype = (s->udata.i >> 24) & 0xff; 693 nsect = (s->udata.i >> 16) & 0xff; 694 ndesc = s->udata.i & 0xffff; 695 696 bfd_h_put_32 (abfd, s->name - sym->strtab, buf); 697 bfd_h_put_8 (abfd, ntype, buf + 4); 698 bfd_h_put_8 (abfd, nsect, buf + 5); 699 bfd_h_put_16 (abfd, ndesc, buf + 6); 700 bfd_h_put_32 (abfd, s->section->vma + s->value, buf + 8); 701 702 bfd_seek (abfd, symoff, SEEK_SET); 703 if (bfd_bwrite ((PTR) buf, 12, abfd) != 12) 704 { 705 fprintf (stderr, "bfd_mach_o_scan_write_symtab_symbols: unable to write %d bytes at %lu\n", 706 12, (unsigned long) symoff); 707 return -1; 708 } 709 } 710 711 return 0; 712 } 713 714 int 715 bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, i) 716 bfd *abfd; 717 bfd_mach_o_symtab_command *sym; 718 asymbol *s; 719 unsigned long i; 720 { 721 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; 722 bfd_vma symoff = sym->symoff + (i * 12); 723 unsigned char buf[12]; 724 unsigned char type = -1; 725 unsigned char section = -1; 726 short desc = -1; 727 unsigned long value = -1; 728 unsigned long stroff = -1; 729 unsigned int symtype = -1; 730 731 BFD_ASSERT (sym->strtab != NULL); 732 733 bfd_seek (abfd, symoff, SEEK_SET); 734 if (bfd_bread ((PTR) buf, 12, abfd) != 12) 735 { 736 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n", 737 12, (unsigned long) symoff); 738 return -1; 739 } 740 741 stroff = bfd_h_get_32 (abfd, buf); 742 type = bfd_h_get_8 (abfd, buf + 4); 743 symtype = (type & 0x0e); 744 section = bfd_h_get_8 (abfd, buf + 5) - 1; 745 desc = bfd_h_get_16 (abfd, buf + 6); 746 value = bfd_h_get_32 (abfd, buf + 8); 747 748 if (stroff >= sym->strsize) 749 { 750 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n", 751 (unsigned long) stroff, (unsigned long) sym->strsize); 752 return -1; 753 } 754 755 s->the_bfd = abfd; 756 s->name = sym->strtab + stroff; 757 s->value = value; 758 s->udata.i = (type << 24) | (section << 16) | desc; 759 s->flags = 0x0; 760 761 if (type & BFD_MACH_O_N_STAB) 762 { 763 s->flags |= BSF_DEBUGGING; 764 s->section = bfd_und_section_ptr; 765 } 766 else 767 { 768 if (type & BFD_MACH_O_N_PEXT) 769 { 770 type &= ~BFD_MACH_O_N_PEXT; 771 s->flags |= BSF_GLOBAL; 772 } 773 774 if (type & BFD_MACH_O_N_EXT) 775 { 776 type &= ~BFD_MACH_O_N_EXT; 777 s->flags |= BSF_GLOBAL; 778 } 779 780 switch (symtype) 781 { 782 case BFD_MACH_O_N_UNDF: 783 s->section = bfd_und_section_ptr; 784 break; 785 case BFD_MACH_O_N_PBUD: 786 s->section = bfd_und_section_ptr; 787 break; 788 case BFD_MACH_O_N_ABS: 789 s->section = bfd_abs_section_ptr; 790 break; 791 case BFD_MACH_O_N_SECT: 792 if ((section > 0) && (section <= mdata->nsects)) 793 { 794 s->section = mdata->sections[section - 1]->bfdsection; 795 s->value = s->value - mdata->sections[section - 1]->addr; 796 } 797 else 798 { 799 /* Mach-O uses 0 to mean "no section"; not an error. */ 800 if (section != 0) 801 { 802 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: " 803 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n", 804 s->name, section, mdata->nsects); 805 } 806 s->section = bfd_und_section_ptr; 807 } 808 break; 809 case BFD_MACH_O_N_INDR: 810 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: " 811 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n", 812 s->name); 813 s->section = bfd_und_section_ptr; 814 break; 815 default: 816 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: " 817 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n", 818 s->name, symtype); 819 s->section = bfd_und_section_ptr; 820 break; 821 } 822 } 823 824 return 0; 825 } 826 827 int 828 bfd_mach_o_scan_read_symtab_strtab (abfd, sym) 829 bfd *abfd; 830 bfd_mach_o_symtab_command *sym; 831 { 832 BFD_ASSERT (sym->strtab == NULL); 833 834 if (abfd->flags & BFD_IN_MEMORY) 835 { 836 struct bfd_in_memory *b; 837 838 b = (struct bfd_in_memory *) abfd->iostream; 839 840 if ((sym->stroff + sym->strsize) > b->size) 841 { 842 bfd_set_error (bfd_error_file_truncated); 843 return -1; 844 } 845 sym->strtab = b->buffer + sym->stroff; 846 return 0; 847 } 848 849 sym->strtab = bfd_alloc (abfd, sym->strsize); 850 if (sym->strtab == NULL) 851 return -1; 852 853 bfd_seek (abfd, sym->stroff, SEEK_SET); 854 if (bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize) 855 { 856 fprintf (stderr, "bfd_mach_o_scan_read_symtab_strtab: unable to read %lu bytes at %lu\n", 857 sym->strsize, sym->stroff); 858 return -1; 859 } 860 861 return 0; 862 } 863 864 int 865 bfd_mach_o_scan_read_symtab_symbols (abfd, sym) 866 bfd *abfd; 867 bfd_mach_o_symtab_command *sym; 868 { 869 unsigned long i; 870 int ret; 871 872 BFD_ASSERT (sym->symbols == NULL); 873 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (asymbol)); 874 875 if (sym->symbols == NULL) 876 { 877 fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n"); 878 return -1; 879 } 880 881 ret = bfd_mach_o_scan_read_symtab_strtab (abfd, sym); 882 if (ret != 0) 883 return ret; 884 885 for (i = 0; i < sym->nsyms; i++) 886 { 887 ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i); 888 if (ret != 0) 889 return ret; 890 } 891 892 return 0; 893 } 894 895 int 896 bfd_mach_o_scan_read_dysymtab_symbol (abfd, dysym, sym, s, i) 897 bfd *abfd; 898 bfd_mach_o_dysymtab_command *dysym; 899 bfd_mach_o_symtab_command *sym; 900 asymbol *s; 901 unsigned long i; 902 { 903 unsigned long isymoff = dysym->indirectsymoff + (i * 4); 904 unsigned long symindex; 905 unsigned char buf[4]; 906 907 BFD_ASSERT (i < dysym->nindirectsyms); 908 909 bfd_seek (abfd, isymoff, SEEK_SET); 910 if (bfd_bread ((PTR) buf, 4, abfd) != 4) 911 { 912 fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n", 913 (unsigned long) 4, isymoff); 914 return -1; 915 } 916 symindex = bfd_h_get_32 (abfd, buf); 917 918 return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex); 919 } 920 921 static const char * 922 bfd_mach_o_i386_flavour_string (flavour) 923 unsigned int flavour; 924 { 925 switch ((int) flavour) 926 { 927 case BFD_MACH_O_i386_NEW_THREAD_STATE: return "i386_NEW_THREAD_STATE"; 928 case BFD_MACH_O_i386_FLOAT_STATE: return "i386_FLOAT_STATE"; 929 case BFD_MACH_O_i386_ISA_PORT_MAP_STATE: return "i386_ISA_PORT_MAP_STATE"; 930 case BFD_MACH_O_i386_V86_ASSIST_STATE: return "i386_V86_ASSIST_STATE"; 931 case BFD_MACH_O_i386_REGS_SEGS_STATE: return "i386_REGS_SEGS_STATE"; 932 case BFD_MACH_O_i386_THREAD_SYSCALL_STATE: return "i386_THREAD_SYSCALL_STATE"; 933 case BFD_MACH_O_i386_THREAD_STATE_NONE: return "i386_THREAD_STATE_NONE"; 934 case BFD_MACH_O_i386_SAVED_STATE: return "i386_SAVED_STATE"; 935 case BFD_MACH_O_i386_THREAD_STATE: return "i386_THREAD_STATE"; 936 case BFD_MACH_O_i386_THREAD_FPSTATE: return "i386_THREAD_FPSTATE"; 937 case BFD_MACH_O_i386_THREAD_EXCEPTSTATE: return "i386_THREAD_EXCEPTSTATE"; 938 case BFD_MACH_O_i386_THREAD_CTHREADSTATE: return "i386_THREAD_CTHREADSTATE"; 939 default: return "UNKNOWN"; 940 } 941 } 942 943 static const char * 944 bfd_mach_o_ppc_flavour_string (flavour) 945 unsigned int flavour; 946 { 947 switch ((int) flavour) 948 { 949 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE"; 950 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE"; 951 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE"; 952 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE"; 953 default: return "UNKNOWN"; 954 } 955 } 956 957 static int 958 bfd_mach_o_scan_write_thread (abfd, command) 959 bfd *abfd; 960 bfd_mach_o_load_command *command; 961 { 962 bfd_mach_o_thread_command *cmd = &command->command.thread; 963 unsigned int i; 964 unsigned char buf[8]; 965 bfd_vma offset; 966 unsigned int nflavours; 967 968 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD) 969 || (command->type == BFD_MACH_O_LC_UNIXTHREAD)); 970 971 offset = 8; 972 nflavours = 0; 973 for (i = 0; i < cmd->nflavours; i++) 974 { 975 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0); 976 BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8)); 977 978 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf); 979 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4); 980 981 bfd_seek (abfd, command->offset + offset, SEEK_SET); 982 if (bfd_bwrite ((PTR) buf, 8, abfd) != 8) 983 return -1; 984 985 offset += cmd->flavours[i].size + 8; 986 } 987 988 return 0; 989 } 990 991 static int 992 bfd_mach_o_scan_read_dylinker (abfd, command) 993 bfd *abfd; 994 bfd_mach_o_load_command *command; 995 { 996 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker; 997 unsigned char buf[4]; 998 unsigned int nameoff; 999 asection *bfdsec; 1000 char *sname; 1001 const char *prefix; 1002 1003 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER) 1004 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)); 1005 1006 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1007 if (bfd_bread ((PTR) buf, 4, abfd) != 4) 1008 return -1; 1009 1010 nameoff = bfd_h_get_32 (abfd, buf + 0); 1011 1012 cmd->name_offset = command->offset + nameoff; 1013 cmd->name_len = command->len - nameoff; 1014 1015 if (command->type == BFD_MACH_O_LC_LOAD_DYLINKER) 1016 prefix = "LC_LOAD_DYLINKER"; 1017 else if (command->type == BFD_MACH_O_LC_ID_DYLINKER) 1018 prefix = "LC_ID_DYLINKER"; 1019 else 1020 abort (); 1021 1022 sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); 1023 if (sname == NULL) 1024 return -1; 1025 strcpy (sname, prefix); 1026 1027 bfdsec = bfd_make_section_anyway (abfd, sname); 1028 if (bfdsec == NULL) 1029 return -1; 1030 1031 bfdsec->vma = 0; 1032 bfdsec->lma = 0; 1033 bfdsec->_raw_size = command->len - 8; 1034 bfdsec->filepos = command->offset + 8; 1035 bfdsec->alignment_power = 0; 1036 bfdsec->flags = SEC_HAS_CONTENTS; 1037 1038 cmd->section = bfdsec; 1039 1040 return 0; 1041 } 1042 1043 static int 1044 bfd_mach_o_scan_read_dylib (abfd, command) 1045 bfd *abfd; 1046 bfd_mach_o_load_command *command; 1047 { 1048 bfd_mach_o_dylib_command *cmd = &command->command.dylib; 1049 unsigned char buf[16]; 1050 unsigned int nameoff; 1051 asection *bfdsec; 1052 char *sname; 1053 const char *prefix; 1054 1055 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLIB) 1056 || (command->type == BFD_MACH_O_LC_LOAD_DYLIB) 1057 || (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB)); 1058 1059 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1060 if (bfd_bread ((PTR) buf, 16, abfd) != 16) 1061 return -1; 1062 1063 nameoff = bfd_h_get_32 (abfd, buf + 0); 1064 cmd->timestamp = bfd_h_get_32 (abfd, buf + 4); 1065 cmd->current_version = bfd_h_get_32 (abfd, buf + 8); 1066 cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12); 1067 1068 cmd->name_offset = command->offset + nameoff; 1069 cmd->name_len = command->len - nameoff; 1070 1071 if (command->type == BFD_MACH_O_LC_LOAD_DYLIB) 1072 prefix = "LC_LOAD_DYLIB"; 1073 else if (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB) 1074 prefix = "LC_LOAD_WEAK_DYLIB"; 1075 else if (command->type == BFD_MACH_O_LC_ID_DYLIB) 1076 prefix = "LC_ID_DYLIB"; 1077 else 1078 abort (); 1079 1080 sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); 1081 if (sname == NULL) 1082 return -1; 1083 strcpy (sname, prefix); 1084 1085 bfdsec = bfd_make_section_anyway (abfd, sname); 1086 if (bfdsec == NULL) 1087 return -1; 1088 1089 bfdsec->vma = 0; 1090 bfdsec->lma = 0; 1091 bfdsec->_raw_size = command->len - 8; 1092 bfdsec->filepos = command->offset + 8; 1093 bfdsec->alignment_power = 0; 1094 bfdsec->flags = SEC_HAS_CONTENTS; 1095 1096 cmd->section = bfdsec; 1097 1098 return 0; 1099 } 1100 1101 static int 1102 bfd_mach_o_scan_read_prebound_dylib (abfd, command) 1103 bfd *abfd ATTRIBUTE_UNUSED; 1104 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED; 1105 { 1106 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */ 1107 1108 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB); 1109 return 0; 1110 } 1111 1112 static int 1113 bfd_mach_o_scan_read_thread (abfd, command) 1114 bfd *abfd; 1115 bfd_mach_o_load_command *command; 1116 { 1117 bfd_mach_o_data_struct *mdata = NULL; 1118 bfd_mach_o_thread_command *cmd = &command->command.thread; 1119 unsigned char buf[8]; 1120 bfd_vma offset; 1121 unsigned int nflavours; 1122 unsigned int i; 1123 1124 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD) 1125 || (command->type == BFD_MACH_O_LC_UNIXTHREAD)); 1126 1127 BFD_ASSERT (bfd_mach_o_valid (abfd)); 1128 mdata = abfd->tdata.mach_o_data; 1129 1130 offset = 8; 1131 nflavours = 0; 1132 while (offset != command->len) 1133 { 1134 if (offset >= command->len) 1135 return -1; 1136 1137 bfd_seek (abfd, command->offset + offset, SEEK_SET); 1138 1139 if (bfd_bread ((PTR) buf, 8, abfd) != 8) 1140 return -1; 1141 1142 offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4; 1143 nflavours++; 1144 } 1145 1146 cmd->flavours = 1147 ((bfd_mach_o_thread_flavour *) 1148 bfd_alloc (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour))); 1149 if (cmd->flavours == NULL) 1150 return -1; 1151 cmd->nflavours = nflavours; 1152 1153 offset = 8; 1154 nflavours = 0; 1155 while (offset != command->len) 1156 { 1157 if (offset >= command->len) 1158 return -1; 1159 1160 if (nflavours >= cmd->nflavours) 1161 return -1; 1162 1163 bfd_seek (abfd, command->offset + offset, SEEK_SET); 1164 1165 if (bfd_bread ((PTR) buf, 8, abfd) != 8) 1166 return -1; 1167 1168 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf); 1169 cmd->flavours[nflavours].offset = command->offset + offset + 8; 1170 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4; 1171 offset += cmd->flavours[nflavours].size + 8; 1172 nflavours++; 1173 } 1174 1175 for (i = 0; i < nflavours; i++) 1176 { 1177 asection *bfdsec; 1178 unsigned int snamelen; 1179 char *sname; 1180 const char *flavourstr; 1181 const char *prefix = "LC_THREAD"; 1182 unsigned int j = 0; 1183 1184 switch (mdata->header.cputype) 1185 { 1186 case BFD_MACH_O_CPU_TYPE_POWERPC: 1187 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour); 1188 break; 1189 case BFD_MACH_O_CPU_TYPE_I386: 1190 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour); 1191 break; 1192 default: 1193 flavourstr = "UNKNOWN_ARCHITECTURE"; 1194 break; 1195 } 1196 1197 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1; 1198 sname = (char *) bfd_alloc (abfd, snamelen); 1199 if (sname == NULL) 1200 return -1; 1201 1202 for (;;) 1203 { 1204 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j); 1205 if (bfd_get_section_by_name (abfd, sname) == NULL) 1206 break; 1207 j++; 1208 } 1209 1210 bfdsec = bfd_make_section (abfd, sname); 1211 1212 bfdsec->vma = 0; 1213 bfdsec->lma = 0; 1214 bfdsec->_raw_size = cmd->flavours[i].size; 1215 bfdsec->filepos = cmd->flavours[i].offset; 1216 bfdsec->alignment_power = 0x0; 1217 bfdsec->flags = SEC_HAS_CONTENTS; 1218 1219 cmd->section = bfdsec; 1220 } 1221 1222 return 0; 1223 } 1224 1225 static int 1226 bfd_mach_o_scan_write_symtab (abfd, command) 1227 bfd *abfd; 1228 bfd_mach_o_load_command *command; 1229 { 1230 bfd_mach_o_symtab_command *seg = &command->command.symtab; 1231 unsigned char buf[16]; 1232 1233 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB); 1234 1235 bfd_h_put_32 (abfd, seg->symoff, buf); 1236 bfd_h_put_32 (abfd, seg->nsyms, buf + 4); 1237 bfd_h_put_32 (abfd, seg->stroff, buf + 8); 1238 bfd_h_put_32 (abfd, seg->strsize, buf + 12); 1239 1240 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1241 if (bfd_bwrite ((PTR) buf, 16, abfd) != 16) 1242 return -1; 1243 1244 if (bfd_mach_o_scan_write_symtab_symbols (abfd, command) != 0) 1245 return -1; 1246 1247 return 0; 1248 } 1249 1250 static int 1251 bfd_mach_o_scan_read_dysymtab (abfd, command) 1252 bfd *abfd; 1253 bfd_mach_o_load_command *command; 1254 { 1255 bfd_mach_o_dysymtab_command *seg = &command->command.dysymtab; 1256 unsigned char buf[72]; 1257 1258 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB); 1259 1260 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1261 if (bfd_bread ((PTR) buf, 72, abfd) != 72) 1262 return -1; 1263 1264 seg->ilocalsym = bfd_h_get_32 (abfd, buf + 0); 1265 seg->nlocalsym = bfd_h_get_32 (abfd, buf + 4); 1266 seg->iextdefsym = bfd_h_get_32 (abfd, buf + 8); 1267 seg->nextdefsym = bfd_h_get_32 (abfd, buf + 12); 1268 seg->iundefsym = bfd_h_get_32 (abfd, buf + 16); 1269 seg->nundefsym = bfd_h_get_32 (abfd, buf + 20); 1270 seg->tocoff = bfd_h_get_32 (abfd, buf + 24); 1271 seg->ntoc = bfd_h_get_32 (abfd, buf + 28); 1272 seg->modtaboff = bfd_h_get_32 (abfd, buf + 32); 1273 seg->nmodtab = bfd_h_get_32 (abfd, buf + 36); 1274 seg->extrefsymoff = bfd_h_get_32 (abfd, buf + 40); 1275 seg->nextrefsyms = bfd_h_get_32 (abfd, buf + 44); 1276 seg->indirectsymoff = bfd_h_get_32 (abfd, buf + 48); 1277 seg->nindirectsyms = bfd_h_get_32 (abfd, buf + 52); 1278 seg->extreloff = bfd_h_get_32 (abfd, buf + 56); 1279 seg->nextrel = bfd_h_get_32 (abfd, buf + 60); 1280 seg->locreloff = bfd_h_get_32 (abfd, buf + 64); 1281 seg->nlocrel = bfd_h_get_32 (abfd, buf + 68); 1282 1283 return 0; 1284 } 1285 1286 static int 1287 bfd_mach_o_scan_read_symtab (abfd, command) 1288 bfd *abfd; 1289 bfd_mach_o_load_command *command; 1290 { 1291 bfd_mach_o_symtab_command *seg = &command->command.symtab; 1292 unsigned char buf[16]; 1293 asection *bfdsec; 1294 char *sname; 1295 const char *prefix = "LC_SYMTAB.stabs"; 1296 1297 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB); 1298 1299 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1300 if (bfd_bread ((PTR) buf, 16, abfd) != 16) 1301 return -1; 1302 1303 seg->symoff = bfd_h_get_32 (abfd, buf); 1304 seg->nsyms = bfd_h_get_32 (abfd, buf + 4); 1305 seg->stroff = bfd_h_get_32 (abfd, buf + 8); 1306 seg->strsize = bfd_h_get_32 (abfd, buf + 12); 1307 seg->symbols = NULL; 1308 seg->strtab = NULL; 1309 1310 sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); 1311 if (sname == NULL) 1312 return -1; 1313 strcpy (sname, prefix); 1314 1315 bfdsec = bfd_make_section_anyway (abfd, sname); 1316 if (bfdsec == NULL) 1317 return -1; 1318 1319 bfdsec->vma = 0; 1320 bfdsec->lma = 0; 1321 bfdsec->_raw_size = seg->nsyms * 12; 1322 bfdsec->filepos = seg->symoff; 1323 bfdsec->alignment_power = 0; 1324 bfdsec->flags = SEC_HAS_CONTENTS; 1325 1326 seg->stabs_segment = bfdsec; 1327 1328 prefix = "LC_SYMTAB.stabstr"; 1329 sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1); 1330 if (sname == NULL) 1331 return -1; 1332 strcpy (sname, prefix); 1333 1334 bfdsec = bfd_make_section_anyway (abfd, sname); 1335 if (bfdsec == NULL) 1336 return -1; 1337 1338 bfdsec->vma = 0; 1339 bfdsec->lma = 0; 1340 bfdsec->_raw_size = seg->strsize; 1341 bfdsec->filepos = seg->stroff; 1342 bfdsec->alignment_power = 0; 1343 bfdsec->flags = SEC_HAS_CONTENTS; 1344 1345 seg->stabstr_segment = bfdsec; 1346 1347 return 0; 1348 } 1349 1350 static int 1351 bfd_mach_o_scan_read_segment (abfd, command) 1352 bfd *abfd; 1353 bfd_mach_o_load_command *command; 1354 { 1355 unsigned char buf[48]; 1356 bfd_mach_o_segment_command *seg = &command->command.segment; 1357 unsigned long i; 1358 asection *bfdsec; 1359 char *sname; 1360 const char *prefix = "LC_SEGMENT"; 1361 unsigned int snamelen; 1362 1363 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT); 1364 1365 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1366 if (bfd_bread ((PTR) buf, 48, abfd) != 48) 1367 return -1; 1368 1369 memcpy (seg->segname, buf, 16); 1370 seg->vmaddr = bfd_h_get_32 (abfd, buf + 16); 1371 seg->vmsize = bfd_h_get_32 (abfd, buf + 20); 1372 seg->fileoff = bfd_h_get_32 (abfd, buf + 24); 1373 seg->filesize = bfd_h_get_32 (abfd, buf + 28); 1374 /* seg->maxprot = bfd_h_get_32 (abfd, buf + 32); */ 1375 /* seg->initprot = bfd_h_get_32 (abfd, buf + 36); */ 1376 seg->nsects = bfd_h_get_32 (abfd, buf + 40); 1377 seg->flags = bfd_h_get_32 (abfd, buf + 44); 1378 1379 snamelen = strlen (prefix) + 1 + strlen (seg->segname) + 1; 1380 sname = (char *) bfd_alloc (abfd, snamelen); 1381 if (sname == NULL) 1382 return -1; 1383 sprintf (sname, "%s.%s", prefix, seg->segname); 1384 1385 bfdsec = bfd_make_section_anyway (abfd, sname); 1386 if (bfdsec == NULL) 1387 return -1; 1388 1389 bfdsec->vma = seg->vmaddr; 1390 bfdsec->lma = seg->vmaddr; 1391 bfdsec->_raw_size = seg->filesize; 1392 bfdsec->filepos = seg->fileoff; 1393 bfdsec->alignment_power = 0x0; 1394 bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE; 1395 1396 seg->segment = bfdsec; 1397 1398 if (seg->nsects != 0) 1399 { 1400 seg->sections = 1401 ((bfd_mach_o_section *) 1402 bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section))); 1403 if (seg->sections == NULL) 1404 return -1; 1405 1406 for (i = 0; i < seg->nsects; i++) 1407 { 1408 bfd_vma segoff = command->offset + 48 + 8 + (i * 68); 1409 1410 if (bfd_mach_o_scan_read_section (abfd, &seg->sections[i], 1411 segoff) != 0) 1412 return -1; 1413 } 1414 } 1415 1416 return 0; 1417 } 1418 1419 static int 1420 bfd_mach_o_scan_write_segment (abfd, command) 1421 bfd *abfd; 1422 bfd_mach_o_load_command *command; 1423 { 1424 unsigned char buf[48]; 1425 bfd_mach_o_segment_command *seg = &command->command.segment; 1426 unsigned long i; 1427 1428 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT); 1429 1430 memcpy (buf, seg->segname, 16); 1431 bfd_h_put_32 (abfd, seg->vmaddr, buf + 16); 1432 bfd_h_put_32 (abfd, seg->vmsize, buf + 20); 1433 bfd_h_put_32 (abfd, seg->fileoff, buf + 24); 1434 bfd_h_put_32 (abfd, seg->filesize, buf + 28); 1435 bfd_h_put_32 (abfd, 0 /* seg->maxprot */, buf + 32); 1436 bfd_h_put_32 (abfd, 0 /* seg->initprot */, buf + 36); 1437 bfd_h_put_32 (abfd, seg->nsects, buf + 40); 1438 bfd_h_put_32 (abfd, seg->flags, buf + 44); 1439 1440 bfd_seek (abfd, command->offset + 8, SEEK_SET); 1441 if (bfd_bwrite ((PTR) buf, 48, abfd) != 48) 1442 return -1; 1443 1444 { 1445 char buf[1024]; 1446 bfd_vma nbytes = seg->filesize; 1447 bfd_vma curoff = seg->fileoff; 1448 1449 while (nbytes > 0) 1450 { 1451 bfd_vma thisread = nbytes; 1452 1453 if (thisread > 1024) 1454 thisread = 1024; 1455 1456 bfd_seek (abfd, curoff, SEEK_SET); 1457 if (bfd_bread ((PTR) buf, thisread, abfd) != thisread) 1458 return -1; 1459 1460 bfd_seek (abfd, curoff, SEEK_SET); 1461 if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread) 1462 return -1; 1463 1464 nbytes -= thisread; 1465 curoff += thisread; 1466 } 1467 } 1468 1469 for (i = 0; i < seg->nsects; i++) 1470 { 1471 bfd_vma segoff = command->offset + 48 + 8 + (i * 68); 1472 1473 if (bfd_mach_o_scan_write_section (abfd, &seg->sections[i], segoff) != 0) 1474 return -1; 1475 } 1476 1477 return 0; 1478 } 1479 1480 static int 1481 bfd_mach_o_scan_read_command (abfd, command) 1482 bfd *abfd; 1483 bfd_mach_o_load_command *command; 1484 { 1485 unsigned char buf[8]; 1486 1487 bfd_seek (abfd, command->offset, SEEK_SET); 1488 if (bfd_bread ((PTR) buf, 8, abfd) != 8) 1489 return -1; 1490 1491 command->type = (bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD); 1492 command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD 1493 ? 1 : 0); 1494 command->len = bfd_h_get_32 (abfd, buf + 4); 1495 1496 switch (command->type) 1497 { 1498 case BFD_MACH_O_LC_SEGMENT: 1499 if (bfd_mach_o_scan_read_segment (abfd, command) != 0) 1500 return -1; 1501 break; 1502 case BFD_MACH_O_LC_SYMTAB: 1503 if (bfd_mach_o_scan_read_symtab (abfd, command) != 0) 1504 return -1; 1505 break; 1506 case BFD_MACH_O_LC_SYMSEG: 1507 break; 1508 case BFD_MACH_O_LC_THREAD: 1509 case BFD_MACH_O_LC_UNIXTHREAD: 1510 if (bfd_mach_o_scan_read_thread (abfd, command) != 0) 1511 return -1; 1512 break; 1513 case BFD_MACH_O_LC_LOAD_DYLINKER: 1514 case BFD_MACH_O_LC_ID_DYLINKER: 1515 if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0) 1516 return -1; 1517 break; 1518 case BFD_MACH_O_LC_LOAD_DYLIB: 1519 case BFD_MACH_O_LC_ID_DYLIB: 1520 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: 1521 if (bfd_mach_o_scan_read_dylib (abfd, command) != 0) 1522 return -1; 1523 break; 1524 case BFD_MACH_O_LC_PREBOUND_DYLIB: 1525 if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0) 1526 return -1; 1527 break; 1528 case BFD_MACH_O_LC_LOADFVMLIB: 1529 case BFD_MACH_O_LC_IDFVMLIB: 1530 case BFD_MACH_O_LC_IDENT: 1531 case BFD_MACH_O_LC_FVMFILE: 1532 case BFD_MACH_O_LC_PREPAGE: 1533 case BFD_MACH_O_LC_ROUTINES: 1534 case BFD_MACH_O_LC_SUB_FRAMEWORK: 1535 break; 1536 case BFD_MACH_O_LC_DYSYMTAB: 1537 if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0) 1538 return -1; 1539 break; 1540 case BFD_MACH_O_LC_SUB_UMBRELLA: 1541 case BFD_MACH_O_LC_SUB_CLIENT: 1542 case BFD_MACH_O_LC_SUB_LIBRARY: 1543 case BFD_MACH_O_LC_TWOLEVEL_HINTS: 1544 case BFD_MACH_O_LC_PREBIND_CKSUM: 1545 break; 1546 default: 1547 fprintf (stderr, "unable to read unknown load command 0x%lx\n", 1548 (unsigned long) command->type); 1549 break; 1550 } 1551 1552 return 0; 1553 } 1554 1555 static void 1556 bfd_mach_o_flatten_sections (abfd) 1557 bfd *abfd; 1558 { 1559 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; 1560 long csect = 0; 1561 unsigned long i, j; 1562 1563 mdata->nsects = 0; 1564 1565 for (i = 0; i < mdata->header.ncmds; i++) 1566 { 1567 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT) 1568 { 1569 bfd_mach_o_segment_command *seg; 1570 1571 seg = &mdata->commands[i].command.segment; 1572 mdata->nsects += seg->nsects; 1573 } 1574 } 1575 1576 mdata->sections = bfd_alloc (abfd, 1577 mdata->nsects * sizeof (bfd_mach_o_section *)); 1578 csect = 0; 1579 1580 for (i = 0; i < mdata->header.ncmds; i++) 1581 { 1582 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT) 1583 { 1584 bfd_mach_o_segment_command *seg; 1585 1586 seg = &mdata->commands[i].command.segment; 1587 BFD_ASSERT (csect + seg->nsects <= mdata->nsects); 1588 1589 for (j = 0; j < seg->nsects; j++) 1590 mdata->sections[csect++] = &seg->sections[j]; 1591 } 1592 } 1593 } 1594 1595 int 1596 bfd_mach_o_scan_start_address (abfd) 1597 bfd *abfd; 1598 { 1599 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; 1600 bfd_mach_o_thread_command *cmd = NULL; 1601 unsigned long i; 1602 1603 for (i = 0; i < mdata->header.ncmds; i++) 1604 { 1605 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) || 1606 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD)) 1607 { 1608 if (cmd == NULL) 1609 cmd = &mdata->commands[i].command.thread; 1610 else 1611 return 0; 1612 } 1613 } 1614 1615 if (cmd == NULL) 1616 return 0; 1617 1618 for (i = 0; i < cmd->nflavours; i++) 1619 { 1620 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386) 1621 && (cmd->flavours[i].flavour 1622 == (unsigned long) BFD_MACH_O_i386_THREAD_STATE)) 1623 { 1624 unsigned char buf[4]; 1625 1626 bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET); 1627 1628 if (bfd_bread (buf, 4, abfd) != 4) 1629 return -1; 1630 1631 abfd->start_address = bfd_h_get_32 (abfd, buf); 1632 } 1633 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC) 1634 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE)) 1635 { 1636 unsigned char buf[4]; 1637 1638 bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET); 1639 1640 if (bfd_bread (buf, 4, abfd) != 4) 1641 return -1; 1642 1643 abfd->start_address = bfd_h_get_32 (abfd, buf); 1644 } 1645 } 1646 1647 return 0; 1648 } 1649 1650 int 1651 bfd_mach_o_scan (abfd, header, mdata) 1652 bfd *abfd; 1653 bfd_mach_o_header *header; 1654 bfd_mach_o_data_struct *mdata; 1655 { 1656 unsigned int i; 1657 enum bfd_architecture cputype; 1658 unsigned long cpusubtype; 1659 1660 mdata->header = *header; 1661 mdata->symbols = NULL; 1662 1663 abfd->flags = (abfd->xvec->object_flags 1664 | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS))); 1665 abfd->tdata.mach_o_data = mdata; 1666 1667 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype, 1668 &cputype, &cpusubtype); 1669 if (cputype == bfd_arch_unknown) 1670 { 1671 fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n", 1672 header->cputype, header->cpusubtype); 1673 return -1; 1674 } 1675 1676 bfd_set_arch_mach (abfd, cputype, cpusubtype); 1677 1678 if (header->ncmds != 0) 1679 { 1680 mdata->commands = 1681 ((bfd_mach_o_load_command *) 1682 bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command))); 1683 if (mdata->commands == NULL) 1684 return -1; 1685 1686 for (i = 0; i < header->ncmds; i++) 1687 { 1688 bfd_mach_o_load_command *cur = &mdata->commands[i]; 1689 1690 if (i == 0) 1691 cur->offset = 28; 1692 else 1693 { 1694 bfd_mach_o_load_command *prev = &mdata->commands[i - 1]; 1695 cur->offset = prev->offset + prev->len; 1696 } 1697 1698 if (bfd_mach_o_scan_read_command (abfd, cur) < 0) 1699 return -1; 1700 } 1701 } 1702 1703 if (bfd_mach_o_scan_start_address (abfd) < 0) 1704 { 1705 #if 0 1706 fprintf (stderr, "bfd_mach_o_scan: unable to scan start address: %s\n", 1707 bfd_errmsg (bfd_get_error ())); 1708 abfd->tdata.mach_o_data = NULL; 1709 return -1; 1710 #endif 1711 } 1712 1713 bfd_mach_o_flatten_sections (abfd); 1714 1715 return 0; 1716 } 1717 1718 bfd_boolean 1719 bfd_mach_o_mkobject (abfd) 1720 bfd *abfd; 1721 { 1722 bfd_mach_o_data_struct *mdata = NULL; 1723 1724 mdata = ((bfd_mach_o_data_struct *) 1725 bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct))); 1726 if (mdata == NULL) 1727 return FALSE; 1728 abfd->tdata.mach_o_data = mdata; 1729 1730 mdata->header.magic = 0; 1731 mdata->header.cputype = 0; 1732 mdata->header.cpusubtype = 0; 1733 mdata->header.filetype = 0; 1734 mdata->header.ncmds = 0; 1735 mdata->header.sizeofcmds = 0; 1736 mdata->header.flags = 0; 1737 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN; 1738 mdata->commands = NULL; 1739 mdata->nsymbols = 0; 1740 mdata->symbols = NULL; 1741 mdata->nsects = 0; 1742 mdata->sections = NULL; 1743 mdata->ibfd = NULL; 1744 1745 return TRUE; 1746 } 1747 1748 const bfd_target * 1749 bfd_mach_o_object_p (abfd) 1750 bfd *abfd; 1751 { 1752 struct bfd_preserve preserve; 1753 bfd_mach_o_header header; 1754 1755 preserve.marker = NULL; 1756 if (bfd_mach_o_read_header (abfd, &header) != 0) 1757 goto wrong; 1758 1759 if (! (header.byteorder == BFD_ENDIAN_BIG 1760 || header.byteorder == BFD_ENDIAN_LITTLE)) 1761 { 1762 fprintf (stderr, "unknown header byte-order value 0x%lx\n", 1763 (long) header.byteorder); 1764 goto wrong; 1765 } 1766 1767 if (! ((header.byteorder == BFD_ENDIAN_BIG 1768 && abfd->xvec->byteorder == BFD_ENDIAN_BIG 1769 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG) 1770 || (header.byteorder == BFD_ENDIAN_LITTLE 1771 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE 1772 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE))) 1773 goto wrong; 1774 1775 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct)); 1776 if (preserve.marker == NULL 1777 || !bfd_preserve_save (abfd, &preserve)) 1778 goto fail; 1779 1780 if (bfd_mach_o_scan (abfd, &header, 1781 (bfd_mach_o_data_struct *) preserve.marker) != 0) 1782 goto wrong; 1783 1784 bfd_preserve_finish (abfd, &preserve); 1785 return abfd->xvec; 1786 1787 wrong: 1788 bfd_set_error (bfd_error_wrong_format); 1789 1790 fail: 1791 if (preserve.marker != NULL) 1792 bfd_preserve_restore (abfd, &preserve); 1793 return NULL; 1794 } 1795 1796 const bfd_target * 1797 bfd_mach_o_core_p (abfd) 1798 bfd *abfd; 1799 { 1800 struct bfd_preserve preserve; 1801 bfd_mach_o_header header; 1802 1803 preserve.marker = NULL; 1804 if (bfd_mach_o_read_header (abfd, &header) != 0) 1805 goto wrong; 1806 1807 if (! (header.byteorder == BFD_ENDIAN_BIG 1808 || header.byteorder == BFD_ENDIAN_LITTLE)) 1809 { 1810 fprintf (stderr, "unknown header byte-order value 0x%lx\n", 1811 (long) header.byteorder); 1812 abort (); 1813 } 1814 1815 if (! ((header.byteorder == BFD_ENDIAN_BIG 1816 && abfd->xvec->byteorder == BFD_ENDIAN_BIG 1817 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG) 1818 || (header.byteorder == BFD_ENDIAN_LITTLE 1819 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE 1820 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE))) 1821 goto wrong; 1822 1823 if (header.filetype != BFD_MACH_O_MH_CORE) 1824 goto wrong; 1825 1826 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct)); 1827 if (preserve.marker == NULL 1828 || !bfd_preserve_save (abfd, &preserve)) 1829 goto fail; 1830 1831 if (bfd_mach_o_scan (abfd, &header, 1832 (bfd_mach_o_data_struct *) preserve.marker) != 0) 1833 goto wrong; 1834 1835 bfd_preserve_finish (abfd, &preserve); 1836 return abfd->xvec; 1837 1838 wrong: 1839 bfd_set_error (bfd_error_wrong_format); 1840 1841 fail: 1842 if (preserve.marker != NULL) 1843 bfd_preserve_restore (abfd, &preserve); 1844 return NULL; 1845 } 1846 1847 typedef struct mach_o_fat_archentry 1848 { 1849 unsigned long cputype; 1850 unsigned long cpusubtype; 1851 unsigned long offset; 1852 unsigned long size; 1853 unsigned long align; 1854 bfd *abfd; 1855 } mach_o_fat_archentry; 1856 1857 typedef struct mach_o_fat_data_struct 1858 { 1859 unsigned long magic; 1860 unsigned long nfat_arch; 1861 mach_o_fat_archentry *archentries; 1862 } mach_o_fat_data_struct; 1863 1864 const bfd_target * 1865 bfd_mach_o_archive_p (abfd) 1866 bfd *abfd; 1867 { 1868 mach_o_fat_data_struct *adata = NULL; 1869 unsigned char buf[20]; 1870 unsigned long i; 1871 1872 bfd_seek (abfd, 0, SEEK_SET); 1873 if (bfd_bread ((PTR) buf, 8, abfd) != 8) 1874 goto error; 1875 1876 adata = (mach_o_fat_data_struct *) 1877 bfd_alloc (abfd, sizeof (mach_o_fat_data_struct)); 1878 if (adata == NULL) 1879 goto error; 1880 1881 adata->magic = bfd_getb32 (buf); 1882 adata->nfat_arch = bfd_getb32 (buf + 4); 1883 if (adata->magic != 0xcafebabe) 1884 goto error; 1885 1886 adata->archentries = (mach_o_fat_archentry *) 1887 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry)); 1888 if (adata->archentries == NULL) 1889 goto error; 1890 1891 for (i = 0; i < adata->nfat_arch; i++) 1892 { 1893 bfd_seek (abfd, 8 + 20 * i, SEEK_SET); 1894 1895 if (bfd_bread ((PTR) buf, 20, abfd) != 20) 1896 goto error; 1897 adata->archentries[i].cputype = bfd_getb32 (buf); 1898 adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4); 1899 adata->archentries[i].offset = bfd_getb32 (buf + 8); 1900 adata->archentries[i].size = bfd_getb32 (buf + 12); 1901 adata->archentries[i].align = bfd_getb32 (buf + 16); 1902 adata->archentries[i].abfd = NULL; 1903 } 1904 1905 abfd->tdata.mach_o_fat_data = adata; 1906 return abfd->xvec; 1907 1908 error: 1909 if (adata != NULL) 1910 bfd_release (abfd, adata); 1911 bfd_set_error (bfd_error_wrong_format); 1912 return NULL; 1913 } 1914 1915 bfd * 1916 bfd_mach_o_openr_next_archived_file (archive, prev) 1917 bfd *archive; 1918 bfd *prev; 1919 { 1920 mach_o_fat_data_struct *adata; 1921 mach_o_fat_archentry *entry = NULL; 1922 unsigned long i; 1923 1924 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data; 1925 BFD_ASSERT (adata != NULL); 1926 1927 /* Find index of previous entry. */ 1928 if (prev == NULL) 1929 i = 0; /* Start at first one. */ 1930 else 1931 { 1932 for (i = 0; i < adata->nfat_arch; i++) 1933 { 1934 if (adata->archentries[i].abfd == prev) 1935 break; 1936 } 1937 1938 if (i == adata->nfat_arch) 1939 { 1940 /* Not found. */ 1941 bfd_set_error (bfd_error_bad_value); 1942 return NULL; 1943 } 1944 i++; /* Get next entry. */ 1945 } 1946 1947 if (i >= adata->nfat_arch) 1948 { 1949 bfd_set_error (bfd_error_no_more_archived_files); 1950 return NULL; 1951 } 1952 1953 entry = &adata->archentries[i]; 1954 if (entry->abfd == NULL) 1955 { 1956 bfd *nbfd = _bfd_new_bfd_contained_in (archive); 1957 char *s = NULL; 1958 1959 if (nbfd == NULL) 1960 return NULL; 1961 1962 nbfd->origin = entry->offset; 1963 s = bfd_malloc (strlen (archive->filename) + 1); 1964 if (s == NULL) 1965 return NULL; 1966 strcpy (s, archive->filename); 1967 nbfd->filename = s; 1968 nbfd->iostream = NULL; 1969 entry->abfd = nbfd; 1970 } 1971 1972 return entry->abfd; 1973 } 1974 1975 int 1976 bfd_mach_o_lookup_section (abfd, section, mcommand, msection) 1977 bfd *abfd; 1978 asection *section; 1979 bfd_mach_o_load_command **mcommand; 1980 bfd_mach_o_section **msection; 1981 { 1982 struct mach_o_data_struct *md = abfd->tdata.mach_o_data; 1983 unsigned int i, j, num; 1984 1985 bfd_mach_o_load_command *ncmd = NULL; 1986 bfd_mach_o_section *nsect = NULL; 1987 1988 BFD_ASSERT (mcommand != NULL); 1989 BFD_ASSERT (msection != NULL); 1990 1991 num = 0; 1992 for (i = 0; i < md->header.ncmds; i++) 1993 { 1994 struct bfd_mach_o_load_command *cmd = &md->commands[i]; 1995 struct bfd_mach_o_segment_command *seg = NULL; 1996 1997 if (cmd->type != BFD_MACH_O_LC_SEGMENT) 1998 continue; 1999 seg = &cmd->command.segment; 2000 2001 if (seg->segment == section) 2002 { 2003 if (num == 0) 2004 ncmd = cmd; 2005 num++; 2006 } 2007 2008 for (j = 0; j < seg->nsects; j++) 2009 { 2010 struct bfd_mach_o_section *sect = &seg->sections[j]; 2011 2012 if (sect->bfdsection == section) 2013 { 2014 if (num == 0) 2015 nsect = sect; 2016 num++; 2017 } 2018 } 2019 } 2020 2021 *mcommand = ncmd; 2022 *msection = nsect; 2023 return num; 2024 } 2025 2026 int 2027 bfd_mach_o_lookup_command (abfd, type, mcommand) 2028 bfd *abfd; 2029 bfd_mach_o_load_command_type type; 2030 bfd_mach_o_load_command **mcommand; 2031 { 2032 struct mach_o_data_struct *md = NULL; 2033 bfd_mach_o_load_command *ncmd = NULL; 2034 unsigned int i, num; 2035 2036 md = abfd->tdata.mach_o_data; 2037 2038 BFD_ASSERT (md != NULL); 2039 BFD_ASSERT (mcommand != NULL); 2040 2041 num = 0; 2042 for (i = 0; i < md->header.ncmds; i++) 2043 { 2044 struct bfd_mach_o_load_command *cmd = &md->commands[i]; 2045 2046 if (cmd->type != type) 2047 continue; 2048 2049 if (num == 0) 2050 ncmd = cmd; 2051 num++; 2052 } 2053 2054 *mcommand = ncmd; 2055 return num; 2056 } 2057 2058 unsigned long 2059 bfd_mach_o_stack_addr (type) 2060 enum bfd_mach_o_cpu_type type; 2061 { 2062 switch (type) 2063 { 2064 case BFD_MACH_O_CPU_TYPE_MC680x0: 2065 return 0x04000000; 2066 case BFD_MACH_O_CPU_TYPE_MC88000: 2067 return 0xffffe000; 2068 case BFD_MACH_O_CPU_TYPE_POWERPC: 2069 return 0xc0000000; 2070 case BFD_MACH_O_CPU_TYPE_I386: 2071 return 0xc0000000; 2072 case BFD_MACH_O_CPU_TYPE_SPARC: 2073 return 0xf0000000; 2074 case BFD_MACH_O_CPU_TYPE_I860: 2075 return 0; 2076 case BFD_MACH_O_CPU_TYPE_HPPA: 2077 return 0xc0000000 - 0x04000000; 2078 default: 2079 return 0; 2080 } 2081 } 2082 2083 int 2084 bfd_mach_o_core_fetch_environment (abfd, rbuf, rlen) 2085 bfd *abfd; 2086 unsigned char **rbuf; 2087 unsigned int *rlen; 2088 { 2089 bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data; 2090 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype); 2091 unsigned int i = 0; 2092 2093 for (i = 0; i < mdata->header.ncmds; i++) 2094 { 2095 bfd_mach_o_load_command *cur = &mdata->commands[i]; 2096 bfd_mach_o_segment_command *seg = NULL; 2097 2098 if (cur->type != BFD_MACH_O_LC_SEGMENT) 2099 continue; 2100 2101 seg = &cur->command.segment; 2102 2103 if ((seg->vmaddr + seg->vmsize) == stackaddr) 2104 { 2105 unsigned long start = seg->fileoff; 2106 unsigned long end = seg->fileoff + seg->filesize; 2107 unsigned char *buf = bfd_malloc (1024); 2108 unsigned long size = 1024; 2109 2110 for (;;) 2111 { 2112 bfd_size_type nread = 0; 2113 unsigned long offset; 2114 int found_nonnull = 0; 2115 2116 if (size > (end - start)) 2117 size = (end - start); 2118 2119 buf = bfd_realloc (buf, size); 2120 2121 bfd_seek (abfd, end - size, SEEK_SET); 2122 nread = bfd_bread (buf, size, abfd); 2123 2124 if (nread != size) 2125 return -1; 2126 2127 for (offset = 4; offset <= size; offset += 4) 2128 { 2129 unsigned long val; 2130 2131 val = *((unsigned long *) (buf + size - offset)); 2132 if (! found_nonnull) 2133 { 2134 if (val != 0) 2135 found_nonnull = 1; 2136 } 2137 else if (val == 0x0) 2138 { 2139 unsigned long bottom; 2140 unsigned long top; 2141 2142 bottom = seg->fileoff + seg->filesize - offset; 2143 top = seg->fileoff + seg->filesize - 4; 2144 *rbuf = bfd_malloc (top - bottom); 2145 *rlen = top - bottom; 2146 2147 memcpy (*rbuf, buf + size - *rlen, *rlen); 2148 return 0; 2149 } 2150 } 2151 2152 if (size == (end - start)) 2153 break; 2154 2155 size *= 2; 2156 } 2157 } 2158 } 2159 2160 return -1; 2161 } 2162 2163 char * 2164 bfd_mach_o_core_file_failing_command (abfd) 2165 bfd *abfd; 2166 { 2167 unsigned char *buf = NULL; 2168 unsigned int len = 0; 2169 int ret = -1; 2170 2171 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len); 2172 if (ret < 0) 2173 return NULL; 2174 2175 return buf; 2176 } 2177 2178 int 2179 bfd_mach_o_core_file_failing_signal (abfd) 2180 bfd *abfd ATTRIBUTE_UNUSED; 2181 { 2182 return 0; 2183 } 2184 2185 bfd_boolean 2186 bfd_mach_o_core_file_matches_executable_p (core_bfd, exec_bfd) 2187 bfd *core_bfd ATTRIBUTE_UNUSED; 2188 bfd *exec_bfd ATTRIBUTE_UNUSED; 2189 { 2190 return TRUE; 2191 } 2192 2193 #define TARGET_NAME mach_o_be_vec 2194 #define TARGET_STRING "mach-o-be" 2195 #define TARGET_BIG_ENDIAN 1 2196 #define TARGET_ARCHIVE 0 2197 2198 #include "mach-o-target.c" 2199 2200 #undef TARGET_NAME 2201 #undef TARGET_STRING 2202 #undef TARGET_BIG_ENDIAN 2203 #undef TARGET_ARCHIVE 2204 2205 #define TARGET_NAME mach_o_le_vec 2206 #define TARGET_STRING "mach-o-le" 2207 #define TARGET_BIG_ENDIAN 0 2208 #define TARGET_ARCHIVE 0 2209 2210 #include "mach-o-target.c" 2211 2212 #undef TARGET_NAME 2213 #undef TARGET_STRING 2214 #undef TARGET_BIG_ENDIAN 2215 #undef TARGET_ARCHIVE 2216 2217 #define TARGET_NAME mach_o_fat_vec 2218 #define TARGET_STRING "mach-o-fat" 2219 #define TARGET_BIG_ENDIAN 1 2220 #define TARGET_ARCHIVE 1 2221 2222 #include "mach-o-target.c" 2223 2224 #undef TARGET_NAME 2225 #undef TARGET_STRING 2226 #undef TARGET_BIG_ENDIAN 2227 #undef TARGET_ARCHIVE 2228