1 /* Mach-O support for BFD. 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 3 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 MA 02110-1301, USA. */ 22 23 #include "sysdep.h" 24 #include "mach-o.h" 25 #include "bfd.h" 26 #include "libbfd.h" 27 #include "libiberty.h" 28 #include "aout/stab_gnu.h" 29 #include <ctype.h> 30 31 #define bfd_mach_o_object_p bfd_mach_o_gen_object_p 32 #define bfd_mach_o_core_p bfd_mach_o_gen_core_p 33 #define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject 34 35 #define FILE_ALIGN(off, algn) \ 36 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn))) 37 38 static int bfd_mach_o_read_symtab_symbols (bfd *); 39 40 unsigned int 41 bfd_mach_o_version (bfd *abfd) 42 { 43 bfd_mach_o_data_struct *mdata = NULL; 44 45 BFD_ASSERT (bfd_mach_o_valid (abfd)); 46 mdata = bfd_mach_o_get_data (abfd); 47 48 return mdata->header.version; 49 } 50 51 bfd_boolean 52 bfd_mach_o_valid (bfd *abfd) 53 { 54 if (abfd == NULL || abfd->xvec == NULL) 55 return FALSE; 56 57 if (abfd->xvec->flavour != bfd_target_mach_o_flavour) 58 return FALSE; 59 60 if (bfd_mach_o_get_data (abfd) == NULL) 61 return FALSE; 62 return TRUE; 63 } 64 65 static INLINE bfd_boolean 66 mach_o_wide_p (bfd_mach_o_header *header) 67 { 68 switch (header->version) 69 { 70 case 1: 71 return FALSE; 72 case 2: 73 return TRUE; 74 default: 75 BFD_FAIL (); 76 return FALSE; 77 } 78 } 79 80 static INLINE bfd_boolean 81 bfd_mach_o_wide_p (bfd *abfd) 82 { 83 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header); 84 } 85 86 /* Tables to translate well known Mach-O segment/section names to bfd 87 names. Use of canonical names (such as .text or .debug_frame) is required 88 by gdb. */ 89 90 struct mach_o_section_name_xlat 91 { 92 const char *bfd_name; 93 const char *mach_o_name; 94 flagword flags; 95 }; 96 97 static const struct mach_o_section_name_xlat dwarf_section_names_xlat[] = 98 { 99 { ".debug_frame", "__debug_frame", SEC_DEBUGGING }, 100 { ".debug_info", "__debug_info", SEC_DEBUGGING }, 101 { ".debug_abbrev", "__debug_abbrev", SEC_DEBUGGING }, 102 { ".debug_aranges", "__debug_aranges", SEC_DEBUGGING }, 103 { ".debug_macinfo", "__debug_macinfo", SEC_DEBUGGING }, 104 { ".debug_line", "__debug_line", SEC_DEBUGGING }, 105 { ".debug_loc", "__debug_loc", SEC_DEBUGGING }, 106 { ".debug_pubnames", "__debug_pubnames", SEC_DEBUGGING }, 107 { ".debug_pubtypes", "__debug_pubtypes", SEC_DEBUGGING }, 108 { ".debug_str", "__debug_str", SEC_DEBUGGING }, 109 { ".debug_ranges", "__debug_ranges", SEC_DEBUGGING }, 110 { NULL, NULL, 0} 111 }; 112 113 static const struct mach_o_section_name_xlat text_section_names_xlat[] = 114 { 115 { ".text", "__text", SEC_CODE | SEC_LOAD }, 116 { ".const", "__const", SEC_READONLY | SEC_DATA | SEC_LOAD }, 117 { ".cstring", "__cstring", SEC_READONLY | SEC_DATA | SEC_LOAD }, 118 { ".eh_frame", "__eh_frame", SEC_READONLY | SEC_LOAD }, 119 { NULL, NULL, 0} 120 }; 121 122 static const struct mach_o_section_name_xlat data_section_names_xlat[] = 123 { 124 { ".data", "__data", SEC_DATA | SEC_LOAD }, 125 { ".const_data", "__const", SEC_DATA | SEC_LOAD }, 126 { ".dyld", "__dyld", SEC_DATA | SEC_LOAD }, 127 { ".lazy_symbol_ptr", "__la_symbol_ptr", SEC_DATA | SEC_LOAD }, 128 { ".non_lazy_symbol_ptr", "__nl_symbol_ptr", SEC_DATA | SEC_LOAD }, 129 { ".bss", "__bss", SEC_NO_FLAGS }, 130 { NULL, NULL, 0} 131 }; 132 133 struct mach_o_segment_name_xlat 134 { 135 const char *segname; 136 const struct mach_o_section_name_xlat *sections; 137 }; 138 139 static const struct mach_o_segment_name_xlat segsec_names_xlat[] = 140 { 141 { "__DWARF", dwarf_section_names_xlat }, 142 { "__TEXT", text_section_names_xlat }, 143 { "__DATA", data_section_names_xlat }, 144 { NULL, NULL } 145 }; 146 147 148 /* Mach-O to bfd names. */ 149 150 static void 151 bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section, 152 char **name, flagword *flags) 153 { 154 const struct mach_o_segment_name_xlat *seg; 155 char *res; 156 unsigned int len; 157 const char *pfx = ""; 158 159 *name = NULL; 160 *flags = SEC_NO_FLAGS; 161 162 for (seg = segsec_names_xlat; seg->segname; seg++) 163 { 164 if (strcmp (seg->segname, section->segname) == 0) 165 { 166 const struct mach_o_section_name_xlat *sec; 167 168 for (sec = seg->sections; sec->mach_o_name; sec++) 169 { 170 if (strcmp (sec->mach_o_name, section->sectname) == 0) 171 { 172 len = strlen (sec->bfd_name); 173 res = bfd_alloc (abfd, len + 1); 174 175 if (res == NULL) 176 return; 177 strcpy (res, sec->bfd_name); 178 *name = res; 179 *flags = sec->flags; 180 return; 181 } 182 } 183 } 184 } 185 186 len = strlen (section->segname) + 1 187 + strlen (section->sectname) + 1; 188 189 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start 190 with an underscore. */ 191 if (section->segname[0] != '_') 192 { 193 static const char seg_pfx[] = "LC_SEGMENT."; 194 195 pfx = seg_pfx; 196 len += sizeof (seg_pfx) - 1; 197 } 198 199 res = bfd_alloc (abfd, len); 200 if (res == NULL) 201 return; 202 snprintf (res, len, "%s%s.%s", pfx, section->segname, section->sectname); 203 *name = res; 204 } 205 206 /* Convert a bfd section name to a Mach-O segment + section name. */ 207 208 static void 209 bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED, 210 asection *sect, 211 bfd_mach_o_section *section) 212 { 213 const struct mach_o_segment_name_xlat *seg; 214 const char *name = bfd_get_section_name (abfd, sect); 215 const char *dot; 216 unsigned int len; 217 unsigned int seglen; 218 unsigned int seclen; 219 220 /* List of well known names. They all start with a dot. */ 221 if (name[0] == '.') 222 for (seg = segsec_names_xlat; seg->segname; seg++) 223 { 224 const struct mach_o_section_name_xlat *sec; 225 226 for (sec = seg->sections; sec->mach_o_name; sec++) 227 { 228 if (strcmp (sec->bfd_name, name) == 0) 229 { 230 strcpy (section->segname, seg->segname); 231 strcpy (section->sectname, sec->mach_o_name); 232 return; 233 } 234 } 235 } 236 237 /* Strip LC_SEGMENT. prefix. */ 238 if (strncmp (name, "LC_SEGMENT.", 11) == 0) 239 name += 11; 240 241 /* Find a dot. */ 242 dot = strchr (name, '.'); 243 len = strlen (name); 244 245 /* Try to split name into segment and section names. */ 246 if (dot && dot != name) 247 { 248 seglen = dot - name; 249 seclen = len - (dot + 1 - name); 250 251 if (seglen < 16 && seclen < 16) 252 { 253 memcpy (section->segname, name, seglen); 254 section->segname[seglen] = 0; 255 memcpy (section->sectname, dot + 1, seclen); 256 section->sectname[seclen] = 0; 257 return; 258 } 259 } 260 261 if (len > 16) 262 len = 16; 263 memcpy (section->segname, name, len); 264 section->segname[len] = 0; 265 memcpy (section->sectname, name, len); 266 section->sectname[len] = 0; 267 } 268 269 /* Return the size of an entry for section SEC. 270 Must be called only for symbol pointer section and symbol stubs 271 sections. */ 272 273 static unsigned int 274 bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec) 275 { 276 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) 277 { 278 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: 279 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: 280 return bfd_mach_o_wide_p (abfd) ? 8 : 4; 281 case BFD_MACH_O_S_SYMBOL_STUBS: 282 return sec->reserved2; 283 default: 284 BFD_FAIL (); 285 return 0; 286 } 287 } 288 289 /* Return the number of indirect symbols for a section. 290 Must be called only for symbol pointer section and symbol stubs 291 sections. */ 292 293 static unsigned int 294 bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec) 295 { 296 unsigned int elsz; 297 298 elsz = bfd_mach_o_section_get_entry_size (abfd, sec); 299 if (elsz == 0) 300 return 0; 301 else 302 return sec->size / elsz; 303 } 304 305 306 /* Copy any private info we understand from the input symbol 307 to the output symbol. */ 308 309 bfd_boolean 310 bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED, 311 asymbol *isymbol ATTRIBUTE_UNUSED, 312 bfd *obfd ATTRIBUTE_UNUSED, 313 asymbol *osymbol ATTRIBUTE_UNUSED) 314 { 315 return TRUE; 316 } 317 318 /* Copy any private info we understand from the input section 319 to the output section. */ 320 321 bfd_boolean 322 bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED, 323 asection *isection ATTRIBUTE_UNUSED, 324 bfd *obfd ATTRIBUTE_UNUSED, 325 asection *osection ATTRIBUTE_UNUSED) 326 { 327 return TRUE; 328 } 329 330 /* Copy any private info we understand from the input bfd 331 to the output bfd. */ 332 333 bfd_boolean 334 bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 335 { 336 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour 337 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour) 338 return TRUE; 339 340 BFD_ASSERT (bfd_mach_o_valid (ibfd)); 341 BFD_ASSERT (bfd_mach_o_valid (obfd)); 342 343 /* FIXME: copy commands. */ 344 345 return TRUE; 346 } 347 348 /* Count the total number of symbols. */ 349 350 static long 351 bfd_mach_o_count_symbols (bfd *abfd) 352 { 353 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 354 355 if (mdata->symtab == NULL) 356 return 0; 357 return mdata->symtab->nsyms; 358 } 359 360 long 361 bfd_mach_o_get_symtab_upper_bound (bfd *abfd) 362 { 363 long nsyms = bfd_mach_o_count_symbols (abfd); 364 365 return ((nsyms + 1) * sizeof (asymbol *)); 366 } 367 368 long 369 bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation) 370 { 371 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 372 long nsyms = bfd_mach_o_count_symbols (abfd); 373 bfd_mach_o_symtab_command *sym = mdata->symtab; 374 unsigned long j; 375 376 if (nsyms < 0) 377 return nsyms; 378 379 if (bfd_mach_o_read_symtab_symbols (abfd) != 0) 380 { 381 (*_bfd_error_handler) (_("bfd_mach_o_canonicalize_symtab: unable to load symbols")); 382 return 0; 383 } 384 385 BFD_ASSERT (sym->symbols != NULL); 386 387 for (j = 0; j < sym->nsyms; j++) 388 alocation[j] = &sym->symbols[j].symbol; 389 390 alocation[j] = NULL; 391 392 return nsyms; 393 } 394 395 long 396 bfd_mach_o_get_synthetic_symtab (bfd *abfd, 397 long symcount ATTRIBUTE_UNUSED, 398 asymbol **syms ATTRIBUTE_UNUSED, 399 long dynsymcount ATTRIBUTE_UNUSED, 400 asymbol **dynsyms ATTRIBUTE_UNUSED, 401 asymbol **ret) 402 { 403 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 404 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab; 405 bfd_mach_o_symtab_command *symtab = mdata->symtab; 406 asymbol *s; 407 unsigned long count, i, j, n; 408 size_t size; 409 char *names; 410 char *nul_name; 411 412 *ret = NULL; 413 414 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL) 415 return 0; 416 417 if (dysymtab->nindirectsyms == 0) 418 return 0; 419 420 count = dysymtab->nindirectsyms; 421 size = count * sizeof (asymbol) + 1; 422 423 for (j = 0; j < count; j++) 424 { 425 unsigned int isym = dysymtab->indirect_syms[j]; 426 427 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name) 428 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub"); 429 } 430 431 s = *ret = (asymbol *) bfd_malloc (size); 432 if (s == NULL) 433 return -1; 434 names = (char *) (s + count); 435 nul_name = names; 436 *names++ = 0; 437 438 n = 0; 439 for (i = 0; i < mdata->nsects; i++) 440 { 441 bfd_mach_o_section *sec = mdata->sections[i]; 442 unsigned int first, last; 443 bfd_vma addr; 444 bfd_vma entry_size; 445 446 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) 447 { 448 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: 449 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: 450 case BFD_MACH_O_S_SYMBOL_STUBS: 451 first = sec->reserved1; 452 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec); 453 addr = sec->addr; 454 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec); 455 for (j = first; j < last; j++) 456 { 457 unsigned int isym = dysymtab->indirect_syms[j]; 458 459 s->flags = BSF_GLOBAL | BSF_SYNTHETIC; 460 s->section = sec->bfdsection; 461 s->value = addr - sec->addr; 462 s->udata.p = NULL; 463 464 if (isym < symtab->nsyms 465 && symtab->symbols[isym].symbol.name) 466 { 467 const char *sym = symtab->symbols[isym].symbol.name; 468 size_t len; 469 470 s->name = names; 471 len = strlen (sym); 472 memcpy (names, sym, len); 473 names += len; 474 memcpy (names, "$stub", sizeof ("$stub")); 475 names += sizeof ("$stub"); 476 } 477 else 478 s->name = nul_name; 479 480 addr += entry_size; 481 s++; 482 n++; 483 } 484 break; 485 default: 486 break; 487 } 488 } 489 490 return n; 491 } 492 493 void 494 bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, 495 asymbol *symbol, 496 symbol_info *ret) 497 { 498 bfd_symbol_info (symbol, ret); 499 } 500 501 void 502 bfd_mach_o_print_symbol (bfd *abfd, 503 void * afile, 504 asymbol *symbol, 505 bfd_print_symbol_type how) 506 { 507 FILE *file = (FILE *) afile; 508 const char *name; 509 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol; 510 511 switch (how) 512 { 513 case bfd_print_symbol_name: 514 fprintf (file, "%s", symbol->name); 515 break; 516 default: 517 bfd_print_symbol_vandf (abfd, (void *) file, symbol); 518 if (asym->n_type & BFD_MACH_O_N_STAB) 519 name = bfd_get_stab_name (asym->n_type); 520 else 521 switch (asym->n_type & BFD_MACH_O_N_TYPE) 522 { 523 case BFD_MACH_O_N_UNDF: 524 name = "UND"; 525 break; 526 case BFD_MACH_O_N_ABS: 527 name = "ABS"; 528 break; 529 case BFD_MACH_O_N_INDR: 530 name = "INDR"; 531 break; 532 case BFD_MACH_O_N_PBUD: 533 name = "PBUD"; 534 break; 535 case BFD_MACH_O_N_SECT: 536 name = "SECT"; 537 break; 538 default: 539 name = "???"; 540 break; 541 } 542 if (name == NULL) 543 name = ""; 544 fprintf (file, " %02x %-6s %02x %04x", 545 asym->n_type, name, asym->n_sect, asym->n_desc); 546 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0 547 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT) 548 fprintf (file, " %-5s", symbol->section->name); 549 fprintf (file, " %s", symbol->name); 550 } 551 } 552 553 static void 554 bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype, 555 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED, 556 enum bfd_architecture *type, 557 unsigned long *subtype) 558 { 559 *subtype = bfd_arch_unknown; 560 561 switch (mtype) 562 { 563 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break; 564 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break; 565 case BFD_MACH_O_CPU_TYPE_I386: 566 *type = bfd_arch_i386; 567 *subtype = bfd_mach_i386_i386; 568 break; 569 case BFD_MACH_O_CPU_TYPE_X86_64: 570 *type = bfd_arch_i386; 571 *subtype = bfd_mach_x86_64; 572 break; 573 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break; 574 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break; 575 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break; 576 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break; 577 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break; 578 case BFD_MACH_O_CPU_TYPE_SPARC: 579 *type = bfd_arch_sparc; 580 *subtype = bfd_mach_sparc; 581 break; 582 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break; 583 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break; 584 case BFD_MACH_O_CPU_TYPE_POWERPC: 585 *type = bfd_arch_powerpc; 586 *subtype = bfd_mach_ppc; 587 break; 588 case BFD_MACH_O_CPU_TYPE_POWERPC_64: 589 *type = bfd_arch_powerpc; 590 *subtype = bfd_mach_ppc64; 591 break; 592 default: 593 *type = bfd_arch_unknown; 594 break; 595 } 596 } 597 598 static bfd_boolean 599 bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header) 600 { 601 unsigned char buf[32]; 602 unsigned int size; 603 604 size = mach_o_wide_p (header) ? 605 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE; 606 607 bfd_h_put_32 (abfd, header->magic, buf + 0); 608 bfd_h_put_32 (abfd, header->cputype, buf + 4); 609 bfd_h_put_32 (abfd, header->cpusubtype, buf + 8); 610 bfd_h_put_32 (abfd, header->filetype, buf + 12); 611 bfd_h_put_32 (abfd, header->ncmds, buf + 16); 612 bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20); 613 bfd_h_put_32 (abfd, header->flags, buf + 24); 614 615 if (mach_o_wide_p (header)) 616 bfd_h_put_32 (abfd, header->reserved, buf + 28); 617 618 if (bfd_seek (abfd, 0, SEEK_SET) != 0 619 || bfd_bwrite ((void *) buf, size, abfd) != size) 620 return FALSE; 621 622 return TRUE; 623 } 624 625 static int 626 bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command) 627 { 628 bfd_mach_o_thread_command *cmd = &command->command.thread; 629 unsigned int i; 630 unsigned char buf[8]; 631 unsigned int offset; 632 633 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD) 634 || (command->type == BFD_MACH_O_LC_UNIXTHREAD)); 635 636 offset = 8; 637 for (i = 0; i < cmd->nflavours; i++) 638 { 639 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0); 640 BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8)); 641 642 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf); 643 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4); 644 645 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0 646 || bfd_bwrite ((void *) buf, 8, abfd) != 8) 647 return -1; 648 649 offset += cmd->flavours[i].size + 8; 650 } 651 652 return 0; 653 } 654 655 long 656 bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, 657 asection *asect) 658 { 659 return (asect->reloc_count + 1) * sizeof (arelent *); 660 } 661 662 static int 663 bfd_mach_o_canonicalize_one_reloc (bfd *abfd, char *buf, 664 arelent *res, asymbol **syms) 665 { 666 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 667 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); 668 bfd_mach_o_reloc_info reloc; 669 bfd_vma addr; 670 bfd_vma symnum; 671 asymbol **sym; 672 673 addr = bfd_get_32 (abfd, buf + 0); 674 symnum = bfd_get_32 (abfd, buf + 4); 675 676 if (addr & BFD_MACH_O_SR_SCATTERED) 677 { 678 unsigned int j; 679 680 /* Scattered relocation. 681 Extract section and offset from r_value. */ 682 res->sym_ptr_ptr = NULL; 683 res->addend = 0; 684 for (j = 0; j < mdata->nsects; j++) 685 { 686 bfd_mach_o_section *sect = mdata->sections[j]; 687 if (symnum >= sect->addr && symnum < sect->addr + sect->size) 688 { 689 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr; 690 res->addend = symnum - sect->addr; 691 break; 692 } 693 } 694 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr); 695 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr); 696 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr); 697 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL; 698 reloc.r_scattered = 1; 699 } 700 else 701 { 702 unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum); 703 res->addend = 0; 704 res->address = addr; 705 if (symnum & BFD_MACH_O_R_EXTERN) 706 { 707 sym = syms + num; 708 reloc.r_extern = 1; 709 } 710 else 711 { 712 BFD_ASSERT (num != 0); 713 BFD_ASSERT (num <= mdata->nsects); 714 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr; 715 /* For a symbol defined in section S, the addend (stored in the 716 binary) contains the address of the section. To comply with 717 bfd conventio, substract the section address. 718 Use the address from the header, so that the user can modify 719 the vma of the section. */ 720 res->addend = -mdata->sections[num - 1]->addr; 721 reloc.r_extern = 0; 722 } 723 res->sym_ptr_ptr = sym; 724 reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum); 725 reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum); 726 reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0; 727 reloc.r_scattered = 0; 728 } 729 730 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc)) 731 return -1; 732 return 0; 733 } 734 735 static int 736 bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos, 737 unsigned long count, 738 arelent *res, asymbol **syms) 739 { 740 unsigned long i; 741 char *native_relocs; 742 bfd_size_type native_size; 743 744 /* Allocate and read relocs. */ 745 native_size = count * BFD_MACH_O_RELENT_SIZE; 746 native_relocs = bfd_malloc (native_size); 747 if (native_relocs == NULL) 748 return -1; 749 750 if (bfd_seek (abfd, filepos, SEEK_SET) != 0 751 || bfd_bread (native_relocs, native_size, abfd) != native_size) 752 goto err; 753 754 for (i = 0; i < count; i++) 755 { 756 char *buf = native_relocs + BFD_MACH_O_RELENT_SIZE * i; 757 758 if (bfd_mach_o_canonicalize_one_reloc (abfd, buf, &res[i], syms) < 0) 759 goto err; 760 } 761 free (native_relocs); 762 return i; 763 err: 764 free (native_relocs); 765 return -1; 766 } 767 768 long 769 bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect, 770 arelent **rels, asymbol **syms) 771 { 772 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); 773 unsigned long i; 774 arelent *res; 775 776 if (asect->reloc_count == 0) 777 return 0; 778 779 /* No need to go further if we don't know how to read relocs. */ 780 if (bed->_bfd_mach_o_swap_reloc_in == NULL) 781 return 0; 782 783 res = bfd_malloc (asect->reloc_count * sizeof (arelent)); 784 if (res == NULL) 785 return -1; 786 787 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos, 788 asect->reloc_count, res, syms) < 0) 789 { 790 free (res); 791 return -1; 792 } 793 794 for (i = 0; i < asect->reloc_count; i++) 795 rels[i] = &res[i]; 796 rels[i] = NULL; 797 asect->relocation = res; 798 799 return i; 800 } 801 802 long 803 bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd) 804 { 805 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 806 807 if (mdata->dysymtab == NULL) 808 return 1; 809 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel) 810 * sizeof (arelent *); 811 } 812 813 long 814 bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels, 815 struct bfd_symbol **syms) 816 { 817 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 818 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab; 819 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); 820 unsigned long i; 821 arelent *res; 822 823 if (dysymtab == NULL) 824 return 0; 825 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0) 826 return 0; 827 828 /* No need to go further if we don't know how to read relocs. */ 829 if (bed->_bfd_mach_o_swap_reloc_in == NULL) 830 return 0; 831 832 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent)); 833 if (res == NULL) 834 return -1; 835 836 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff, 837 dysymtab->nextrel, res, syms) < 0) 838 { 839 free (res); 840 return -1; 841 } 842 843 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff, 844 dysymtab->nlocrel, 845 res + dysymtab->nextrel, syms) < 0) 846 { 847 free (res); 848 return -1; 849 } 850 851 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++) 852 rels[i] = &res[i]; 853 rels[i] = NULL; 854 return i; 855 } 856 857 static bfd_boolean 858 bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section) 859 { 860 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 861 unsigned int i; 862 arelent **entries; 863 asection *sec; 864 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); 865 866 sec = section->bfdsection; 867 if (sec->reloc_count == 0) 868 return TRUE; 869 870 if (bed->_bfd_mach_o_swap_reloc_out == NULL) 871 return TRUE; 872 873 /* Allocate relocation room. */ 874 mdata->filelen = FILE_ALIGN(mdata->filelen, 2); 875 section->nreloc = sec->reloc_count; 876 sec->rel_filepos = mdata->filelen; 877 section->reloff = sec->rel_filepos; 878 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE; 879 880 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0) 881 return FALSE; 882 883 /* Convert and write. */ 884 entries = section->bfdsection->orelocation; 885 for (i = 0; i < section->nreloc; i++) 886 { 887 arelent *rel = entries[i]; 888 char buf[8]; 889 bfd_mach_o_reloc_info info, *pinfo = &info; 890 891 /* Convert relocation to an intermediate representation. */ 892 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo)) 893 return FALSE; 894 895 /* Lower the relocation info. */ 896 if (pinfo->r_scattered) 897 { 898 unsigned long v; 899 900 v = BFD_MACH_O_SR_SCATTERED 901 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0) 902 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length) 903 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type) 904 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address); 905 bfd_put_32 (abfd, v, buf); 906 bfd_put_32 (abfd, pinfo->r_value, buf + 4); 907 } 908 else 909 { 910 unsigned long v; 911 912 bfd_put_32 (abfd, pinfo->r_address, buf); 913 v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value) 914 | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0) 915 | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length) 916 | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0) 917 | BFD_MACH_O_SET_R_TYPE (pinfo->r_type); 918 bfd_put_32 (abfd, v, buf + 4); 919 } 920 921 if (bfd_bwrite ((void *) buf, BFD_MACH_O_RELENT_SIZE, abfd) 922 != BFD_MACH_O_RELENT_SIZE) 923 return FALSE; 924 } 925 return TRUE; 926 } 927 928 static int 929 bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section) 930 { 931 unsigned char buf[BFD_MACH_O_SECTION_SIZE]; 932 933 memcpy (buf, section->sectname, 16); 934 memcpy (buf + 16, section->segname, 16); 935 bfd_h_put_32 (abfd, section->addr, buf + 32); 936 bfd_h_put_32 (abfd, section->size, buf + 36); 937 bfd_h_put_32 (abfd, section->offset, buf + 40); 938 bfd_h_put_32 (abfd, section->align, buf + 44); 939 bfd_h_put_32 (abfd, section->reloff, buf + 48); 940 bfd_h_put_32 (abfd, section->nreloc, buf + 52); 941 bfd_h_put_32 (abfd, section->flags, buf + 56); 942 bfd_h_put_32 (abfd, section->reserved1, buf + 60); 943 bfd_h_put_32 (abfd, section->reserved2, buf + 64); 944 945 if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd) 946 != BFD_MACH_O_SECTION_SIZE) 947 return -1; 948 949 return 0; 950 } 951 952 static int 953 bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section) 954 { 955 unsigned char buf[BFD_MACH_O_SECTION_64_SIZE]; 956 957 memcpy (buf, section->sectname, 16); 958 memcpy (buf + 16, section->segname, 16); 959 bfd_h_put_64 (abfd, section->addr, buf + 32); 960 bfd_h_put_64 (abfd, section->size, buf + 40); 961 bfd_h_put_32 (abfd, section->offset, buf + 48); 962 bfd_h_put_32 (abfd, section->align, buf + 52); 963 bfd_h_put_32 (abfd, section->reloff, buf + 56); 964 bfd_h_put_32 (abfd, section->nreloc, buf + 60); 965 bfd_h_put_32 (abfd, section->flags, buf + 64); 966 bfd_h_put_32 (abfd, section->reserved1, buf + 68); 967 bfd_h_put_32 (abfd, section->reserved2, buf + 72); 968 bfd_h_put_32 (abfd, section->reserved3, buf + 76); 969 970 if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd) 971 != BFD_MACH_O_SECTION_64_SIZE) 972 return -1; 973 974 return 0; 975 } 976 977 static int 978 bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command) 979 { 980 unsigned char buf[BFD_MACH_O_LC_SEGMENT_SIZE]; 981 bfd_mach_o_segment_command *seg = &command->command.segment; 982 unsigned long i; 983 984 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT); 985 986 for (i = 0; i < seg->nsects; i++) 987 if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i])) 988 return -1; 989 990 memcpy (buf, seg->segname, 16); 991 bfd_h_put_32 (abfd, seg->vmaddr, buf + 16); 992 bfd_h_put_32 (abfd, seg->vmsize, buf + 20); 993 bfd_h_put_32 (abfd, seg->fileoff, buf + 24); 994 bfd_h_put_32 (abfd, seg->filesize, buf + 28); 995 bfd_h_put_32 (abfd, seg->maxprot, buf + 32); 996 bfd_h_put_32 (abfd, seg->initprot, buf + 36); 997 bfd_h_put_32 (abfd, seg->nsects, buf + 40); 998 bfd_h_put_32 (abfd, seg->flags, buf + 44); 999 1000 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 1001 || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_SIZE - 8, abfd) 1002 != BFD_MACH_O_LC_SEGMENT_SIZE - 8)) 1003 return -1; 1004 1005 for (i = 0; i < seg->nsects; i++) 1006 if (bfd_mach_o_write_section_32 (abfd, &seg->sections[i])) 1007 return -1; 1008 1009 return 0; 1010 } 1011 1012 static int 1013 bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command) 1014 { 1015 unsigned char buf[BFD_MACH_O_LC_SEGMENT_64_SIZE]; 1016 bfd_mach_o_segment_command *seg = &command->command.segment; 1017 unsigned long i; 1018 1019 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64); 1020 1021 for (i = 0; i < seg->nsects; i++) 1022 if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i])) 1023 return -1; 1024 1025 memcpy (buf, seg->segname, 16); 1026 bfd_h_put_64 (abfd, seg->vmaddr, buf + 16); 1027 bfd_h_put_64 (abfd, seg->vmsize, buf + 24); 1028 bfd_h_put_64 (abfd, seg->fileoff, buf + 32); 1029 bfd_h_put_64 (abfd, seg->filesize, buf + 40); 1030 bfd_h_put_32 (abfd, seg->maxprot, buf + 48); 1031 bfd_h_put_32 (abfd, seg->initprot, buf + 52); 1032 bfd_h_put_32 (abfd, seg->nsects, buf + 56); 1033 bfd_h_put_32 (abfd, seg->flags, buf + 60); 1034 1035 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 1036 || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_64_SIZE - 8, abfd) 1037 != BFD_MACH_O_LC_SEGMENT_64_SIZE - 8)) 1038 return -1; 1039 1040 for (i = 0; i < seg->nsects; i++) 1041 if (bfd_mach_o_write_section_64 (abfd, &seg->sections[i])) 1042 return -1; 1043 1044 return 0; 1045 } 1046 1047 static bfd_boolean 1048 bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command) 1049 { 1050 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 1051 bfd_mach_o_symtab_command *sym = &command->command.symtab; 1052 unsigned char buf[16]; 1053 unsigned long i; 1054 unsigned int wide = bfd_mach_o_wide_p (abfd); 1055 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE; 1056 struct bfd_strtab_hash *strtab; 1057 asymbol **symbols = bfd_get_outsymbols (abfd); 1058 1059 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB); 1060 1061 /* Write the symbols first. */ 1062 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2); 1063 sym->symoff = mdata->filelen; 1064 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0) 1065 return FALSE; 1066 1067 sym->nsyms = bfd_get_symcount (abfd); 1068 mdata->filelen += sym->nsyms * symlen; 1069 1070 strtab = _bfd_stringtab_init (); 1071 if (strtab == NULL) 1072 return FALSE; 1073 1074 for (i = 0; i < sym->nsyms; i++) 1075 { 1076 bfd_size_type str_index; 1077 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i]; 1078 1079 /* Compute name index. */ 1080 /* An index of 0 always means the empty string. */ 1081 if (s->symbol.name == 0 || s->symbol.name[0] == '\0') 1082 str_index = 0; 1083 else 1084 { 1085 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE); 1086 if (str_index == (bfd_size_type) -1) 1087 goto err; 1088 } 1089 bfd_h_put_32 (abfd, str_index, buf); 1090 bfd_h_put_8 (abfd, s->n_type, buf + 4); 1091 bfd_h_put_8 (abfd, s->n_sect, buf + 5); 1092 bfd_h_put_16 (abfd, s->n_desc, buf + 6); 1093 if (wide) 1094 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8); 1095 else 1096 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8); 1097 1098 if (bfd_bwrite ((void *) buf, symlen, abfd) != symlen) 1099 goto err; 1100 } 1101 sym->strsize = _bfd_stringtab_size (strtab); 1102 sym->stroff = mdata->filelen; 1103 mdata->filelen += sym->strsize; 1104 1105 if (_bfd_stringtab_emit (abfd, strtab) != TRUE) 1106 goto err; 1107 _bfd_stringtab_free (strtab); 1108 1109 /* The command. */ 1110 bfd_h_put_32 (abfd, sym->symoff, buf); 1111 bfd_h_put_32 (abfd, sym->nsyms, buf + 4); 1112 bfd_h_put_32 (abfd, sym->stroff, buf + 8); 1113 bfd_h_put_32 (abfd, sym->strsize, buf + 12); 1114 1115 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 1116 || bfd_bwrite ((void *) buf, 16, abfd) != 16) 1117 return FALSE; 1118 1119 return TRUE; 1120 1121 err: 1122 _bfd_stringtab_free (strtab); 1123 return FALSE; 1124 } 1125 1126 /* Process the symbols and generate Mach-O specific fields. 1127 Number them. */ 1128 1129 static bfd_boolean 1130 bfd_mach_o_mangle_symbols (bfd *abfd) 1131 { 1132 unsigned long i; 1133 asymbol **symbols = bfd_get_outsymbols (abfd); 1134 1135 for (i = 0; i < bfd_get_symcount (abfd); i++) 1136 { 1137 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i]; 1138 1139 if (s->n_type == BFD_MACH_O_N_UNDF && !(s->symbol.flags & BSF_DEBUGGING)) 1140 { 1141 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined 1142 symbols should be N_UNDEF | N_EXT), we suppose the back-end 1143 values haven't been set. */ 1144 if (s->symbol.section == bfd_abs_section_ptr) 1145 s->n_type = BFD_MACH_O_N_ABS; 1146 else if (s->symbol.section == bfd_und_section_ptr) 1147 { 1148 s->n_type = BFD_MACH_O_N_UNDF; 1149 if (s->symbol.flags & BSF_WEAK) 1150 s->n_desc |= BFD_MACH_O_N_WEAK_REF; 1151 } 1152 else if (s->symbol.section == bfd_com_section_ptr) 1153 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT; 1154 else 1155 s->n_type = BFD_MACH_O_N_SECT; 1156 1157 if (s->symbol.flags & BSF_GLOBAL) 1158 s->n_type |= BFD_MACH_O_N_EXT; 1159 } 1160 1161 /* Compute section index. */ 1162 if (s->symbol.section != bfd_abs_section_ptr 1163 && s->symbol.section != bfd_und_section_ptr 1164 && s->symbol.section != bfd_com_section_ptr) 1165 s->n_sect = s->symbol.section->target_index; 1166 1167 /* Number symbols. */ 1168 s->symbol.udata.i = i; 1169 } 1170 return TRUE; 1171 } 1172 1173 bfd_boolean 1174 bfd_mach_o_write_contents (bfd *abfd) 1175 { 1176 unsigned int i; 1177 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 1178 1179 if (mdata->header.ncmds == 0) 1180 if (!bfd_mach_o_build_commands (abfd)) 1181 return FALSE; 1182 1183 /* Now write header information. */ 1184 if (mdata->header.filetype == 0) 1185 { 1186 if (abfd->flags & EXEC_P) 1187 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE; 1188 else if (abfd->flags & DYNAMIC) 1189 mdata->header.filetype = BFD_MACH_O_MH_DYLIB; 1190 else 1191 mdata->header.filetype = BFD_MACH_O_MH_OBJECT; 1192 } 1193 if (!bfd_mach_o_write_header (abfd, &mdata->header)) 1194 return FALSE; 1195 1196 /* Assign a number to each symbols. */ 1197 if (!bfd_mach_o_mangle_symbols (abfd)) 1198 return FALSE; 1199 1200 for (i = 0; i < mdata->header.ncmds; i++) 1201 { 1202 unsigned char buf[8]; 1203 bfd_mach_o_load_command *cur = &mdata->commands[i]; 1204 unsigned long typeflag; 1205 1206 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0); 1207 1208 bfd_h_put_32 (abfd, typeflag, buf); 1209 bfd_h_put_32 (abfd, cur->len, buf + 4); 1210 1211 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0 1212 || bfd_bwrite ((void *) buf, 8, abfd) != 8) 1213 return FALSE; 1214 1215 switch (cur->type) 1216 { 1217 case BFD_MACH_O_LC_SEGMENT: 1218 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0) 1219 return FALSE; 1220 break; 1221 case BFD_MACH_O_LC_SEGMENT_64: 1222 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0) 1223 return FALSE; 1224 break; 1225 case BFD_MACH_O_LC_SYMTAB: 1226 if (!bfd_mach_o_write_symtab (abfd, cur)) 1227 return FALSE; 1228 break; 1229 case BFD_MACH_O_LC_SYMSEG: 1230 break; 1231 case BFD_MACH_O_LC_THREAD: 1232 case BFD_MACH_O_LC_UNIXTHREAD: 1233 if (bfd_mach_o_write_thread (abfd, cur) != 0) 1234 return FALSE; 1235 break; 1236 case BFD_MACH_O_LC_LOADFVMLIB: 1237 case BFD_MACH_O_LC_IDFVMLIB: 1238 case BFD_MACH_O_LC_IDENT: 1239 case BFD_MACH_O_LC_FVMFILE: 1240 case BFD_MACH_O_LC_PREPAGE: 1241 case BFD_MACH_O_LC_DYSYMTAB: 1242 case BFD_MACH_O_LC_LOAD_DYLIB: 1243 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: 1244 case BFD_MACH_O_LC_ID_DYLIB: 1245 case BFD_MACH_O_LC_REEXPORT_DYLIB: 1246 case BFD_MACH_O_LC_LOAD_DYLINKER: 1247 case BFD_MACH_O_LC_ID_DYLINKER: 1248 case BFD_MACH_O_LC_PREBOUND_DYLIB: 1249 case BFD_MACH_O_LC_ROUTINES: 1250 case BFD_MACH_O_LC_SUB_FRAMEWORK: 1251 break; 1252 default: 1253 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"), 1254 (unsigned long) cur->type); 1255 return FALSE; 1256 } 1257 } 1258 1259 return TRUE; 1260 } 1261 1262 /* Build Mach-O load commands from the sections. */ 1263 1264 bfd_boolean 1265 bfd_mach_o_build_commands (bfd *abfd) 1266 { 1267 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 1268 unsigned int wide = mach_o_wide_p (&mdata->header); 1269 bfd_mach_o_segment_command *seg; 1270 bfd_mach_o_section *sections; 1271 asection *sec; 1272 bfd_mach_o_load_command *cmd; 1273 bfd_mach_o_load_command *symtab_cmd; 1274 int target_index; 1275 1276 /* Return now if commands are already built. */ 1277 if (mdata->header.ncmds) 1278 return FALSE; 1279 1280 /* Very simple version: 1 command (segment) containing all sections. */ 1281 mdata->header.ncmds = 2; 1282 mdata->commands = bfd_alloc (abfd, mdata->header.ncmds 1283 * sizeof (bfd_mach_o_load_command)); 1284 if (mdata->commands == NULL) 1285 return FALSE; 1286 cmd = &mdata->commands[0]; 1287 seg = &cmd->command.segment; 1288 1289 seg->nsects = bfd_count_sections (abfd); 1290 sections = bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section)); 1291 if (sections == NULL) 1292 return FALSE; 1293 seg->sections = sections; 1294 1295 /* Set segment command. */ 1296 if (wide) 1297 { 1298 cmd->type = BFD_MACH_O_LC_SEGMENT_64; 1299 cmd->offset = BFD_MACH_O_HEADER_64_SIZE; 1300 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE 1301 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects; 1302 } 1303 else 1304 { 1305 cmd->type = BFD_MACH_O_LC_SEGMENT; 1306 cmd->offset = BFD_MACH_O_HEADER_SIZE; 1307 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE 1308 + BFD_MACH_O_SECTION_SIZE * seg->nsects; 1309 } 1310 cmd->type_required = FALSE; 1311 mdata->header.sizeofcmds = cmd->len; 1312 mdata->filelen = cmd->offset + cmd->len; 1313 1314 /* Set symtab command. */ 1315 symtab_cmd = &mdata->commands[1]; 1316 1317 symtab_cmd->type = BFD_MACH_O_LC_SYMTAB; 1318 symtab_cmd->offset = cmd->offset + cmd->len; 1319 symtab_cmd->len = 6 * 4; 1320 symtab_cmd->type_required = FALSE; 1321 1322 mdata->header.sizeofcmds += symtab_cmd->len; 1323 mdata->filelen += symtab_cmd->len; 1324 1325 /* Fill segment command. */ 1326 memset (seg->segname, 0, sizeof (seg->segname)); 1327 seg->vmaddr = 0; 1328 seg->fileoff = mdata->filelen; 1329 seg->filesize = 0; 1330 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE 1331 | BFD_MACH_O_PROT_EXECUTE; 1332 seg->initprot = seg->maxprot; 1333 seg->flags = 0; 1334 1335 /* Create Mach-O sections. */ 1336 target_index = 0; 1337 for (sec = abfd->sections; sec; sec = sec->next) 1338 { 1339 sections->bfdsection = sec; 1340 bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, sections); 1341 sections->addr = bfd_get_section_vma (abfd, sec); 1342 sections->size = bfd_get_section_size (sec); 1343 sections->align = bfd_get_section_alignment (abfd, sec); 1344 1345 if (sections->size != 0) 1346 { 1347 mdata->filelen = FILE_ALIGN (mdata->filelen, sections->align); 1348 sections->offset = mdata->filelen; 1349 } 1350 else 1351 sections->offset = 0; 1352 sections->reloff = 0; 1353 sections->nreloc = 0; 1354 sections->reserved1 = 0; 1355 sections->reserved2 = 0; 1356 sections->reserved3 = 0; 1357 1358 sec->filepos = sections->offset; 1359 sec->target_index = ++target_index; 1360 1361 mdata->filelen += sections->size; 1362 sections++; 1363 } 1364 seg->filesize = mdata->filelen - seg->fileoff; 1365 seg->vmsize = seg->filesize; 1366 1367 return TRUE; 1368 } 1369 1370 /* Set the contents of a section. */ 1371 1372 bfd_boolean 1373 bfd_mach_o_set_section_contents (bfd *abfd, 1374 asection *section, 1375 const void * location, 1376 file_ptr offset, 1377 bfd_size_type count) 1378 { 1379 file_ptr pos; 1380 1381 /* This must be done first, because bfd_set_section_contents is 1382 going to set output_has_begun to TRUE. */ 1383 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd)) 1384 return FALSE; 1385 1386 if (count == 0) 1387 return TRUE; 1388 1389 pos = section->filepos + offset; 1390 if (bfd_seek (abfd, pos, SEEK_SET) != 0 1391 || bfd_bwrite (location, count, abfd) != count) 1392 return FALSE; 1393 1394 return TRUE; 1395 } 1396 1397 int 1398 bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED, 1399 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1400 { 1401 return 0; 1402 } 1403 1404 /* Make an empty symbol. This is required only because 1405 bfd_make_section_anyway wants to create a symbol for the section. */ 1406 1407 asymbol * 1408 bfd_mach_o_make_empty_symbol (bfd *abfd) 1409 { 1410 asymbol *new_symbol; 1411 1412 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol)); 1413 if (new_symbol == NULL) 1414 return new_symbol; 1415 new_symbol->the_bfd = abfd; 1416 new_symbol->udata.i = 0; 1417 return new_symbol; 1418 } 1419 1420 static bfd_boolean 1421 bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header) 1422 { 1423 unsigned char buf[32]; 1424 unsigned int size; 1425 bfd_vma (*get32) (const void *) = NULL; 1426 1427 /* Just read the magic number. */ 1428 if (bfd_seek (abfd, 0, SEEK_SET) != 0 1429 || bfd_bread ((void *) buf, 4, abfd) != 4) 1430 return FALSE; 1431 1432 if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC) 1433 { 1434 header->byteorder = BFD_ENDIAN_BIG; 1435 header->magic = BFD_MACH_O_MH_MAGIC; 1436 header->version = 1; 1437 get32 = bfd_getb32; 1438 } 1439 else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC) 1440 { 1441 header->byteorder = BFD_ENDIAN_LITTLE; 1442 header->magic = BFD_MACH_O_MH_MAGIC; 1443 header->version = 1; 1444 get32 = bfd_getl32; 1445 } 1446 else if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC_64) 1447 { 1448 header->byteorder = BFD_ENDIAN_BIG; 1449 header->magic = BFD_MACH_O_MH_MAGIC_64; 1450 header->version = 2; 1451 get32 = bfd_getb32; 1452 } 1453 else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC_64) 1454 { 1455 header->byteorder = BFD_ENDIAN_LITTLE; 1456 header->magic = BFD_MACH_O_MH_MAGIC_64; 1457 header->version = 2; 1458 get32 = bfd_getl32; 1459 } 1460 else 1461 { 1462 header->byteorder = BFD_ENDIAN_UNKNOWN; 1463 return FALSE; 1464 } 1465 1466 /* Once the size of the header is known, read the full header. */ 1467 size = mach_o_wide_p (header) ? 1468 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE; 1469 1470 if (bfd_seek (abfd, 0, SEEK_SET) != 0 1471 || bfd_bread ((void *) buf, size, abfd) != size) 1472 return FALSE; 1473 1474 header->cputype = (*get32) (buf + 4); 1475 header->cpusubtype = (*get32) (buf + 8); 1476 header->filetype = (*get32) (buf + 12); 1477 header->ncmds = (*get32) (buf + 16); 1478 header->sizeofcmds = (*get32) (buf + 20); 1479 header->flags = (*get32) (buf + 24); 1480 1481 if (mach_o_wide_p (header)) 1482 header->reserved = (*get32) (buf + 28); 1483 1484 return TRUE; 1485 } 1486 1487 static asection * 1488 bfd_mach_o_make_bfd_section (bfd *abfd, bfd_mach_o_section *section, 1489 unsigned long prot) 1490 { 1491 asection *bfdsec; 1492 char *sname; 1493 flagword flags; 1494 1495 bfd_mach_o_convert_section_name_to_bfd (abfd, section, &sname, &flags); 1496 if (sname == NULL) 1497 return NULL; 1498 1499 if (flags == SEC_NO_FLAGS) 1500 { 1501 /* Try to guess flags. */ 1502 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG) 1503 flags = SEC_DEBUGGING; 1504 else 1505 { 1506 flags = SEC_ALLOC; 1507 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK) 1508 != BFD_MACH_O_S_ZEROFILL) 1509 { 1510 flags |= SEC_LOAD; 1511 if (prot & BFD_MACH_O_PROT_EXECUTE) 1512 flags |= SEC_CODE; 1513 if (prot & BFD_MACH_O_PROT_WRITE) 1514 flags |= SEC_DATA; 1515 else if (prot & BFD_MACH_O_PROT_READ) 1516 flags |= SEC_READONLY; 1517 } 1518 } 1519 } 1520 else 1521 { 1522 if ((flags & SEC_DEBUGGING) == 0) 1523 flags |= SEC_ALLOC; 1524 } 1525 1526 if (section->offset != 0) 1527 flags |= SEC_HAS_CONTENTS; 1528 if (section->nreloc != 0) 1529 flags |= SEC_RELOC; 1530 1531 bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, flags); 1532 if (bfdsec == NULL) 1533 return NULL; 1534 1535 bfdsec->vma = section->addr; 1536 bfdsec->lma = section->addr; 1537 bfdsec->size = section->size; 1538 bfdsec->filepos = section->offset; 1539 bfdsec->alignment_power = section->align; 1540 bfdsec->segment_mark = 0; 1541 bfdsec->reloc_count = section->nreloc; 1542 bfdsec->rel_filepos = section->reloff; 1543 1544 return bfdsec; 1545 } 1546 1547 static int 1548 bfd_mach_o_read_section_32 (bfd *abfd, 1549 bfd_mach_o_section *section, 1550 unsigned int offset, 1551 unsigned long prot) 1552 { 1553 unsigned char buf[BFD_MACH_O_SECTION_SIZE]; 1554 1555 if (bfd_seek (abfd, offset, SEEK_SET) != 0 1556 || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd) 1557 != BFD_MACH_O_SECTION_SIZE)) 1558 return -1; 1559 1560 memcpy (section->sectname, buf, 16); 1561 section->sectname[16] = '\0'; 1562 memcpy (section->segname, buf + 16, 16); 1563 section->segname[16] = '\0'; 1564 section->addr = bfd_h_get_32 (abfd, buf + 32); 1565 section->size = bfd_h_get_32 (abfd, buf + 36); 1566 section->offset = bfd_h_get_32 (abfd, buf + 40); 1567 section->align = bfd_h_get_32 (abfd, buf + 44); 1568 section->reloff = bfd_h_get_32 (abfd, buf + 48); 1569 section->nreloc = bfd_h_get_32 (abfd, buf + 52); 1570 section->flags = bfd_h_get_32 (abfd, buf + 56); 1571 section->reserved1 = bfd_h_get_32 (abfd, buf + 60); 1572 section->reserved2 = bfd_h_get_32 (abfd, buf + 64); 1573 section->reserved3 = 0; 1574 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot); 1575 1576 if (section->bfdsection == NULL) 1577 return -1; 1578 1579 return 0; 1580 } 1581 1582 static int 1583 bfd_mach_o_read_section_64 (bfd *abfd, 1584 bfd_mach_o_section *section, 1585 unsigned int offset, 1586 unsigned long prot) 1587 { 1588 unsigned char buf[BFD_MACH_O_SECTION_64_SIZE]; 1589 1590 if (bfd_seek (abfd, offset, SEEK_SET) != 0 1591 || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd) 1592 != BFD_MACH_O_SECTION_64_SIZE)) 1593 return -1; 1594 1595 memcpy (section->sectname, buf, 16); 1596 section->sectname[16] = '\0'; 1597 memcpy (section->segname, buf + 16, 16); 1598 section->segname[16] = '\0'; 1599 section->addr = bfd_h_get_64 (abfd, buf + 32); 1600 section->size = bfd_h_get_64 (abfd, buf + 40); 1601 section->offset = bfd_h_get_32 (abfd, buf + 48); 1602 section->align = bfd_h_get_32 (abfd, buf + 52); 1603 section->reloff = bfd_h_get_32 (abfd, buf + 56); 1604 section->nreloc = bfd_h_get_32 (abfd, buf + 60); 1605 section->flags = bfd_h_get_32 (abfd, buf + 64); 1606 section->reserved1 = bfd_h_get_32 (abfd, buf + 68); 1607 section->reserved2 = bfd_h_get_32 (abfd, buf + 72); 1608 section->reserved3 = bfd_h_get_32 (abfd, buf + 76); 1609 section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot); 1610 1611 if (section->bfdsection == NULL) 1612 return -1; 1613 1614 return 0; 1615 } 1616 1617 static int 1618 bfd_mach_o_read_section (bfd *abfd, 1619 bfd_mach_o_section *section, 1620 unsigned int offset, 1621 unsigned long prot, 1622 unsigned int wide) 1623 { 1624 if (wide) 1625 return bfd_mach_o_read_section_64 (abfd, section, offset, prot); 1626 else 1627 return bfd_mach_o_read_section_32 (abfd, section, offset, prot); 1628 } 1629 1630 static int 1631 bfd_mach_o_read_symtab_symbol (bfd *abfd, 1632 bfd_mach_o_symtab_command *sym, 1633 bfd_mach_o_asymbol *s, 1634 unsigned long i) 1635 { 1636 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 1637 unsigned int wide = mach_o_wide_p (&mdata->header); 1638 unsigned int symwidth = 1639 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE; 1640 unsigned int symoff = sym->symoff + (i * symwidth); 1641 unsigned char buf[16]; 1642 unsigned char type = -1; 1643 unsigned char section = -1; 1644 short desc = -1; 1645 symvalue value = -1; 1646 unsigned long stroff = -1; 1647 unsigned int symtype = -1; 1648 1649 BFD_ASSERT (sym->strtab != NULL); 1650 1651 if (bfd_seek (abfd, symoff, SEEK_SET) != 0 1652 || bfd_bread ((void *) buf, symwidth, abfd) != symwidth) 1653 { 1654 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"), 1655 symwidth, (unsigned long) symoff); 1656 return -1; 1657 } 1658 1659 stroff = bfd_h_get_32 (abfd, buf); 1660 type = bfd_h_get_8 (abfd, buf + 4); 1661 symtype = type & BFD_MACH_O_N_TYPE; 1662 section = bfd_h_get_8 (abfd, buf + 5); 1663 desc = bfd_h_get_16 (abfd, buf + 6); 1664 if (wide) 1665 value = bfd_h_get_64 (abfd, buf + 8); 1666 else 1667 value = bfd_h_get_32 (abfd, buf + 8); 1668 1669 if (stroff >= sym->strsize) 1670 { 1671 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: symbol name out of range (%lu >= %lu)"), 1672 (unsigned long) stroff, 1673 (unsigned long) sym->strsize); 1674 return -1; 1675 } 1676 1677 s->symbol.the_bfd = abfd; 1678 s->symbol.name = sym->strtab + stroff; 1679 s->symbol.value = value; 1680 s->symbol.flags = 0x0; 1681 s->symbol.udata.i = 0; 1682 s->n_type = type; 1683 s->n_sect = section; 1684 s->n_desc = desc; 1685 1686 if (type & BFD_MACH_O_N_STAB) 1687 { 1688 s->symbol.flags |= BSF_DEBUGGING; 1689 s->symbol.section = bfd_und_section_ptr; 1690 switch (type) 1691 { 1692 case N_FUN: 1693 case N_STSYM: 1694 case N_LCSYM: 1695 case N_BNSYM: 1696 case N_SLINE: 1697 case N_ENSYM: 1698 case N_ECOMM: 1699 case N_ECOML: 1700 case N_GSYM: 1701 if ((section > 0) && (section <= mdata->nsects)) 1702 { 1703 s->symbol.section = mdata->sections[section - 1]->bfdsection; 1704 s->symbol.value = 1705 s->symbol.value - mdata->sections[section - 1]->addr; 1706 } 1707 break; 1708 } 1709 } 1710 else 1711 { 1712 if (type & BFD_MACH_O_N_PEXT) 1713 s->symbol.flags |= BSF_GLOBAL; 1714 1715 if (type & BFD_MACH_O_N_EXT) 1716 s->symbol.flags |= BSF_GLOBAL; 1717 1718 if (!(type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))) 1719 s->symbol.flags |= BSF_LOCAL; 1720 1721 switch (symtype) 1722 { 1723 case BFD_MACH_O_N_UNDF: 1724 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT) 1725 && s->symbol.value != 0) 1726 { 1727 /* A common symbol. */ 1728 s->symbol.section = bfd_com_section_ptr; 1729 s->symbol.flags = BSF_NO_FLAGS; 1730 } 1731 else 1732 { 1733 s->symbol.section = bfd_und_section_ptr; 1734 if (s->n_desc & BFD_MACH_O_N_WEAK_REF) 1735 s->symbol.flags |= BSF_WEAK; 1736 } 1737 break; 1738 case BFD_MACH_O_N_PBUD: 1739 s->symbol.section = bfd_und_section_ptr; 1740 break; 1741 case BFD_MACH_O_N_ABS: 1742 s->symbol.section = bfd_abs_section_ptr; 1743 break; 1744 case BFD_MACH_O_N_SECT: 1745 if ((section > 0) && (section <= mdata->nsects)) 1746 { 1747 s->symbol.section = mdata->sections[section - 1]->bfdsection; 1748 s->symbol.value = 1749 s->symbol.value - mdata->sections[section - 1]->addr; 1750 } 1751 else 1752 { 1753 /* Mach-O uses 0 to mean "no section"; not an error. */ 1754 if (section != 0) 1755 { 1756 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: " 1757 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"), 1758 s->symbol.name, section, mdata->nsects); 1759 } 1760 s->symbol.section = bfd_und_section_ptr; 1761 } 1762 break; 1763 case BFD_MACH_O_N_INDR: 1764 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: " 1765 "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined"), 1766 s->symbol.name); 1767 s->symbol.section = bfd_und_section_ptr; 1768 break; 1769 default: 1770 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: " 1771 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"), 1772 s->symbol.name, symtype); 1773 s->symbol.section = bfd_und_section_ptr; 1774 break; 1775 } 1776 } 1777 1778 return 0; 1779 } 1780 1781 static int 1782 bfd_mach_o_read_symtab_strtab (bfd *abfd) 1783 { 1784 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 1785 bfd_mach_o_symtab_command *sym = mdata->symtab; 1786 1787 /* Fail if there is no symtab. */ 1788 if (sym == NULL) 1789 return -1; 1790 1791 /* Success if already loaded. */ 1792 if (sym->strtab) 1793 return 0; 1794 1795 if (abfd->flags & BFD_IN_MEMORY) 1796 { 1797 struct bfd_in_memory *b; 1798 1799 b = (struct bfd_in_memory *) abfd->iostream; 1800 1801 if ((sym->stroff + sym->strsize) > b->size) 1802 { 1803 bfd_set_error (bfd_error_file_truncated); 1804 return -1; 1805 } 1806 sym->strtab = (char *) b->buffer + sym->stroff; 1807 } 1808 else 1809 { 1810 sym->strtab = bfd_alloc (abfd, sym->strsize); 1811 if (sym->strtab == NULL) 1812 return -1; 1813 1814 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0 1815 || bfd_bread ((void *) sym->strtab, sym->strsize, abfd) != sym->strsize) 1816 { 1817 bfd_set_error (bfd_error_file_truncated); 1818 return -1; 1819 } 1820 } 1821 1822 return 0; 1823 } 1824 1825 static int 1826 bfd_mach_o_read_symtab_symbols (bfd *abfd) 1827 { 1828 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 1829 bfd_mach_o_symtab_command *sym = mdata->symtab; 1830 unsigned long i; 1831 int ret; 1832 1833 if (sym->symbols) 1834 return 0; 1835 1836 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol)); 1837 1838 if (sym->symbols == NULL) 1839 { 1840 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols")); 1841 return -1; 1842 } 1843 1844 ret = bfd_mach_o_read_symtab_strtab (abfd); 1845 if (ret != 0) 1846 return ret; 1847 1848 for (i = 0; i < sym->nsyms; i++) 1849 { 1850 ret = bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i); 1851 if (ret != 0) 1852 return ret; 1853 } 1854 1855 return 0; 1856 } 1857 1858 int 1859 bfd_mach_o_read_dysymtab_symbol (bfd *abfd, 1860 bfd_mach_o_dysymtab_command *dysym, 1861 bfd_mach_o_symtab_command *sym, 1862 bfd_mach_o_asymbol *s, 1863 unsigned long i) 1864 { 1865 unsigned long isymoff = dysym->indirectsymoff + (i * 4); 1866 unsigned long sym_index; 1867 unsigned char buf[4]; 1868 1869 BFD_ASSERT (i < dysym->nindirectsyms); 1870 1871 if (bfd_seek (abfd, isymoff, SEEK_SET) != 0 1872 || bfd_bread ((void *) buf, 4, abfd) != 4) 1873 { 1874 (*_bfd_error_handler) (_("bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu"), 1875 (unsigned long) 4, isymoff); 1876 return -1; 1877 } 1878 sym_index = bfd_h_get_32 (abfd, buf); 1879 1880 return bfd_mach_o_read_symtab_symbol (abfd, sym, s, sym_index); 1881 } 1882 1883 static const char * 1884 bfd_mach_o_i386_flavour_string (unsigned int flavour) 1885 { 1886 switch ((int) flavour) 1887 { 1888 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32"; 1889 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32"; 1890 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32"; 1891 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64"; 1892 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64"; 1893 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64"; 1894 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE"; 1895 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE"; 1896 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE"; 1897 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32"; 1898 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64"; 1899 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE"; 1900 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE"; 1901 default: return "UNKNOWN"; 1902 } 1903 } 1904 1905 static const char * 1906 bfd_mach_o_ppc_flavour_string (unsigned int flavour) 1907 { 1908 switch ((int) flavour) 1909 { 1910 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE"; 1911 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE"; 1912 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE"; 1913 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE"; 1914 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64"; 1915 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64"; 1916 default: return "UNKNOWN"; 1917 } 1918 } 1919 1920 static int 1921 bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command) 1922 { 1923 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker; 1924 unsigned char buf[4]; 1925 unsigned int nameoff; 1926 1927 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER) 1928 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)); 1929 1930 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 1931 || bfd_bread ((void *) buf, 4, abfd) != 4) 1932 return -1; 1933 1934 nameoff = bfd_h_get_32 (abfd, buf + 0); 1935 1936 cmd->name_offset = command->offset + nameoff; 1937 cmd->name_len = command->len - nameoff; 1938 cmd->name_str = bfd_alloc (abfd, cmd->name_len); 1939 if (cmd->name_str == NULL) 1940 return -1; 1941 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0 1942 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len) 1943 return -1; 1944 return 0; 1945 } 1946 1947 static int 1948 bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command) 1949 { 1950 bfd_mach_o_dylib_command *cmd = &command->command.dylib; 1951 unsigned char buf[16]; 1952 unsigned int nameoff; 1953 1954 switch (command->type) 1955 { 1956 case BFD_MACH_O_LC_LOAD_DYLIB: 1957 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: 1958 case BFD_MACH_O_LC_ID_DYLIB: 1959 case BFD_MACH_O_LC_REEXPORT_DYLIB: 1960 break; 1961 default: 1962 BFD_FAIL (); 1963 return -1; 1964 } 1965 1966 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 1967 || bfd_bread ((void *) buf, 16, abfd) != 16) 1968 return -1; 1969 1970 nameoff = bfd_h_get_32 (abfd, buf + 0); 1971 cmd->timestamp = bfd_h_get_32 (abfd, buf + 4); 1972 cmd->current_version = bfd_h_get_32 (abfd, buf + 8); 1973 cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12); 1974 1975 cmd->name_offset = command->offset + nameoff; 1976 cmd->name_len = command->len - nameoff; 1977 cmd->name_str = bfd_alloc (abfd, cmd->name_len); 1978 if (cmd->name_str == NULL) 1979 return -1; 1980 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0 1981 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len) 1982 return -1; 1983 return 0; 1984 } 1985 1986 static int 1987 bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED, 1988 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED) 1989 { 1990 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */ 1991 1992 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB); 1993 return 0; 1994 } 1995 1996 static int 1997 bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command) 1998 { 1999 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 2000 bfd_mach_o_thread_command *cmd = &command->command.thread; 2001 unsigned char buf[8]; 2002 unsigned int offset; 2003 unsigned int nflavours; 2004 unsigned int i; 2005 2006 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD) 2007 || (command->type == BFD_MACH_O_LC_UNIXTHREAD)); 2008 2009 /* Count the number of threads. */ 2010 offset = 8; 2011 nflavours = 0; 2012 while (offset != command->len) 2013 { 2014 if (offset >= command->len) 2015 return -1; 2016 2017 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0 2018 || bfd_bread ((void *) buf, 8, abfd) != 8) 2019 return -1; 2020 2021 offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4; 2022 nflavours++; 2023 } 2024 2025 /* Allocate threads. */ 2026 cmd->flavours = bfd_alloc 2027 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour)); 2028 if (cmd->flavours == NULL) 2029 return -1; 2030 cmd->nflavours = nflavours; 2031 2032 offset = 8; 2033 nflavours = 0; 2034 while (offset != command->len) 2035 { 2036 if (offset >= command->len) 2037 return -1; 2038 2039 if (nflavours >= cmd->nflavours) 2040 return -1; 2041 2042 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0 2043 || bfd_bread ((void *) buf, 8, abfd) != 8) 2044 return -1; 2045 2046 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf); 2047 cmd->flavours[nflavours].offset = command->offset + offset + 8; 2048 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4; 2049 offset += cmd->flavours[nflavours].size + 8; 2050 nflavours++; 2051 } 2052 2053 for (i = 0; i < nflavours; i++) 2054 { 2055 asection *bfdsec; 2056 unsigned int snamelen; 2057 char *sname; 2058 const char *flavourstr; 2059 const char *prefix = "LC_THREAD"; 2060 unsigned int j = 0; 2061 2062 switch (mdata->header.cputype) 2063 { 2064 case BFD_MACH_O_CPU_TYPE_POWERPC: 2065 case BFD_MACH_O_CPU_TYPE_POWERPC_64: 2066 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour); 2067 break; 2068 case BFD_MACH_O_CPU_TYPE_I386: 2069 case BFD_MACH_O_CPU_TYPE_X86_64: 2070 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour); 2071 break; 2072 default: 2073 flavourstr = "UNKNOWN_ARCHITECTURE"; 2074 break; 2075 } 2076 2077 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1; 2078 sname = bfd_alloc (abfd, snamelen); 2079 if (sname == NULL) 2080 return -1; 2081 2082 for (;;) 2083 { 2084 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j); 2085 if (bfd_get_section_by_name (abfd, sname) == NULL) 2086 break; 2087 j++; 2088 } 2089 2090 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS); 2091 2092 bfdsec->vma = 0; 2093 bfdsec->lma = 0; 2094 bfdsec->size = cmd->flavours[i].size; 2095 bfdsec->filepos = cmd->flavours[i].offset; 2096 bfdsec->alignment_power = 0x0; 2097 2098 cmd->section = bfdsec; 2099 } 2100 2101 return 0; 2102 } 2103 2104 static int 2105 bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command) 2106 { 2107 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab; 2108 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 2109 unsigned char buf[72]; 2110 2111 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB); 2112 2113 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2114 || bfd_bread ((void *) buf, 72, abfd) != 72) 2115 return -1; 2116 2117 cmd->ilocalsym = bfd_h_get_32 (abfd, buf + 0); 2118 cmd->nlocalsym = bfd_h_get_32 (abfd, buf + 4); 2119 cmd->iextdefsym = bfd_h_get_32 (abfd, buf + 8); 2120 cmd->nextdefsym = bfd_h_get_32 (abfd, buf + 12); 2121 cmd->iundefsym = bfd_h_get_32 (abfd, buf + 16); 2122 cmd->nundefsym = bfd_h_get_32 (abfd, buf + 20); 2123 cmd->tocoff = bfd_h_get_32 (abfd, buf + 24); 2124 cmd->ntoc = bfd_h_get_32 (abfd, buf + 28); 2125 cmd->modtaboff = bfd_h_get_32 (abfd, buf + 32); 2126 cmd->nmodtab = bfd_h_get_32 (abfd, buf + 36); 2127 cmd->extrefsymoff = bfd_h_get_32 (abfd, buf + 40); 2128 cmd->nextrefsyms = bfd_h_get_32 (abfd, buf + 44); 2129 cmd->indirectsymoff = bfd_h_get_32 (abfd, buf + 48); 2130 cmd->nindirectsyms = bfd_h_get_32 (abfd, buf + 52); 2131 cmd->extreloff = bfd_h_get_32 (abfd, buf + 56); 2132 cmd->nextrel = bfd_h_get_32 (abfd, buf + 60); 2133 cmd->locreloff = bfd_h_get_32 (abfd, buf + 64); 2134 cmd->nlocrel = bfd_h_get_32 (abfd, buf + 68); 2135 2136 if (cmd->nmodtab != 0) 2137 { 2138 unsigned int i; 2139 int wide = bfd_mach_o_wide_p (abfd); 2140 unsigned int module_len = wide ? 56 : 52; 2141 2142 cmd->dylib_module = 2143 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module)); 2144 if (cmd->dylib_module == NULL) 2145 return -1; 2146 2147 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0) 2148 return -1; 2149 2150 for (i = 0; i < cmd->nmodtab; i++) 2151 { 2152 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i]; 2153 unsigned long v; 2154 2155 if (bfd_bread ((void *) buf, module_len, abfd) != module_len) 2156 return -1; 2157 2158 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0); 2159 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4); 2160 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8); 2161 module->irefsym = bfd_h_get_32 (abfd, buf + 12); 2162 module->nrefsym = bfd_h_get_32 (abfd, buf + 16); 2163 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20); 2164 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24); 2165 module->iextrel = bfd_h_get_32 (abfd, buf + 28); 2166 module->nextrel = bfd_h_get_32 (abfd, buf + 32); 2167 v = bfd_h_get_32 (abfd, buf +36); 2168 module->iinit = v & 0xffff; 2169 module->iterm = (v >> 16) & 0xffff; 2170 v = bfd_h_get_32 (abfd, buf + 40); 2171 module->ninit = v & 0xffff; 2172 module->nterm = (v >> 16) & 0xffff; 2173 if (wide) 2174 { 2175 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44); 2176 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48); 2177 } 2178 else 2179 { 2180 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44); 2181 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48); 2182 } 2183 } 2184 } 2185 2186 if (cmd->ntoc != 0) 2187 { 2188 unsigned int i; 2189 2190 cmd->dylib_toc = bfd_alloc 2191 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content)); 2192 if (cmd->dylib_toc == NULL) 2193 return -1; 2194 2195 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0) 2196 return -1; 2197 2198 for (i = 0; i < cmd->ntoc; i++) 2199 { 2200 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i]; 2201 2202 if (bfd_bread ((void *) buf, 8, abfd) != 8) 2203 return -1; 2204 2205 toc->symbol_index = bfd_h_get_32 (abfd, buf + 0); 2206 toc->module_index = bfd_h_get_32 (abfd, buf + 4); 2207 } 2208 } 2209 2210 if (cmd->nindirectsyms != 0) 2211 { 2212 unsigned int i; 2213 2214 cmd->indirect_syms = bfd_alloc 2215 (abfd, cmd->nindirectsyms * sizeof (unsigned int)); 2216 if (cmd->indirect_syms == NULL) 2217 return -1; 2218 2219 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0) 2220 return -1; 2221 2222 for (i = 0; i < cmd->nindirectsyms; i++) 2223 { 2224 unsigned int *is = &cmd->indirect_syms[i]; 2225 2226 if (bfd_bread ((void *) buf, 4, abfd) != 4) 2227 return -1; 2228 2229 *is = bfd_h_get_32 (abfd, buf + 0); 2230 } 2231 } 2232 2233 if (cmd->nextrefsyms != 0) 2234 { 2235 unsigned long v; 2236 unsigned int i; 2237 2238 cmd->ext_refs = bfd_alloc 2239 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference)); 2240 if (cmd->ext_refs == NULL) 2241 return -1; 2242 2243 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0) 2244 return -1; 2245 2246 for (i = 0; i < cmd->nextrefsyms; i++) 2247 { 2248 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i]; 2249 2250 if (bfd_bread ((void *) buf, 4, abfd) != 4) 2251 return -1; 2252 2253 /* Fields isym and flags are written as bit-fields, thus we need 2254 a specific processing for endianness. */ 2255 v = bfd_h_get_32 (abfd, buf + 0); 2256 if (bfd_big_endian (abfd)) 2257 { 2258 ref->isym = (v >> 8) & 0xffffff; 2259 ref->flags = v & 0xff; 2260 } 2261 else 2262 { 2263 ref->isym = v & 0xffffff; 2264 ref->flags = (v >> 24) & 0xff; 2265 } 2266 } 2267 } 2268 2269 if (mdata->dysymtab) 2270 return -1; 2271 mdata->dysymtab = cmd; 2272 2273 return 0; 2274 } 2275 2276 static int 2277 bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command) 2278 { 2279 bfd_mach_o_symtab_command *symtab = &command->command.symtab; 2280 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 2281 unsigned char buf[16]; 2282 2283 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB); 2284 2285 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2286 || bfd_bread ((void *) buf, 16, abfd) != 16) 2287 return -1; 2288 2289 symtab->symoff = bfd_h_get_32 (abfd, buf); 2290 symtab->nsyms = bfd_h_get_32 (abfd, buf + 4); 2291 symtab->stroff = bfd_h_get_32 (abfd, buf + 8); 2292 symtab->strsize = bfd_h_get_32 (abfd, buf + 12); 2293 symtab->symbols = NULL; 2294 symtab->strtab = NULL; 2295 2296 if (symtab->nsyms != 0) 2297 abfd->flags |= HAS_SYMS; 2298 2299 if (mdata->symtab) 2300 return -1; 2301 mdata->symtab = symtab; 2302 return 0; 2303 } 2304 2305 static int 2306 bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command) 2307 { 2308 bfd_mach_o_uuid_command *cmd = &command->command.uuid; 2309 2310 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID); 2311 2312 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2313 || bfd_bread ((void *) cmd->uuid, 16, abfd) != 16) 2314 return -1; 2315 2316 return 0; 2317 } 2318 2319 static int 2320 bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command) 2321 { 2322 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit; 2323 char buf[8]; 2324 2325 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2326 || bfd_bread ((void *) buf, 8, abfd) != 8) 2327 return -1; 2328 2329 cmd->dataoff = bfd_get_32 (abfd, buf + 0); 2330 cmd->datasize = bfd_get_32 (abfd, buf + 4); 2331 return 0; 2332 } 2333 2334 static int 2335 bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command) 2336 { 2337 bfd_mach_o_str_command *cmd = &command->command.str; 2338 char buf[4]; 2339 unsigned long off; 2340 2341 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2342 || bfd_bread ((void *) buf, 4, abfd) != 4) 2343 return -1; 2344 2345 off = bfd_get_32 (abfd, buf + 0); 2346 cmd->stroff = command->offset + off; 2347 cmd->str_len = command->len - off; 2348 cmd->str = bfd_alloc (abfd, cmd->str_len); 2349 if (cmd->str == NULL) 2350 return -1; 2351 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0 2352 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len) 2353 return -1; 2354 return 0; 2355 } 2356 2357 static int 2358 bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command) 2359 { 2360 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info; 2361 char buf[40]; 2362 2363 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2364 || bfd_bread ((void *) buf, sizeof (buf), abfd) != sizeof (buf)) 2365 return -1; 2366 2367 cmd->rebase_off = bfd_get_32 (abfd, buf + 0); 2368 cmd->rebase_size = bfd_get_32 (abfd, buf + 4); 2369 cmd->bind_off = bfd_get_32 (abfd, buf + 8); 2370 cmd->bind_size = bfd_get_32 (abfd, buf + 12); 2371 cmd->weak_bind_off = bfd_get_32 (abfd, buf + 16); 2372 cmd->weak_bind_size = bfd_get_32 (abfd, buf + 20); 2373 cmd->lazy_bind_off = bfd_get_32 (abfd, buf + 24); 2374 cmd->lazy_bind_size = bfd_get_32 (abfd, buf + 28); 2375 cmd->export_off = bfd_get_32 (abfd, buf + 32); 2376 cmd->export_size = bfd_get_32 (abfd, buf + 36); 2377 return 0; 2378 } 2379 2380 static int 2381 bfd_mach_o_read_segment (bfd *abfd, 2382 bfd_mach_o_load_command *command, 2383 unsigned int wide) 2384 { 2385 unsigned char buf[64]; 2386 bfd_mach_o_segment_command *seg = &command->command.segment; 2387 unsigned long i; 2388 2389 if (wide) 2390 { 2391 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64); 2392 2393 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2394 || bfd_bread ((void *) buf, 64, abfd) != 64) 2395 return -1; 2396 2397 memcpy (seg->segname, buf, 16); 2398 seg->segname[16] = '\0'; 2399 2400 seg->vmaddr = bfd_h_get_64 (abfd, buf + 16); 2401 seg->vmsize = bfd_h_get_64 (abfd, buf + 24); 2402 seg->fileoff = bfd_h_get_64 (abfd, buf + 32); 2403 seg->filesize = bfd_h_get_64 (abfd, buf + 40); 2404 seg->maxprot = bfd_h_get_32 (abfd, buf + 48); 2405 seg->initprot = bfd_h_get_32 (abfd, buf + 52); 2406 seg->nsects = bfd_h_get_32 (abfd, buf + 56); 2407 seg->flags = bfd_h_get_32 (abfd, buf + 60); 2408 } 2409 else 2410 { 2411 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT); 2412 2413 if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0 2414 || bfd_bread ((void *) buf, 48, abfd) != 48) 2415 return -1; 2416 2417 memcpy (seg->segname, buf, 16); 2418 seg->segname[16] = '\0'; 2419 2420 seg->vmaddr = bfd_h_get_32 (abfd, buf + 16); 2421 seg->vmsize = bfd_h_get_32 (abfd, buf + 20); 2422 seg->fileoff = bfd_h_get_32 (abfd, buf + 24); 2423 seg->filesize = bfd_h_get_32 (abfd, buf + 28); 2424 seg->maxprot = bfd_h_get_32 (abfd, buf + 32); 2425 seg->initprot = bfd_h_get_32 (abfd, buf + 36); 2426 seg->nsects = bfd_h_get_32 (abfd, buf + 40); 2427 seg->flags = bfd_h_get_32 (abfd, buf + 44); 2428 } 2429 2430 if (seg->nsects != 0) 2431 { 2432 seg->sections = bfd_alloc (abfd, seg->nsects 2433 * sizeof (bfd_mach_o_section)); 2434 if (seg->sections == NULL) 2435 return -1; 2436 2437 for (i = 0; i < seg->nsects; i++) 2438 { 2439 bfd_vma segoff; 2440 if (wide) 2441 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE 2442 + (i * BFD_MACH_O_SECTION_64_SIZE); 2443 else 2444 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE 2445 + (i * BFD_MACH_O_SECTION_SIZE); 2446 2447 if (bfd_mach_o_read_section 2448 (abfd, &seg->sections[i], segoff, seg->initprot, wide) != 0) 2449 return -1; 2450 } 2451 } 2452 2453 return 0; 2454 } 2455 2456 static int 2457 bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command) 2458 { 2459 return bfd_mach_o_read_segment (abfd, command, 0); 2460 } 2461 2462 static int 2463 bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command) 2464 { 2465 return bfd_mach_o_read_segment (abfd, command, 1); 2466 } 2467 2468 static int 2469 bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command) 2470 { 2471 unsigned char buf[8]; 2472 2473 /* Read command type and length. */ 2474 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0 2475 || bfd_bread ((void *) buf, 8, abfd) != 8) 2476 return -1; 2477 2478 command->type = bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD; 2479 command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD 2480 ? TRUE : FALSE); 2481 command->len = bfd_h_get_32 (abfd, buf + 4); 2482 2483 switch (command->type) 2484 { 2485 case BFD_MACH_O_LC_SEGMENT: 2486 if (bfd_mach_o_read_segment_32 (abfd, command) != 0) 2487 return -1; 2488 break; 2489 case BFD_MACH_O_LC_SEGMENT_64: 2490 if (bfd_mach_o_read_segment_64 (abfd, command) != 0) 2491 return -1; 2492 break; 2493 case BFD_MACH_O_LC_SYMTAB: 2494 if (bfd_mach_o_read_symtab (abfd, command) != 0) 2495 return -1; 2496 break; 2497 case BFD_MACH_O_LC_SYMSEG: 2498 break; 2499 case BFD_MACH_O_LC_THREAD: 2500 case BFD_MACH_O_LC_UNIXTHREAD: 2501 if (bfd_mach_o_read_thread (abfd, command) != 0) 2502 return -1; 2503 break; 2504 case BFD_MACH_O_LC_LOAD_DYLINKER: 2505 case BFD_MACH_O_LC_ID_DYLINKER: 2506 if (bfd_mach_o_read_dylinker (abfd, command) != 0) 2507 return -1; 2508 break; 2509 case BFD_MACH_O_LC_LOAD_DYLIB: 2510 case BFD_MACH_O_LC_ID_DYLIB: 2511 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: 2512 case BFD_MACH_O_LC_REEXPORT_DYLIB: 2513 if (bfd_mach_o_read_dylib (abfd, command) != 0) 2514 return -1; 2515 break; 2516 case BFD_MACH_O_LC_PREBOUND_DYLIB: 2517 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0) 2518 return -1; 2519 break; 2520 case BFD_MACH_O_LC_LOADFVMLIB: 2521 case BFD_MACH_O_LC_IDFVMLIB: 2522 case BFD_MACH_O_LC_IDENT: 2523 case BFD_MACH_O_LC_FVMFILE: 2524 case BFD_MACH_O_LC_PREPAGE: 2525 case BFD_MACH_O_LC_ROUTINES: 2526 break; 2527 case BFD_MACH_O_LC_SUB_FRAMEWORK: 2528 case BFD_MACH_O_LC_SUB_UMBRELLA: 2529 case BFD_MACH_O_LC_SUB_LIBRARY: 2530 case BFD_MACH_O_LC_SUB_CLIENT: 2531 case BFD_MACH_O_LC_RPATH: 2532 if (bfd_mach_o_read_str (abfd, command) != 0) 2533 return -1; 2534 break; 2535 case BFD_MACH_O_LC_DYSYMTAB: 2536 if (bfd_mach_o_read_dysymtab (abfd, command) != 0) 2537 return -1; 2538 break; 2539 case BFD_MACH_O_LC_TWOLEVEL_HINTS: 2540 case BFD_MACH_O_LC_PREBIND_CKSUM: 2541 break; 2542 case BFD_MACH_O_LC_UUID: 2543 if (bfd_mach_o_read_uuid (abfd, command) != 0) 2544 return -1; 2545 break; 2546 case BFD_MACH_O_LC_CODE_SIGNATURE: 2547 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO: 2548 if (bfd_mach_o_read_linkedit (abfd, command) != 0) 2549 return -1; 2550 break; 2551 case BFD_MACH_O_LC_DYLD_INFO: 2552 if (bfd_mach_o_read_dyld_info (abfd, command) != 0) 2553 return -1; 2554 break; 2555 default: 2556 (*_bfd_error_handler) (_("unable to read unknown load command 0x%lx"), 2557 (unsigned long) command->type); 2558 break; 2559 } 2560 2561 return 0; 2562 } 2563 2564 static void 2565 bfd_mach_o_flatten_sections (bfd *abfd) 2566 { 2567 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 2568 long csect = 0; 2569 unsigned long i, j; 2570 2571 /* Count total number of sections. */ 2572 mdata->nsects = 0; 2573 2574 for (i = 0; i < mdata->header.ncmds; i++) 2575 { 2576 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT 2577 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64) 2578 { 2579 bfd_mach_o_segment_command *seg; 2580 2581 seg = &mdata->commands[i].command.segment; 2582 mdata->nsects += seg->nsects; 2583 } 2584 } 2585 2586 /* Allocate sections array. */ 2587 mdata->sections = bfd_alloc (abfd, 2588 mdata->nsects * sizeof (bfd_mach_o_section *)); 2589 2590 /* Fill the array. */ 2591 csect = 0; 2592 2593 for (i = 0; i < mdata->header.ncmds; i++) 2594 { 2595 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT 2596 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64) 2597 { 2598 bfd_mach_o_segment_command *seg; 2599 2600 seg = &mdata->commands[i].command.segment; 2601 BFD_ASSERT (csect + seg->nsects <= mdata->nsects); 2602 2603 for (j = 0; j < seg->nsects; j++) 2604 mdata->sections[csect++] = &seg->sections[j]; 2605 } 2606 } 2607 } 2608 2609 int 2610 bfd_mach_o_scan_start_address (bfd *abfd) 2611 { 2612 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 2613 bfd_mach_o_thread_command *cmd = NULL; 2614 unsigned long i; 2615 2616 for (i = 0; i < mdata->header.ncmds; i++) 2617 { 2618 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) || 2619 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD)) 2620 { 2621 if (cmd == NULL) 2622 cmd = &mdata->commands[i].command.thread; 2623 else 2624 return 0; 2625 } 2626 } 2627 2628 if (cmd == NULL) 2629 return 0; 2630 2631 for (i = 0; i < cmd->nflavours; i++) 2632 { 2633 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386) 2634 && (cmd->flavours[i].flavour 2635 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32)) 2636 { 2637 unsigned char buf[4]; 2638 2639 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0 2640 || bfd_bread (buf, 4, abfd) != 4) 2641 return -1; 2642 2643 abfd->start_address = bfd_h_get_32 (abfd, buf); 2644 } 2645 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC) 2646 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE)) 2647 { 2648 unsigned char buf[4]; 2649 2650 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0 2651 || bfd_bread (buf, 4, abfd) != 4) 2652 return -1; 2653 2654 abfd->start_address = bfd_h_get_32 (abfd, buf); 2655 } 2656 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64) 2657 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64)) 2658 { 2659 unsigned char buf[8]; 2660 2661 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0 2662 || bfd_bread (buf, 8, abfd) != 8) 2663 return -1; 2664 2665 abfd->start_address = bfd_h_get_64 (abfd, buf); 2666 } 2667 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64) 2668 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64)) 2669 { 2670 unsigned char buf[8]; 2671 2672 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0 2673 || bfd_bread (buf, 8, abfd) != 8) 2674 return -1; 2675 2676 abfd->start_address = bfd_h_get_64 (abfd, buf); 2677 } 2678 } 2679 2680 return 0; 2681 } 2682 2683 bfd_boolean 2684 bfd_mach_o_set_arch_mach (bfd *abfd, 2685 enum bfd_architecture arch, 2686 unsigned long machine) 2687 { 2688 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); 2689 2690 /* If this isn't the right architecture for this backend, and this 2691 isn't the generic backend, fail. */ 2692 if (arch != bed->arch 2693 && arch != bfd_arch_unknown 2694 && bed->arch != bfd_arch_unknown) 2695 return FALSE; 2696 2697 return bfd_default_set_arch_mach (abfd, arch, machine); 2698 } 2699 2700 int 2701 bfd_mach_o_scan (bfd *abfd, 2702 bfd_mach_o_header *header, 2703 bfd_mach_o_data_struct *mdata) 2704 { 2705 unsigned int i; 2706 enum bfd_architecture cputype; 2707 unsigned long cpusubtype; 2708 unsigned int hdrsize; 2709 2710 hdrsize = mach_o_wide_p (header) ? 2711 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE; 2712 2713 mdata->header = *header; 2714 2715 abfd->flags = abfd->flags & BFD_IN_MEMORY; 2716 switch (header->filetype) 2717 { 2718 case BFD_MACH_O_MH_OBJECT: 2719 abfd->flags |= HAS_RELOC; 2720 break; 2721 case BFD_MACH_O_MH_EXECUTE: 2722 abfd->flags |= EXEC_P; 2723 break; 2724 case BFD_MACH_O_MH_DYLIB: 2725 case BFD_MACH_O_MH_BUNDLE: 2726 abfd->flags |= DYNAMIC; 2727 break; 2728 } 2729 2730 abfd->tdata.mach_o_data = mdata; 2731 2732 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype, 2733 &cputype, &cpusubtype); 2734 if (cputype == bfd_arch_unknown) 2735 { 2736 (*_bfd_error_handler) (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"), 2737 header->cputype, header->cpusubtype); 2738 return -1; 2739 } 2740 2741 bfd_set_arch_mach (abfd, cputype, cpusubtype); 2742 2743 if (header->ncmds != 0) 2744 { 2745 mdata->commands = bfd_alloc 2746 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command)); 2747 if (mdata->commands == NULL) 2748 return -1; 2749 2750 for (i = 0; i < header->ncmds; i++) 2751 { 2752 bfd_mach_o_load_command *cur = &mdata->commands[i]; 2753 2754 if (i == 0) 2755 cur->offset = hdrsize; 2756 else 2757 { 2758 bfd_mach_o_load_command *prev = &mdata->commands[i - 1]; 2759 cur->offset = prev->offset + prev->len; 2760 } 2761 2762 if (bfd_mach_o_read_command (abfd, cur) < 0) 2763 return -1; 2764 } 2765 } 2766 2767 if (bfd_mach_o_scan_start_address (abfd) < 0) 2768 return -1; 2769 2770 bfd_mach_o_flatten_sections (abfd); 2771 return 0; 2772 } 2773 2774 bfd_boolean 2775 bfd_mach_o_mkobject_init (bfd *abfd) 2776 { 2777 bfd_mach_o_data_struct *mdata = NULL; 2778 2779 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct)); 2780 if (mdata == NULL) 2781 return FALSE; 2782 abfd->tdata.mach_o_data = mdata; 2783 2784 mdata->header.magic = 0; 2785 mdata->header.cputype = 0; 2786 mdata->header.cpusubtype = 0; 2787 mdata->header.filetype = 0; 2788 mdata->header.ncmds = 0; 2789 mdata->header.sizeofcmds = 0; 2790 mdata->header.flags = 0; 2791 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN; 2792 mdata->commands = NULL; 2793 mdata->nsects = 0; 2794 mdata->sections = NULL; 2795 2796 return TRUE; 2797 } 2798 2799 static bfd_boolean 2800 bfd_mach_o_gen_mkobject (bfd *abfd) 2801 { 2802 bfd_mach_o_data_struct *mdata; 2803 2804 if (!bfd_mach_o_mkobject_init (abfd)) 2805 return FALSE; 2806 2807 mdata = bfd_mach_o_get_data (abfd); 2808 mdata->header.magic = BFD_MACH_O_MH_MAGIC; 2809 mdata->header.cputype = 0; 2810 mdata->header.cpusubtype = 0; 2811 mdata->header.byteorder = abfd->xvec->byteorder; 2812 mdata->header.version = 1; 2813 2814 return TRUE; 2815 } 2816 2817 const bfd_target * 2818 bfd_mach_o_header_p (bfd *abfd, 2819 bfd_mach_o_filetype filetype, 2820 bfd_mach_o_cpu_type cputype) 2821 { 2822 struct bfd_preserve preserve; 2823 bfd_mach_o_header header; 2824 2825 preserve.marker = NULL; 2826 if (!bfd_mach_o_read_header (abfd, &header)) 2827 goto wrong; 2828 2829 if (! (header.byteorder == BFD_ENDIAN_BIG 2830 || header.byteorder == BFD_ENDIAN_LITTLE)) 2831 { 2832 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"), 2833 (unsigned long) header.byteorder); 2834 goto wrong; 2835 } 2836 2837 if (! ((header.byteorder == BFD_ENDIAN_BIG 2838 && abfd->xvec->byteorder == BFD_ENDIAN_BIG 2839 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG) 2840 || (header.byteorder == BFD_ENDIAN_LITTLE 2841 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE 2842 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE))) 2843 goto wrong; 2844 2845 /* Check cputype and filetype. 2846 In case of wildcard, do not accept magics that are handled by existing 2847 targets. */ 2848 if (cputype) 2849 { 2850 if (header.cputype != cputype) 2851 goto wrong; 2852 } 2853 else 2854 { 2855 switch (header.cputype) 2856 { 2857 case BFD_MACH_O_CPU_TYPE_I386: 2858 /* Handled by mach-o-i386 */ 2859 goto wrong; 2860 default: 2861 break; 2862 } 2863 } 2864 if (filetype) 2865 { 2866 if (header.filetype != filetype) 2867 goto wrong; 2868 } 2869 else 2870 { 2871 switch (header.filetype) 2872 { 2873 case BFD_MACH_O_MH_CORE: 2874 /* Handled by core_p */ 2875 goto wrong; 2876 default: 2877 break; 2878 } 2879 } 2880 2881 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct)); 2882 if (preserve.marker == NULL 2883 || !bfd_preserve_save (abfd, &preserve)) 2884 goto fail; 2885 2886 if (bfd_mach_o_scan (abfd, &header, 2887 (bfd_mach_o_data_struct *) preserve.marker) != 0) 2888 goto wrong; 2889 2890 bfd_preserve_finish (abfd, &preserve); 2891 return abfd->xvec; 2892 2893 wrong: 2894 bfd_set_error (bfd_error_wrong_format); 2895 2896 fail: 2897 if (preserve.marker != NULL) 2898 bfd_preserve_restore (abfd, &preserve); 2899 return NULL; 2900 } 2901 2902 static const bfd_target * 2903 bfd_mach_o_gen_object_p (bfd *abfd) 2904 { 2905 return bfd_mach_o_header_p (abfd, 0, 0); 2906 } 2907 2908 static const bfd_target * 2909 bfd_mach_o_gen_core_p (bfd *abfd) 2910 { 2911 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0); 2912 } 2913 2914 typedef struct mach_o_fat_archentry 2915 { 2916 unsigned long cputype; 2917 unsigned long cpusubtype; 2918 unsigned long offset; 2919 unsigned long size; 2920 unsigned long align; 2921 } mach_o_fat_archentry; 2922 2923 typedef struct mach_o_fat_data_struct 2924 { 2925 unsigned long magic; 2926 unsigned long nfat_arch; 2927 mach_o_fat_archentry *archentries; 2928 } mach_o_fat_data_struct; 2929 2930 const bfd_target * 2931 bfd_mach_o_archive_p (bfd *abfd) 2932 { 2933 mach_o_fat_data_struct *adata = NULL; 2934 unsigned char buf[20]; 2935 unsigned long i; 2936 2937 if (bfd_seek (abfd, 0, SEEK_SET) != 0 2938 || bfd_bread ((void *) buf, 8, abfd) != 8) 2939 goto error; 2940 2941 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct)); 2942 if (adata == NULL) 2943 goto error; 2944 2945 adata->magic = bfd_getb32 (buf); 2946 adata->nfat_arch = bfd_getb32 (buf + 4); 2947 if (adata->magic != 0xcafebabe) 2948 goto error; 2949 /* Avoid matching Java bytecode files, which have the same magic number. 2950 In the Java bytecode file format this field contains the JVM version, 2951 which starts at 43.0. */ 2952 if (adata->nfat_arch > 30) 2953 goto error; 2954 2955 adata->archentries = 2956 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry)); 2957 if (adata->archentries == NULL) 2958 goto error; 2959 2960 for (i = 0; i < adata->nfat_arch; i++) 2961 { 2962 if (bfd_seek (abfd, 8 + 20 * i, SEEK_SET) != 0 2963 || bfd_bread ((void *) buf, 20, abfd) != 20) 2964 goto error; 2965 adata->archentries[i].cputype = bfd_getb32 (buf); 2966 adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4); 2967 adata->archentries[i].offset = bfd_getb32 (buf + 8); 2968 adata->archentries[i].size = bfd_getb32 (buf + 12); 2969 adata->archentries[i].align = bfd_getb32 (buf + 16); 2970 } 2971 2972 abfd->tdata.mach_o_fat_data = adata; 2973 return abfd->xvec; 2974 2975 error: 2976 if (adata != NULL) 2977 bfd_release (abfd, adata); 2978 bfd_set_error (bfd_error_wrong_format); 2979 return NULL; 2980 } 2981 2982 bfd * 2983 bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev) 2984 { 2985 mach_o_fat_data_struct *adata; 2986 mach_o_fat_archentry *entry = NULL; 2987 unsigned long i; 2988 bfd *nbfd; 2989 enum bfd_architecture arch_type; 2990 unsigned long arch_subtype; 2991 2992 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data; 2993 BFD_ASSERT (adata != NULL); 2994 2995 /* Find index of previous entry. */ 2996 if (prev == NULL) 2997 i = 0; /* Start at first one. */ 2998 else 2999 { 3000 for (i = 0; i < adata->nfat_arch; i++) 3001 { 3002 if (adata->archentries[i].offset == prev->origin) 3003 break; 3004 } 3005 3006 if (i == adata->nfat_arch) 3007 { 3008 /* Not found. */ 3009 bfd_set_error (bfd_error_bad_value); 3010 return NULL; 3011 } 3012 i++; /* Get next entry. */ 3013 } 3014 3015 if (i >= adata->nfat_arch) 3016 { 3017 bfd_set_error (bfd_error_no_more_archived_files); 3018 return NULL; 3019 } 3020 3021 entry = &adata->archentries[i]; 3022 nbfd = _bfd_new_bfd_contained_in (archive); 3023 if (nbfd == NULL) 3024 return NULL; 3025 3026 nbfd->origin = entry->offset; 3027 3028 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype, 3029 &arch_type, &arch_subtype); 3030 /* Create the member filename. 3031 Use FILENAME:ARCH_NAME. */ 3032 { 3033 char *s = NULL; 3034 const char *arch_name; 3035 size_t arch_file_len = strlen (bfd_get_filename (archive)); 3036 3037 arch_name = bfd_printable_arch_mach (arch_type, arch_subtype); 3038 s = bfd_malloc (arch_file_len + 1 + strlen (arch_name) + 1); 3039 if (s == NULL) 3040 return NULL; 3041 memcpy (s, bfd_get_filename (archive), arch_file_len); 3042 s[arch_file_len] = ':'; 3043 strcpy (s + arch_file_len + 1, arch_name); 3044 nbfd->filename = s; 3045 } 3046 nbfd->iostream = NULL; 3047 bfd_set_arch_mach (nbfd, arch_type, arch_subtype); 3048 3049 return nbfd; 3050 } 3051 3052 /* If ABFD format is FORMAT and architecture is ARCH, return it. 3053 If ABFD is a fat image containing a member that corresponds to FORMAT 3054 and ARCH, returns it. 3055 In other case, returns NULL. 3056 This function allows transparent uses of fat images. */ 3057 bfd * 3058 bfd_mach_o_fat_extract (bfd *abfd, 3059 bfd_format format, 3060 const bfd_arch_info_type *arch) 3061 { 3062 bfd *res; 3063 mach_o_fat_data_struct *adata; 3064 unsigned int i; 3065 3066 if (bfd_check_format (abfd, format)) 3067 { 3068 if (bfd_get_arch_info (abfd) == arch) 3069 return abfd; 3070 return NULL; 3071 } 3072 if (!bfd_check_format (abfd, bfd_archive) 3073 || abfd->xvec != &mach_o_fat_vec) 3074 return NULL; 3075 3076 /* This is a Mach-O fat image. */ 3077 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data; 3078 BFD_ASSERT (adata != NULL); 3079 3080 for (i = 0; i < adata->nfat_arch; i++) 3081 { 3082 struct mach_o_fat_archentry *e = &adata->archentries[i]; 3083 enum bfd_architecture cpu_type; 3084 unsigned long cpu_subtype; 3085 3086 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype, 3087 &cpu_type, &cpu_subtype); 3088 if (cpu_type != arch->arch || cpu_subtype != arch->mach) 3089 continue; 3090 3091 /* The architecture is found. */ 3092 res = _bfd_new_bfd_contained_in (abfd); 3093 if (res == NULL) 3094 return NULL; 3095 3096 res->origin = e->offset; 3097 3098 res->filename = strdup (abfd->filename); 3099 res->iostream = NULL; 3100 3101 if (bfd_check_format (res, format)) 3102 { 3103 BFD_ASSERT (bfd_get_arch_info (res) == arch); 3104 return res; 3105 } 3106 bfd_close (res); 3107 return NULL; 3108 } 3109 3110 return NULL; 3111 } 3112 3113 int 3114 bfd_mach_o_lookup_section (bfd *abfd, 3115 asection *section, 3116 bfd_mach_o_load_command **mcommand, 3117 bfd_mach_o_section **msection) 3118 { 3119 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd); 3120 unsigned int i, j, num; 3121 3122 bfd_mach_o_load_command *ncmd = NULL; 3123 bfd_mach_o_section *nsect = NULL; 3124 3125 BFD_ASSERT (mcommand != NULL); 3126 BFD_ASSERT (msection != NULL); 3127 3128 num = 0; 3129 for (i = 0; i < md->header.ncmds; i++) 3130 { 3131 struct bfd_mach_o_load_command *cmd = &md->commands[i]; 3132 struct bfd_mach_o_segment_command *seg = NULL; 3133 3134 if (cmd->type != BFD_MACH_O_LC_SEGMENT 3135 || cmd->type != BFD_MACH_O_LC_SEGMENT_64) 3136 continue; 3137 seg = &cmd->command.segment; 3138 3139 for (j = 0; j < seg->nsects; j++) 3140 { 3141 struct bfd_mach_o_section *sect = &seg->sections[j]; 3142 3143 if (sect->bfdsection == section) 3144 { 3145 if (num == 0) 3146 { 3147 nsect = sect; 3148 ncmd = cmd; 3149 } 3150 num++; 3151 } 3152 } 3153 } 3154 3155 *mcommand = ncmd; 3156 *msection = nsect; 3157 return num; 3158 } 3159 3160 int 3161 bfd_mach_o_lookup_command (bfd *abfd, 3162 bfd_mach_o_load_command_type type, 3163 bfd_mach_o_load_command **mcommand) 3164 { 3165 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd); 3166 bfd_mach_o_load_command *ncmd = NULL; 3167 unsigned int i, num; 3168 3169 BFD_ASSERT (md != NULL); 3170 BFD_ASSERT (mcommand != NULL); 3171 3172 num = 0; 3173 for (i = 0; i < md->header.ncmds; i++) 3174 { 3175 struct bfd_mach_o_load_command *cmd = &md->commands[i]; 3176 3177 if (cmd->type != type) 3178 continue; 3179 3180 if (num == 0) 3181 ncmd = cmd; 3182 num++; 3183 } 3184 3185 *mcommand = ncmd; 3186 return num; 3187 } 3188 3189 unsigned long 3190 bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type) 3191 { 3192 switch (type) 3193 { 3194 case BFD_MACH_O_CPU_TYPE_MC680x0: 3195 return 0x04000000; 3196 case BFD_MACH_O_CPU_TYPE_MC88000: 3197 return 0xffffe000; 3198 case BFD_MACH_O_CPU_TYPE_POWERPC: 3199 return 0xc0000000; 3200 case BFD_MACH_O_CPU_TYPE_I386: 3201 return 0xc0000000; 3202 case BFD_MACH_O_CPU_TYPE_SPARC: 3203 return 0xf0000000; 3204 case BFD_MACH_O_CPU_TYPE_I860: 3205 return 0; 3206 case BFD_MACH_O_CPU_TYPE_HPPA: 3207 return 0xc0000000 - 0x04000000; 3208 default: 3209 return 0; 3210 } 3211 } 3212 3213 typedef struct bfd_mach_o_xlat_name 3214 { 3215 const char *name; 3216 unsigned long val; 3217 } 3218 bfd_mach_o_xlat_name; 3219 3220 static void 3221 bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table, 3222 unsigned long val, 3223 FILE *file) 3224 { 3225 int first = 1; 3226 3227 for (; table->name; table++) 3228 { 3229 if (table->val & val) 3230 { 3231 if (!first) 3232 fprintf (file, "+"); 3233 fprintf (file, "%s", table->name); 3234 val &= ~table->val; 3235 first = 0; 3236 } 3237 } 3238 if (val) 3239 { 3240 if (!first) 3241 fprintf (file, "+"); 3242 fprintf (file, "0x%lx", val); 3243 return; 3244 } 3245 if (first) 3246 fprintf (file, "-"); 3247 } 3248 3249 static const char * 3250 bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val) 3251 { 3252 for (; table->name; table++) 3253 if (table->val == val) 3254 return table->name; 3255 return "*UNKNOWN*"; 3256 } 3257 3258 static bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] = 3259 { 3260 { "vax", BFD_MACH_O_CPU_TYPE_VAX }, 3261 { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 }, 3262 { "i386", BFD_MACH_O_CPU_TYPE_I386 }, 3263 { "mips", BFD_MACH_O_CPU_TYPE_MIPS }, 3264 { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 }, 3265 { "hppa", BFD_MACH_O_CPU_TYPE_HPPA }, 3266 { "arm", BFD_MACH_O_CPU_TYPE_ARM }, 3267 { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 }, 3268 { "sparc", BFD_MACH_O_CPU_TYPE_SPARC }, 3269 { "i860", BFD_MACH_O_CPU_TYPE_I860 }, 3270 { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA }, 3271 { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC }, 3272 { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 }, 3273 { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 }, 3274 { NULL, 0} 3275 }; 3276 3277 static bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] = 3278 { 3279 { "object", BFD_MACH_O_MH_OBJECT }, 3280 { "execute", BFD_MACH_O_MH_EXECUTE }, 3281 { "fvmlib", BFD_MACH_O_MH_FVMLIB }, 3282 { "core", BFD_MACH_O_MH_CORE }, 3283 { "preload", BFD_MACH_O_MH_PRELOAD }, 3284 { "dylib", BFD_MACH_O_MH_DYLIB }, 3285 { "dylinker", BFD_MACH_O_MH_DYLINKER }, 3286 { "bundle", BFD_MACH_O_MH_BUNDLE }, 3287 { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB }, 3288 { "dym", BFD_MACH_O_MH_DSYM }, 3289 { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE }, 3290 { NULL, 0} 3291 }; 3292 3293 static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] = 3294 { 3295 { "noundefs", BFD_MACH_O_MH_NOUNDEFS }, 3296 { "incrlink", BFD_MACH_O_MH_INCRLINK }, 3297 { "dyldlink", BFD_MACH_O_MH_DYLDLINK }, 3298 { "bindatload", BFD_MACH_O_MH_BINDATLOAD }, 3299 { "prebound", BFD_MACH_O_MH_PREBOUND }, 3300 { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS }, 3301 { "lazy_init", BFD_MACH_O_MH_LAZY_INIT }, 3302 { "twolevel", BFD_MACH_O_MH_TWOLEVEL }, 3303 { "force_flat", BFD_MACH_O_MH_FORCE_FLAT }, 3304 { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS }, 3305 { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING }, 3306 { "prebindable", BFD_MACH_O_MH_PREBINDABLE }, 3307 { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND }, 3308 { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS }, 3309 { "canonical", BFD_MACH_O_MH_CANONICAL }, 3310 { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES }, 3311 { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK }, 3312 { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION }, 3313 { "root_safe", BFD_MACH_O_MH_ROOT_SAFE }, 3314 { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE }, 3315 { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS }, 3316 { "pie", BFD_MACH_O_MH_PIE }, 3317 { NULL, 0} 3318 }; 3319 3320 static bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] = 3321 { 3322 { "regular", BFD_MACH_O_S_REGULAR}, 3323 { "zerofill", BFD_MACH_O_S_ZEROFILL}, 3324 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS}, 3325 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS}, 3326 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS}, 3327 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS}, 3328 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS}, 3329 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS}, 3330 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS}, 3331 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS}, 3332 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS}, 3333 { "coalesced", BFD_MACH_O_S_COALESCED}, 3334 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL}, 3335 { "interposing", BFD_MACH_O_S_INTERPOSING}, 3336 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS}, 3337 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF}, 3338 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS}, 3339 { NULL, 0} 3340 }; 3341 3342 static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] = 3343 { 3344 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC }, 3345 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC }, 3346 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS }, 3347 { "debug", BFD_MACH_O_S_ATTR_DEBUG }, 3348 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE }, 3349 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT }, 3350 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP }, 3351 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS }, 3352 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC }, 3353 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS }, 3354 { NULL, 0} 3355 }; 3356 3357 static bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] = 3358 { 3359 { "segment", BFD_MACH_O_LC_SEGMENT}, 3360 { "symtab", BFD_MACH_O_LC_SYMTAB}, 3361 { "symseg", BFD_MACH_O_LC_SYMSEG}, 3362 { "thread", BFD_MACH_O_LC_THREAD}, 3363 { "unixthread", BFD_MACH_O_LC_UNIXTHREAD}, 3364 { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB}, 3365 { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB}, 3366 { "ident", BFD_MACH_O_LC_IDENT}, 3367 { "fvmfile", BFD_MACH_O_LC_FVMFILE}, 3368 { "prepage", BFD_MACH_O_LC_PREPAGE}, 3369 { "dysymtab", BFD_MACH_O_LC_DYSYMTAB}, 3370 { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB}, 3371 { "id_dylib", BFD_MACH_O_LC_ID_DYLIB}, 3372 { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER}, 3373 { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER}, 3374 { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB}, 3375 { "routines", BFD_MACH_O_LC_ROUTINES}, 3376 { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK}, 3377 { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA}, 3378 { "sub_client", BFD_MACH_O_LC_SUB_CLIENT}, 3379 { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY}, 3380 { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS}, 3381 { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM}, 3382 { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB}, 3383 { "segment_64", BFD_MACH_O_LC_SEGMENT_64}, 3384 { "routines_64", BFD_MACH_O_LC_ROUTINES_64}, 3385 { "uuid", BFD_MACH_O_LC_UUID}, 3386 { "rpath", BFD_MACH_O_LC_RPATH}, 3387 { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE}, 3388 { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO}, 3389 { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB}, 3390 { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB}, 3391 { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO}, 3392 { "dyld_info", BFD_MACH_O_LC_DYLD_INFO}, 3393 { NULL, 0} 3394 }; 3395 3396 static void 3397 bfd_mach_o_print_private_header (bfd *abfd, FILE *file) 3398 { 3399 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 3400 bfd_mach_o_header *h = &mdata->header; 3401 3402 fputs (_("Mach-O header:\n"), file); 3403 fprintf (file, _(" magic : %08lx\n"), h->magic); 3404 fprintf (file, _(" cputype : %08lx (%s)\n"), h->cputype, 3405 bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype)); 3406 fprintf (file, _(" cpusubtype: %08lx\n"), h->cpusubtype); 3407 fprintf (file, _(" filetype : %08lx (%s)\n"), 3408 h->filetype, 3409 bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype)); 3410 fprintf (file, _(" ncmds : %08lx (%lu)\n"), h->ncmds, h->ncmds); 3411 fprintf (file, _(" sizeofcmds: %08lx\n"), h->sizeofcmds); 3412 fprintf (file, _(" flags : %08lx ("), h->flags); 3413 bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags, file); 3414 fputs (_(")\n"), file); 3415 fprintf (file, _(" reserved : %08x\n"), h->reserved); 3416 } 3417 3418 static void 3419 bfd_mach_o_print_section_map (bfd *abfd, FILE *file) 3420 { 3421 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 3422 unsigned int i, j; 3423 unsigned int sec_nbr = 0; 3424 3425 fputs (_("Segments and Sections:\n"), file); 3426 fputs (_(" #: Segment name Section name Address\n"), file); 3427 3428 for (i = 0; i < mdata->header.ncmds; i++) 3429 { 3430 bfd_mach_o_segment_command *seg; 3431 3432 if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT 3433 && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64) 3434 continue; 3435 3436 seg = &mdata->commands[i].command.segment; 3437 3438 fprintf (file, "[Segment %-16s ", seg->segname); 3439 fprintf_vma (file, seg->vmaddr); 3440 fprintf (file, "-"); 3441 fprintf_vma (file, seg->vmaddr + seg->vmsize - 1); 3442 fputc (' ', file); 3443 fputc (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-', file); 3444 fputc (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-', file); 3445 fputc (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-', file); 3446 fprintf (file, "]\n"); 3447 for (j = 0; j < seg->nsects; j++) 3448 { 3449 bfd_mach_o_section *sec = &seg->sections[j]; 3450 fprintf (file, "%02u: %-16s %-16s ", ++sec_nbr, 3451 sec->segname, sec->sectname); 3452 fprintf_vma (file, sec->addr); 3453 fprintf (file, " "); 3454 fprintf_vma (file, sec->size); 3455 fprintf (file, " %08lx\n", sec->flags); 3456 } 3457 } 3458 } 3459 3460 static void 3461 bfd_mach_o_print_section (bfd *abfd ATTRIBUTE_UNUSED, 3462 bfd_mach_o_section *sec, FILE *file) 3463 { 3464 fprintf (file, " Section: %-16s %-16s (bfdname: %s)\n", 3465 sec->sectname, sec->segname, sec->bfdsection->name); 3466 fprintf (file, " addr: "); 3467 fprintf_vma (file, sec->addr); 3468 fprintf (file, " size: "); 3469 fprintf_vma (file, sec->size); 3470 fprintf (file, " offset: "); 3471 fprintf_vma (file, sec->offset); 3472 fprintf (file, "\n"); 3473 fprintf (file, " align: %ld", sec->align); 3474 fprintf (file, " nreloc: %lu reloff: ", sec->nreloc); 3475 fprintf_vma (file, sec->reloff); 3476 fprintf (file, "\n"); 3477 fprintf (file, " flags: %08lx (type: %s", sec->flags, 3478 bfd_mach_o_get_name (bfd_mach_o_section_type_name, 3479 sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)); 3480 fprintf (file, " attr: "); 3481 bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name, 3482 sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK, 3483 file); 3484 fprintf (file, ")\n"); 3485 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) 3486 { 3487 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: 3488 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: 3489 case BFD_MACH_O_S_SYMBOL_STUBS: 3490 fprintf (file, " first indirect sym: %lu", sec->reserved1); 3491 fprintf (file, " (%u entries)", 3492 bfd_mach_o_section_get_nbr_indirect (abfd, sec)); 3493 break; 3494 default: 3495 fprintf (file, " reserved1: 0x%lx", sec->reserved1); 3496 break; 3497 } 3498 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) 3499 { 3500 case BFD_MACH_O_S_SYMBOL_STUBS: 3501 fprintf (file, " stub size: %lu", sec->reserved2); 3502 break; 3503 default: 3504 fprintf (file, " reserved2: 0x%lx", sec->reserved2); 3505 break; 3506 } 3507 fprintf (file, " reserved3: 0x%lx\n", sec->reserved3); 3508 } 3509 3510 static void 3511 bfd_mach_o_print_segment (bfd *abfd ATTRIBUTE_UNUSED, 3512 bfd_mach_o_load_command *cmd, FILE *file) 3513 { 3514 bfd_mach_o_segment_command *seg = &cmd->command.segment; 3515 unsigned int i; 3516 3517 fprintf (file, " name: %s\n", *seg->segname ? seg->segname : "*none*"); 3518 fprintf (file, " vmaddr: "); 3519 fprintf_vma (file, seg->vmaddr); 3520 fprintf (file, " vmsize: "); 3521 fprintf_vma (file, seg->vmsize); 3522 fprintf (file, "\n"); 3523 fprintf (file, " fileoff: "); 3524 fprintf_vma (file, seg->fileoff); 3525 fprintf (file, " filesize: "); 3526 fprintf_vma (file, (bfd_vma)seg->filesize); 3527 fprintf (file, " endoff: "); 3528 fprintf_vma (file, (bfd_vma)(seg->fileoff + seg->filesize)); 3529 fprintf (file, "\n"); 3530 fprintf (file, " nsects: %lu ", seg->nsects); 3531 fprintf (file, " flags: %lx\n", seg->flags); 3532 for (i = 0; i < seg->nsects; i++) 3533 bfd_mach_o_print_section (abfd, &seg->sections[i], file); 3534 } 3535 3536 static void 3537 bfd_mach_o_print_dysymtab (bfd *abfd ATTRIBUTE_UNUSED, 3538 bfd_mach_o_load_command *cmd, FILE *file) 3539 { 3540 bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab; 3541 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 3542 unsigned int i; 3543 3544 fprintf (file, " local symbols: idx: %10lu num: %-8lu", 3545 dysymtab->ilocalsym, dysymtab->nlocalsym); 3546 fprintf (file, " (nxtidx: %lu)\n", 3547 dysymtab->ilocalsym + dysymtab->nlocalsym); 3548 fprintf (file, " external symbols: idx: %10lu num: %-8lu", 3549 dysymtab->iextdefsym, dysymtab->nextdefsym); 3550 fprintf (file, " (nxtidx: %lu)\n", 3551 dysymtab->iextdefsym + dysymtab->nextdefsym); 3552 fprintf (file, " undefined symbols: idx: %10lu num: %-8lu", 3553 dysymtab->iundefsym, dysymtab->nundefsym); 3554 fprintf (file, " (nxtidx: %lu)\n", 3555 dysymtab->iundefsym + dysymtab->nundefsym); 3556 fprintf (file, " table of content: off: 0x%08lx num: %-8lu", 3557 dysymtab->tocoff, dysymtab->ntoc); 3558 fprintf (file, " (endoff: 0x%08lx)\n", 3559 dysymtab->tocoff 3560 + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE); 3561 fprintf (file, " module table: off: 0x%08lx num: %-8lu", 3562 dysymtab->modtaboff, dysymtab->nmodtab); 3563 fprintf (file, " (endoff: 0x%08lx)\n", 3564 dysymtab->modtaboff + dysymtab->nmodtab 3565 * (mach_o_wide_p (&mdata->header) ? 3566 BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE)); 3567 fprintf (file, " external reference table: off: 0x%08lx num: %-8lu", 3568 dysymtab->extrefsymoff, dysymtab->nextrefsyms); 3569 fprintf (file, " (endoff: 0x%08lx)\n", 3570 dysymtab->extrefsymoff 3571 + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE); 3572 fprintf (file, " indirect symbol table: off: 0x%08lx num: %-8lu", 3573 dysymtab->indirectsymoff, dysymtab->nindirectsyms); 3574 fprintf (file, " (endoff: 0x%08lx)\n", 3575 dysymtab->indirectsymoff 3576 + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE); 3577 fprintf (file, " external relocation table: off: 0x%08lx num: %-8lu", 3578 dysymtab->extreloff, dysymtab->nextrel); 3579 fprintf (file, " (endoff: 0x%08lx)\n", 3580 dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE); 3581 fprintf (file, " local relocation table: off: 0x%08lx num: %-8lu", 3582 dysymtab->locreloff, dysymtab->nlocrel); 3583 fprintf (file, " (endoff: 0x%08lx)\n", 3584 dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE); 3585 3586 if (dysymtab->ntoc > 0 3587 || dysymtab->nindirectsyms > 0 3588 || dysymtab->nextrefsyms > 0) 3589 { 3590 /* Try to read the symbols to display the toc or indirect symbols. */ 3591 bfd_mach_o_read_symtab_symbols (abfd); 3592 } 3593 else if (dysymtab->nmodtab > 0) 3594 { 3595 /* Try to read the strtab to display modules name. */ 3596 bfd_mach_o_read_symtab_strtab (abfd); 3597 } 3598 3599 for (i = 0; i < dysymtab->nmodtab; i++) 3600 { 3601 bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i]; 3602 fprintf (file, " module %u:\n", i); 3603 fprintf (file, " name: %lu", module->module_name_idx); 3604 if (mdata->symtab && mdata->symtab->strtab) 3605 fprintf (file, ": %s", 3606 mdata->symtab->strtab + module->module_name_idx); 3607 fprintf (file, "\n"); 3608 fprintf (file, " extdefsym: idx: %8lu num: %lu\n", 3609 module->iextdefsym, module->nextdefsym); 3610 fprintf (file, " refsym: idx: %8lu num: %lu\n", 3611 module->irefsym, module->nrefsym); 3612 fprintf (file, " localsym: idx: %8lu num: %lu\n", 3613 module->ilocalsym, module->nlocalsym); 3614 fprintf (file, " extrel: idx: %8lu num: %lu\n", 3615 module->iextrel, module->nextrel); 3616 fprintf (file, " init: idx: %8u num: %u\n", 3617 module->iinit, module->ninit); 3618 fprintf (file, " term: idx: %8u num: %u\n", 3619 module->iterm, module->nterm); 3620 fprintf (file, " objc_module_info: addr: "); 3621 fprintf_vma (file, module->objc_module_info_addr); 3622 fprintf (file, " size: %lu\n", module->objc_module_info_size); 3623 } 3624 3625 if (dysymtab->ntoc > 0) 3626 { 3627 bfd_mach_o_symtab_command *symtab = mdata->symtab; 3628 3629 fprintf (file, " table of content: (symbol/module)\n"); 3630 for (i = 0; i < dysymtab->ntoc; i++) 3631 { 3632 bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i]; 3633 3634 fprintf (file, " %4u: ", i); 3635 if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms) 3636 { 3637 const char *name = symtab->symbols[toc->symbol_index].symbol.name; 3638 fprintf (file, "%s (%lu)", name ? name : "*invalid*", 3639 toc->symbol_index); 3640 } 3641 else 3642 fprintf (file, "%lu", toc->symbol_index); 3643 3644 fprintf (file, " / "); 3645 if (symtab && symtab->strtab 3646 && toc->module_index < dysymtab->nmodtab) 3647 { 3648 bfd_mach_o_dylib_module *mod; 3649 mod = &dysymtab->dylib_module[toc->module_index]; 3650 fprintf (file, "%s (%lu)", 3651 symtab->strtab + mod->module_name_idx, 3652 toc->module_index); 3653 } 3654 else 3655 fprintf (file, "%lu", toc->module_index); 3656 3657 fprintf (file, "\n"); 3658 } 3659 } 3660 3661 if (dysymtab->nindirectsyms != 0) 3662 { 3663 fprintf (file, " indirect symbols:\n"); 3664 3665 for (i = 0; i < mdata->nsects; i++) 3666 { 3667 bfd_mach_o_section *sec = mdata->sections[i]; 3668 unsigned int j, first, last; 3669 bfd_mach_o_symtab_command *symtab = mdata->symtab; 3670 bfd_vma addr; 3671 bfd_vma entry_size; 3672 3673 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK) 3674 { 3675 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS: 3676 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS: 3677 case BFD_MACH_O_S_SYMBOL_STUBS: 3678 first = sec->reserved1; 3679 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec); 3680 addr = sec->addr; 3681 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec); 3682 fprintf (file, " for section %s.%s:\n", 3683 sec->segname, sec->sectname); 3684 for (j = first; j < last; j++) 3685 { 3686 unsigned int isym = dysymtab->indirect_syms[j]; 3687 3688 fprintf (file, " "); 3689 fprintf_vma (file, addr); 3690 fprintf (file, " %5u: 0x%08x", j, isym); 3691 if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL) 3692 fprintf (file, " LOCAL"); 3693 if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS) 3694 fprintf (file, " ABSOLUTE"); 3695 if (symtab && symtab->symbols 3696 && isym < symtab->nsyms 3697 && symtab->symbols[isym].symbol.name) 3698 fprintf (file, " %s", symtab->symbols[isym].symbol.name); 3699 fprintf (file, "\n"); 3700 addr += entry_size; 3701 } 3702 break; 3703 default: 3704 break; 3705 } 3706 } 3707 } 3708 if (dysymtab->nextrefsyms > 0) 3709 { 3710 bfd_mach_o_symtab_command *symtab = mdata->symtab; 3711 3712 fprintf (file, " external reference table: (symbol flags)\n"); 3713 for (i = 0; i < dysymtab->nextrefsyms; i++) 3714 { 3715 bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i]; 3716 3717 fprintf (file, " %4u: %5lu 0x%02lx", i, ref->isym, ref->flags); 3718 if (symtab && symtab->symbols 3719 && ref->isym < symtab->nsyms 3720 && symtab->symbols[ref->isym].symbol.name) 3721 fprintf (file, " %s", symtab->symbols[ref->isym].symbol.name); 3722 fprintf (file, "\n"); 3723 } 3724 } 3725 3726 } 3727 3728 static void 3729 bfd_mach_o_print_dyld_info (bfd *abfd ATTRIBUTE_UNUSED, 3730 bfd_mach_o_load_command *cmd, FILE *file) 3731 { 3732 bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info; 3733 3734 fprintf (file, " rebase: off: 0x%08x size: %-8u\n", 3735 info->rebase_off, info->rebase_size); 3736 fprintf (file, " bind: off: 0x%08x size: %-8u\n", 3737 info->bind_off, info->bind_size); 3738 fprintf (file, " weak bind: off: 0x%08x size: %-8u\n", 3739 info->weak_bind_off, info->weak_bind_size); 3740 fprintf (file, " lazy bind: off: 0x%08x size: %-8u\n", 3741 info->lazy_bind_off, info->lazy_bind_size); 3742 fprintf (file, " export: off: 0x%08x size: %-8u\n", 3743 info->export_off, info->export_size); 3744 } 3745 3746 bfd_boolean 3747 bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, void * ptr) 3748 { 3749 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 3750 FILE *file = (FILE *) ptr; 3751 unsigned int i; 3752 3753 bfd_mach_o_print_private_header (abfd, file); 3754 fputc ('\n', file); 3755 3756 for (i = 0; i < mdata->header.ncmds; i++) 3757 { 3758 bfd_mach_o_load_command *cmd = &mdata->commands[i]; 3759 3760 fprintf (file, "Load command %s:", 3761 bfd_mach_o_get_name (bfd_mach_o_load_command_name, cmd->type)); 3762 switch (cmd->type) 3763 { 3764 case BFD_MACH_O_LC_SEGMENT: 3765 case BFD_MACH_O_LC_SEGMENT_64: 3766 bfd_mach_o_print_segment (abfd, cmd, file); 3767 break; 3768 case BFD_MACH_O_LC_UUID: 3769 { 3770 bfd_mach_o_uuid_command *uuid = &cmd->command.uuid; 3771 unsigned int j; 3772 3773 for (j = 0; j < sizeof (uuid->uuid); j ++) 3774 fprintf (file, " %02x", uuid->uuid[j]); 3775 fputc ('\n', file); 3776 } 3777 break; 3778 case BFD_MACH_O_LC_LOAD_DYLIB: 3779 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB: 3780 case BFD_MACH_O_LC_REEXPORT_DYLIB: 3781 case BFD_MACH_O_LC_ID_DYLIB: 3782 { 3783 bfd_mach_o_dylib_command *dylib = &cmd->command.dylib; 3784 fprintf (file, " %s\n", dylib->name_str); 3785 fprintf (file, " time stamp: 0x%08lx\n", 3786 dylib->timestamp); 3787 fprintf (file, " current version: 0x%08lx\n", 3788 dylib->current_version); 3789 fprintf (file, " comptibility version: 0x%08lx\n", 3790 dylib->compatibility_version); 3791 break; 3792 } 3793 case BFD_MACH_O_LC_LOAD_DYLINKER: 3794 case BFD_MACH_O_LC_ID_DYLINKER: 3795 fprintf (file, " %s\n", cmd->command.dylinker.name_str); 3796 break; 3797 case BFD_MACH_O_LC_SYMTAB: 3798 { 3799 bfd_mach_o_symtab_command *symtab = &cmd->command.symtab; 3800 fprintf (file, 3801 "\n" 3802 " symoff: 0x%08x nsyms: %8u (endoff: 0x%08x)\n", 3803 symtab->symoff, symtab->nsyms, 3804 symtab->symoff + symtab->nsyms 3805 * (mach_o_wide_p (&mdata->header) 3806 ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE)); 3807 fprintf (file, 3808 " stroff: 0x%08x strsize: %8u (endoff: 0x%08x)\n", 3809 symtab->stroff, symtab->strsize, 3810 symtab->stroff + symtab->strsize); 3811 break; 3812 } 3813 case BFD_MACH_O_LC_DYSYMTAB: 3814 fprintf (file, "\n"); 3815 bfd_mach_o_print_dysymtab (abfd, cmd, file); 3816 break; 3817 case BFD_MACH_O_LC_CODE_SIGNATURE: 3818 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO: 3819 { 3820 bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit; 3821 fprintf 3822 (file, "\n" 3823 " dataoff: 0x%08lx datasize: 0x%08lx (endoff: 0x%08lx)\n", 3824 linkedit->dataoff, linkedit->datasize, 3825 linkedit->dataoff + linkedit->datasize); 3826 break; 3827 } 3828 case BFD_MACH_O_LC_SUB_FRAMEWORK: 3829 case BFD_MACH_O_LC_SUB_UMBRELLA: 3830 case BFD_MACH_O_LC_SUB_LIBRARY: 3831 case BFD_MACH_O_LC_SUB_CLIENT: 3832 case BFD_MACH_O_LC_RPATH: 3833 { 3834 bfd_mach_o_str_command *str = &cmd->command.str; 3835 fprintf (file, " %s\n", str->str); 3836 break; 3837 } 3838 case BFD_MACH_O_LC_THREAD: 3839 case BFD_MACH_O_LC_UNIXTHREAD: 3840 { 3841 bfd_mach_o_thread_command *thread = &cmd->command.thread; 3842 unsigned int j; 3843 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd); 3844 3845 fprintf (file, " nflavours: %lu\n", thread->nflavours); 3846 for (j = 0; j < thread->nflavours; j++) 3847 { 3848 bfd_mach_o_thread_flavour *flavour = &thread->flavours[j]; 3849 3850 fprintf (file, " %2u: flavour: 0x%08lx offset: 0x%08lx" 3851 " size: 0x%08lx\n", 3852 j, flavour->flavour, flavour->offset, 3853 flavour->size); 3854 if (bed->_bfd_mach_o_print_thread) 3855 { 3856 char *buf = bfd_malloc (flavour->size); 3857 3858 if (buf 3859 && bfd_seek (abfd, flavour->offset, SEEK_SET) == 0 3860 && (bfd_bread (buf, flavour->size, abfd) 3861 == flavour->size)) 3862 (*bed->_bfd_mach_o_print_thread)(abfd, flavour, 3863 file, buf); 3864 free (buf); 3865 } 3866 } 3867 break; 3868 } 3869 case BFD_MACH_O_LC_DYLD_INFO: 3870 fprintf (file, "\n"); 3871 bfd_mach_o_print_dyld_info (abfd, cmd, file); 3872 break; 3873 default: 3874 fprintf (file, "\n"); 3875 break; 3876 } 3877 fputc ('\n', file); 3878 } 3879 3880 bfd_mach_o_print_section_map (abfd, file); 3881 3882 return TRUE; 3883 } 3884 3885 int 3886 bfd_mach_o_core_fetch_environment (bfd *abfd, 3887 unsigned char **rbuf, 3888 unsigned int *rlen) 3889 { 3890 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd); 3891 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype); 3892 unsigned int i = 0; 3893 3894 for (i = 0; i < mdata->header.ncmds; i++) 3895 { 3896 bfd_mach_o_load_command *cur = &mdata->commands[i]; 3897 bfd_mach_o_segment_command *seg = NULL; 3898 3899 if (cur->type != BFD_MACH_O_LC_SEGMENT) 3900 continue; 3901 3902 seg = &cur->command.segment; 3903 3904 if ((seg->vmaddr + seg->vmsize) == stackaddr) 3905 { 3906 unsigned long start = seg->fileoff; 3907 unsigned long end = seg->fileoff + seg->filesize; 3908 unsigned char *buf = bfd_malloc (1024); 3909 unsigned long size = 1024; 3910 3911 for (;;) 3912 { 3913 bfd_size_type nread = 0; 3914 unsigned long offset; 3915 int found_nonnull = 0; 3916 3917 if (size > (end - start)) 3918 size = (end - start); 3919 3920 buf = bfd_realloc_or_free (buf, size); 3921 if (buf == NULL) 3922 return -1; 3923 3924 if (bfd_seek (abfd, end - size, SEEK_SET) != 0) 3925 { 3926 free (buf); 3927 return -1; 3928 } 3929 3930 nread = bfd_bread (buf, size, abfd); 3931 3932 if (nread != size) 3933 { 3934 free (buf); 3935 return -1; 3936 } 3937 3938 for (offset = 4; offset <= size; offset += 4) 3939 { 3940 unsigned long val; 3941 3942 val = *((unsigned long *) (buf + size - offset)); 3943 if (! found_nonnull) 3944 { 3945 if (val != 0) 3946 found_nonnull = 1; 3947 } 3948 else if (val == 0x0) 3949 { 3950 unsigned long bottom; 3951 unsigned long top; 3952 3953 bottom = seg->fileoff + seg->filesize - offset; 3954 top = seg->fileoff + seg->filesize - 4; 3955 *rbuf = bfd_malloc (top - bottom); 3956 *rlen = top - bottom; 3957 3958 memcpy (*rbuf, buf + size - *rlen, *rlen); 3959 free (buf); 3960 return 0; 3961 } 3962 } 3963 3964 if (size == (end - start)) 3965 break; 3966 3967 size *= 2; 3968 } 3969 3970 free (buf); 3971 } 3972 } 3973 3974 return -1; 3975 } 3976 3977 char * 3978 bfd_mach_o_core_file_failing_command (bfd *abfd) 3979 { 3980 unsigned char *buf = NULL; 3981 unsigned int len = 0; 3982 int ret = -1; 3983 3984 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len); 3985 if (ret < 0) 3986 return NULL; 3987 3988 return (char *) buf; 3989 } 3990 3991 int 3992 bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED) 3993 { 3994 return 0; 3995 } 3996 3997 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 3998 #define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup 3999 4000 #define bfd_mach_o_swap_reloc_in NULL 4001 #define bfd_mach_o_swap_reloc_out NULL 4002 #define bfd_mach_o_print_thread NULL 4003 4004 #define TARGET_NAME mach_o_be_vec 4005 #define TARGET_STRING "mach-o-be" 4006 #define TARGET_ARCHITECTURE bfd_arch_unknown 4007 #define TARGET_BIG_ENDIAN 1 4008 #define TARGET_ARCHIVE 0 4009 #include "mach-o-target.c" 4010 4011 #undef TARGET_NAME 4012 #undef TARGET_STRING 4013 #undef TARGET_ARCHITECTURE 4014 #undef TARGET_BIG_ENDIAN 4015 #undef TARGET_ARCHIVE 4016 4017 #define TARGET_NAME mach_o_le_vec 4018 #define TARGET_STRING "mach-o-le" 4019 #define TARGET_ARCHITECTURE bfd_arch_unknown 4020 #define TARGET_BIG_ENDIAN 0 4021 #define TARGET_ARCHIVE 0 4022 4023 #include "mach-o-target.c" 4024 4025 #undef TARGET_NAME 4026 #undef TARGET_STRING 4027 #undef TARGET_ARCHITECTURE 4028 #undef TARGET_BIG_ENDIAN 4029 #undef TARGET_ARCHIVE 4030 4031 /* Not yet handled: creating an archive. */ 4032 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive 4033 4034 /* Not used. */ 4035 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr 4036 #define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr 4037 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap 4038 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table 4039 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table 4040 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname 4041 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap 4042 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index 4043 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt 4044 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp 4045 4046 #define TARGET_NAME mach_o_fat_vec 4047 #define TARGET_STRING "mach-o-fat" 4048 #define TARGET_ARCHITECTURE bfd_arch_unknown 4049 #define TARGET_BIG_ENDIAN 1 4050 #define TARGET_ARCHIVE 1 4051 4052 #include "mach-o-target.c" 4053 4054 #undef TARGET_NAME 4055 #undef TARGET_STRING 4056 #undef TARGET_ARCHITECTURE 4057 #undef TARGET_BIG_ENDIAN 4058 #undef TARGET_ARCHIVE 4059