bfd/mach-o.c

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