bfd/mach-o.c

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