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