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