bfd/mach-o.c

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