bfd/mach-o.c

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