bfd/mach-o.c

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