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