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