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