bfd/mach-o.c

   1 /* Mach-O support for BFD.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "mach-o.h"
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "libbfd.h"
  25 #include "libiberty.h"
  26 #include <ctype.h>
  27
  28 #ifndef BFD_IO_FUNCS
  29 #define BFD_IO_FUNCS 0
  30 #endif
  31
  32 #define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
  33 #define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
  34 #define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
  35 #define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
  36 #define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
  37 #define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
  38 #define bfd_mach_o_write_armap _bfd_noarchive_write_armap
  39 #define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
  40 #define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
  41 #define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
  42 #define bfd_mach_o_close_and_cleanup _bfd_generic_close_and_cleanup
  43 #define bfd_mach_o_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
  44 #define bfd_mach_o_new_section_hook _bfd_generic_new_section_hook
  45 #define bfd_mach_o_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
  46 #define bfd_mach_o_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
  47 #define bfd_mach_o_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
  48 #define bfd_mach_o_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
  49 #define bfd_mach_o_get_lineno _bfd_nosymbols_get_lineno
  50 #define bfd_mach_o_find_nearest_line _bfd_nosymbols_find_nearest_line
  51 #define bfd_mach_o_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
  52 #define bfd_mach_o_read_minisymbols _bfd_generic_read_minisymbols
  53 #define bfd_mach_o_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
  54 #define bfd_mach_o_get_reloc_upper_bound _bfd_norelocs_get_reloc_upper_bound
  55 #define bfd_mach_o_canonicalize_reloc _bfd_norelocs_canonicalize_reloc
  56 #define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
  57 #define bfd_mach_o_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
  58 #define bfd_mach_o_bfd_relax_section bfd_generic_relax_section
  59 #define bfd_mach_o_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
  60 #define bfd_mach_o_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
  61 #define bfd_mach_o_bfd_link_add_symbols _bfd_generic_link_add_symbols
  62 #define bfd_mach_o_bfd_link_just_syms _bfd_generic_link_just_syms
  63 #define bfd_mach_o_bfd_final_link _bfd_generic_final_link
  64 #define bfd_mach_o_bfd_link_split_section _bfd_generic_link_split_section
  65 #define bfd_mach_o_set_arch_mach bfd_default_set_arch_mach
  66 #define bfd_mach_o_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
  67 #define bfd_mach_o_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
  68 #define bfd_mach_o_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
  69 #define bfd_mach_o_get_section_contents _bfd_generic_get_section_contents
  70 #define bfd_mach_o_set_section_contents _bfd_generic_set_section_contents
  71 #define bfd_mach_o_bfd_gc_sections bfd_generic_gc_sections
  72 #define bfd_mach_o_bfd_merge_sections bfd_generic_merge_sections
  73 #define bfd_mach_o_bfd_is_group_section bfd_generic_is_group_section
  74 #define bfd_mach_o_bfd_discard_group bfd_generic_discard_group
  75 #define bfd_mach_o_section_already_linked \
  76   _bfd_generic_section_already_linked
  77 #define bfd_mach_o_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
  78
  79 static bfd_boolean bfd_mach_o_bfd_copy_private_symbol_data
  80   PARAMS ((bfd *, asymbol *, bfd *, asymbol *));
  81 static bfd_boolean bfd_mach_o_bfd_copy_private_section_data
  82   PARAMS ((bfd *, asection *, bfd *, asection *));
  83 static bfd_boolean bfd_mach_o_bfd_copy_private_bfd_data
  84   PARAMS ((bfd *, bfd *));
  85 static long bfd_mach_o_count_symbols
  86   PARAMS ((bfd *));
  87 static long bfd_mach_o_get_symtab_upper_bound
  88   PARAMS ((bfd *));
  89 static long bfd_mach_o_canonicalize_symtab
  90   PARAMS ((bfd *, asymbol **));
  91 static void bfd_mach_o_get_symbol_info
  92   PARAMS ((bfd *, asymbol *, symbol_info *));
  93 static void bfd_mach_o_print_symbol
  94   PARAMS ((bfd *, PTR, asymbol *, bfd_print_symbol_type));
  95 static void bfd_mach_o_convert_architecture
  96   PARAMS ((bfd_mach_o_cpu_type, bfd_mach_o_cpu_subtype,
  97            enum bfd_architecture *, unsigned long *));
  98 static bfd_boolean bfd_mach_o_write_contents
  99   PARAMS ((bfd *));
 100 static int bfd_mach_o_sizeof_headers
 101   PARAMS ((bfd *, bfd_boolean));
 102 static asymbol * bfd_mach_o_make_empty_symbol
 103   PARAMS ((bfd *));
 104 static int bfd_mach_o_write_header
 105   PARAMS ((bfd *, bfd_mach_o_header *));
 106 static int bfd_mach_o_read_header
 107   PARAMS ((bfd *, bfd_mach_o_header *));
 108 static asection * bfd_mach_o_make_bfd_section
 109   PARAMS ((bfd *, bfd_mach_o_section *));
 110 static int bfd_mach_o_scan_read_section
 111   PARAMS ((bfd *, bfd_mach_o_section *, bfd_vma));
 112 static int bfd_mach_o_scan_write_section
 113   PARAMS ((bfd *, bfd_mach_o_section *, bfd_vma));
 114 static int bfd_mach_o_scan_write_symtab_symbols
 115   PARAMS ((bfd *, bfd_mach_o_load_command *));
 116 static int bfd_mach_o_scan_write_thread
 117   PARAMS ((bfd *, bfd_mach_o_load_command *));
 118 static int bfd_mach_o_scan_read_dylinker
 119   PARAMS ((bfd *, bfd_mach_o_load_command *));
 120 static int bfd_mach_o_scan_read_dylib
 121   PARAMS ((bfd *, bfd_mach_o_load_command *));
 122 static int bfd_mach_o_scan_read_prebound_dylib
 123   PARAMS ((bfd *, bfd_mach_o_load_command *));
 124 static int bfd_mach_o_scan_read_thread
 125   PARAMS ((bfd *, bfd_mach_o_load_command *));
 126 static int bfd_mach_o_scan_write_symtab
 127   PARAMS ((bfd *, bfd_mach_o_load_command *));
 128 static int bfd_mach_o_scan_read_dysymtab
 129   PARAMS ((bfd *, bfd_mach_o_load_command *));
 130 static int bfd_mach_o_scan_read_symtab
 131   PARAMS ((bfd *, bfd_mach_o_load_command *));
 132 static int bfd_mach_o_scan_read_segment
 133   PARAMS ((bfd *, bfd_mach_o_load_command *));
 134 static int bfd_mach_o_scan_write_segment
 135   PARAMS ((bfd *, bfd_mach_o_load_command *));
 136 static int bfd_mach_o_scan_read_command
 137   PARAMS ((bfd *, bfd_mach_o_load_command *));
 138 static void bfd_mach_o_flatten_sections
 139   PARAMS ((bfd *));
 140 static const char * bfd_mach_o_i386_flavour_string
 141   PARAMS ((unsigned int));
 142 static const char * bfd_mach_o_ppc_flavour_string
 143   PARAMS ((unsigned int));
 144
 145 /* The flags field of a section structure is separated into two parts a section
 146    type and section attributes.  The section types are mutually exclusive (it
 147    can only have one type) but the section attributes are not (it may have more
 148    than one attribute).  */
 149
 150 #define SECTION_TYPE             0x000000ff     /* 256 section types.  */
 151 #define SECTION_ATTRIBUTES       0xffffff00     /*  24 section attributes.  */
 152
 153 /* Constants for the section attributes part of the flags field of a section
 154    structure.  */
 155
 156 #define SECTION_ATTRIBUTES_USR   0xff000000     /* User-settable attributes.  */
 157 #define S_ATTR_PURE_INSTRUCTIONS 0x80000000     /* Section contains only true machine instructions.  */
 158 #define SECTION_ATTRIBUTES_SYS   0x00ffff00     /* System setable attributes.  */
 159 #define S_ATTR_SOME_INSTRUCTIONS 0x00000400     /* Section contains some machine instructions.  */
 160 #define S_ATTR_EXT_RELOC         0x00000200     /* Section has external relocation entries.  */
 161 #define S_ATTR_LOC_RELOC         0x00000100     /* Section has local relocation entries.  */
 162
 163 #define N_STAB 0xe0
 164 #define N_TYPE 0x1e
 165 #define N_EXT  0x01
 166 #define N_UNDF 0x0
 167 #define N_ABS  0x2
 168 #define N_SECT 0xe
 169 #define N_INDR 0xa
 170
 171 bfd_boolean
 172 bfd_mach_o_valid (abfd)
 173      bfd *abfd;
 174 {
 175   if (abfd == NULL || abfd->xvec == NULL)
 176     return 0;
 177
 178   if (! ((abfd->xvec == &mach_o_be_vec)
 179          || (abfd->xvec == &mach_o_le_vec)
 180          || (abfd->xvec == &mach_o_fat_vec)))
 181     return 0;
 182
 183   if (abfd->tdata.mach_o_data == NULL)
 184     return 0;
 185   return 1;
 186 }
 187
 188 /* Copy any private info we understand from the input symbol
 189    to the output symbol.  */
 190
 191 static bfd_boolean
 192 bfd_mach_o_bfd_copy_private_symbol_data (ibfd, isymbol, obfd, osymbol)
 193      bfd *ibfd ATTRIBUTE_UNUSED;
 194      asymbol *isymbol ATTRIBUTE_UNUSED;
 195      bfd *obfd ATTRIBUTE_UNUSED;
 196      asymbol *osymbol ATTRIBUTE_UNUSED;
 197 {
 198   return TRUE;
 199 }
 200
 201 /* Copy any private info we understand from the input section
 202    to the output section.  */
 203
 204 static bfd_boolean
 205 bfd_mach_o_bfd_copy_private_section_data (ibfd, isection, obfd, osection)
 206      bfd *ibfd ATTRIBUTE_UNUSED;
 207      asection *isection ATTRIBUTE_UNUSED;
 208      bfd *obfd ATTRIBUTE_UNUSED;
 209      asection *osection ATTRIBUTE_UNUSED;
 210 {
 211   return TRUE;
 212 }
 213
 214 /* Copy any private info we understand from the input bfd
 215    to the output bfd.  */
 216
 217 static bfd_boolean
 218 bfd_mach_o_bfd_copy_private_bfd_data (ibfd, obfd)
 219      bfd *ibfd;
 220      bfd *obfd;
 221 {
 222   BFD_ASSERT (bfd_mach_o_valid (ibfd));
 223   BFD_ASSERT (bfd_mach_o_valid (obfd));
 224
 225   obfd->tdata.mach_o_data = ibfd->tdata.mach_o_data;
 226   obfd->tdata.mach_o_data->ibfd = ibfd;
 227   return TRUE;
 228 }
 229
 230 static long
 231 bfd_mach_o_count_symbols (abfd)
 232      bfd *abfd;
 233 {
 234   bfd_mach_o_data_struct *mdata = NULL;
 235   long nsyms = 0;
 236   unsigned long i;
 237
 238   BFD_ASSERT (bfd_mach_o_valid (abfd));
 239   mdata = abfd->tdata.mach_o_data;
 240
 241   for (i = 0; i < mdata->header.ncmds; i++)
 242     if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB)
 243       {
 244         bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab;
 245         nsyms += sym->nsyms;
 246       }
 247
 248   return nsyms;
 249 }
 250
 251 static long
 252 bfd_mach_o_get_symtab_upper_bound (abfd)
 253      bfd *abfd;
 254 {
 255   long nsyms = bfd_mach_o_count_symbols (abfd);
 256
 257   if (nsyms < 0)
 258     return nsyms;
 259
 260   return ((nsyms + 1) * sizeof (asymbol *));
 261 }
 262
 263 static long
 264 bfd_mach_o_canonicalize_symtab (abfd, alocation)
 265      bfd *abfd;
 266      asymbol **alocation;
 267 {
 268   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
 269   long nsyms = bfd_mach_o_count_symbols (abfd);
 270   asymbol **csym = alocation;
 271   unsigned long i, j;
 272
 273   if (nsyms < 0)
 274     return nsyms;
 275
 276   for (i = 0; i < mdata->header.ncmds; i++)
 277     {
 278       if (mdata->commands[i].type == BFD_MACH_O_LC_SYMTAB)
 279         {
 280           bfd_mach_o_symtab_command *sym = &mdata->commands[i].command.symtab;
 281
 282           if (bfd_mach_o_scan_read_symtab_symbols (abfd, &mdata->commands[i].command.symtab) != 0)
 283             {
 284               fprintf (stderr, "bfd_mach_o_canonicalize_symtab: unable to load symbols for section %lu\n", i);
 285               return 0;
 286             }
 287
 288           BFD_ASSERT (sym->symbols != NULL);
 289
 290           for (j = 0; j < sym->nsyms; j++)
 291             {
 292               BFD_ASSERT (csym < (alocation + nsyms));
 293               *csym++ = &sym->symbols[j];
 294             }
 295         }
 296     }
 297
 298   *csym++ = NULL;
 299
 300   return nsyms;
 301 }
 302
 303 static void
 304 bfd_mach_o_get_symbol_info (abfd, symbol, ret)
 305      bfd *abfd ATTRIBUTE_UNUSED;
 306      asymbol *symbol;
 307      symbol_info *ret;
 308 {
 309   bfd_symbol_info (symbol, ret);
 310 }
 311
 312 static void
 313 bfd_mach_o_print_symbol (abfd, afile, symbol, how)
 314      bfd *abfd;
 315      PTR afile;
 316      asymbol *symbol;
 317      bfd_print_symbol_type how;
 318 {
 319   FILE *file = (FILE *) afile;
 320
 321   switch (how)
 322     {
 323     case bfd_print_symbol_name:
 324       fprintf (file, "%s", symbol->name);
 325       break;
 326     default:
 327       bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
 328       fprintf (file, " %-5s %s", symbol->section->name, symbol->name);
 329     }
 330 }
 331
 332 static void
 333 bfd_mach_o_convert_architecture (mtype, msubtype, type, subtype)
 334      bfd_mach_o_cpu_type mtype;
 335      bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED;
 336      enum bfd_architecture *type;
 337      unsigned long *subtype;
 338 {
 339   *subtype = bfd_arch_unknown;
 340
 341   switch (mtype)
 342     {
 343     case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
 344     case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
 345     case BFD_MACH_O_CPU_TYPE_I386: *type = bfd_arch_i386; break;
 346     case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
 347     case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
 348     case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
 349     case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
 350     case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
 351     case BFD_MACH_O_CPU_TYPE_SPARC: *type = bfd_arch_sparc; break;
 352     case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
 353     case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
 354     case BFD_MACH_O_CPU_TYPE_POWERPC: *type = bfd_arch_powerpc; break;
 355     default: *type = bfd_arch_unknown; break;
 356     }
 357
 358   switch (*type)
 359     {
 360     case bfd_arch_i386: *subtype = bfd_mach_i386_i386; break;
 361     case bfd_arch_sparc: *subtype = bfd_mach_sparc; break;
 362     default:
 363       *subtype = bfd_arch_unknown;
 364     }
 365 }
 366
 367 static bfd_boolean
 368 bfd_mach_o_write_contents (abfd)
 369      bfd *abfd;
 370 {
 371   unsigned int i;
 372   asection *s;
 373
 374   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
 375
 376   /* Write data sections first in case they overlap header data to be
 377      written later.  */
 378
 379   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
 380     ;
 381
 382   /* Now write header information.  */
 383   if (bfd_mach_o_write_header (abfd, &mdata->header) != 0)
 384     return FALSE;
 385
 386   for (i = 0; i < mdata->header.ncmds; i++)
 387     {
 388       unsigned char buf[8];
 389       bfd_mach_o_load_command *cur = &mdata->commands[i];
 390       unsigned long typeflag;
 391
 392       typeflag = cur->type_required ? cur->type & BFD_MACH_O_LC_REQ_DYLD : cur->type;
 393
 394       bfd_h_put_32 (abfd, typeflag, buf);
 395       bfd_h_put_32 (abfd, cur->len, buf + 4);
 396
 397       bfd_seek (abfd, cur->offset, SEEK_SET);
 398       if (bfd_bwrite ((PTR) buf, 8, abfd) != 8)
 399         return FALSE;
 400
 401       switch (cur->type)
 402         {
 403         case BFD_MACH_O_LC_SEGMENT:
 404           if (bfd_mach_o_scan_write_segment (abfd, cur) != 0)
 405             return FALSE;
 406           break;
 407         case BFD_MACH_O_LC_SYMTAB:
 408           if (bfd_mach_o_scan_write_symtab (abfd, cur) != 0)
 409             return FALSE;
 410           break;
 411         case BFD_MACH_O_LC_SYMSEG:
 412           break;
 413         case BFD_MACH_O_LC_THREAD:
 414         case BFD_MACH_O_LC_UNIXTHREAD:
 415           if (bfd_mach_o_scan_write_thread (abfd, cur) != 0)
 416             return FALSE;
 417           break;
 418         case BFD_MACH_O_LC_LOADFVMLIB:
 419         case BFD_MACH_O_LC_IDFVMLIB:
 420         case BFD_MACH_O_LC_IDENT:
 421         case BFD_MACH_O_LC_FVMFILE:
 422         case BFD_MACH_O_LC_PREPAGE:
 423         case BFD_MACH_O_LC_DYSYMTAB:
 424         case BFD_MACH_O_LC_LOAD_DYLIB:
 425         case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
 426         case BFD_MACH_O_LC_ID_DYLIB:
 427         case BFD_MACH_O_LC_LOAD_DYLINKER:
 428         case BFD_MACH_O_LC_ID_DYLINKER:
 429         case BFD_MACH_O_LC_PREBOUND_DYLIB:
 430         case BFD_MACH_O_LC_ROUTINES:
 431         case BFD_MACH_O_LC_SUB_FRAMEWORK:
 432           break;
 433         default:
 434           fprintf (stderr,
 435                    "unable to write unknown load command 0x%lx\n",
 436                    (long) cur->type);
 437           return FALSE;
 438         }
 439     }
 440
 441   return TRUE;
 442 }
 443
 444 static int
 445 bfd_mach_o_sizeof_headers (a, b)
 446      bfd *a ATTRIBUTE_UNUSED;
 447      bfd_boolean b ATTRIBUTE_UNUSED;
 448 {
 449   return 0;
 450 }
 451
 452 /* Make an empty symbol.  This is required only because
 453    bfd_make_section_anyway wants to create a symbol for the section.  */
 454
 455 static asymbol *
 456 bfd_mach_o_make_empty_symbol (abfd)
 457      bfd *abfd;
 458 {
 459   asymbol *new;
 460
 461   new = (asymbol *) bfd_zalloc (abfd, sizeof (asymbol));
 462   if (new == NULL)
 463     return new;
 464   new->the_bfd = abfd;
 465   return new;
 466 }
 467
 468 static int
 469 bfd_mach_o_write_header (abfd, header)
 470      bfd *abfd;
 471      bfd_mach_o_header *header;
 472 {
 473   unsigned char buf[28];
 474
 475   bfd_h_put_32 (abfd, header->magic, buf + 0);
 476   bfd_h_put_32 (abfd, header->cputype, buf + 4);
 477   bfd_h_put_32 (abfd, header->cpusubtype, buf + 8);
 478   bfd_h_put_32 (abfd, header->filetype, buf + 12);
 479   bfd_h_put_32 (abfd, header->ncmds, buf + 16);
 480   bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20);
 481   bfd_h_put_32 (abfd, header->flags, buf + 24);
 482
 483   bfd_seek (abfd, 0, SEEK_SET);
 484   if (bfd_bwrite ((PTR) buf, 28, abfd) != 28)
 485     return -1;
 486
 487   return 0;
 488 }
 489
 490 static int
 491 bfd_mach_o_read_header (abfd, header)
 492      bfd *abfd;
 493      bfd_mach_o_header *header;
 494 {
 495   unsigned char buf[28];
 496   bfd_vma (*get32) (const void *) = NULL;
 497
 498   bfd_seek (abfd, 0, SEEK_SET);
 499
 500   if (bfd_bread ((PTR) buf, 28, abfd) != 28)
 501     return -1;
 502
 503   if (bfd_getb32 (buf) == 0xfeedface)
 504     {
 505       header->byteorder = BFD_ENDIAN_BIG;
 506       header->magic = 0xfeedface;
 507       get32 = bfd_getb32;
 508     }
 509   else if (bfd_getl32 (buf) == 0xfeedface)
 510     {
 511       header->byteorder = BFD_ENDIAN_LITTLE;
 512       header->magic = 0xfeedface;
 513       get32 = bfd_getl32;
 514     }
 515   else
 516     {
 517       header->byteorder = BFD_ENDIAN_UNKNOWN;
 518       return -1;
 519     }
 520
 521   header->cputype = (*get32) (buf + 4);
 522   header->cpusubtype = (*get32) (buf + 8);
 523   header->filetype = (*get32) (buf + 12);
 524   header->ncmds = (*get32) (buf + 16);
 525   header->sizeofcmds = (*get32) (buf + 20);
 526   header->flags = (*get32) (buf + 24);
 527
 528   return 0;
 529 }
 530
 531 static asection *
 532 bfd_mach_o_make_bfd_section (abfd, section)
 533      bfd *abfd;
 534      bfd_mach_o_section *section;
 535 {
 536   asection *bfdsec;
 537   char *sname;
 538   const char *prefix = "LC_SEGMENT";
 539   unsigned int snamelen;
 540
 541   snamelen = strlen (prefix) + 1
 542     + strlen (section->segname) + 1
 543     + strlen (section->sectname) + 1;
 544
 545   sname = (char *) bfd_alloc (abfd, snamelen);
 546   if (sname == NULL)
 547     return NULL;
 548   sprintf (sname, "%s.%s.%s", prefix, section->segname, section->sectname);
 549
 550   bfdsec = bfd_make_section_anyway (abfd, sname);
 551   if (bfdsec == NULL)
 552     return NULL;
 553
 554   bfdsec->vma = section->addr;
 555   bfdsec->lma = section->addr;
 556   bfdsec->size = section->size;
 557   bfdsec->filepos = section->offset;
 558   bfdsec->alignment_power = section->align;
 559
 560   if (section->flags & BFD_MACH_O_S_ZEROFILL)
 561     bfdsec->flags = SEC_ALLOC;
 562   else
 563     bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
 564
 565   return bfdsec;
 566 }
 567
 568 static int
 569 bfd_mach_o_scan_read_section (abfd, section, offset)
 570      bfd *abfd;
 571      bfd_mach_o_section *section;
 572      bfd_vma offset;
 573 {
 574   unsigned char buf[68];
 575
 576   bfd_seek (abfd, offset, SEEK_SET);
 577   if (bfd_bread ((PTR) buf, 68, abfd) != 68)
 578     return -1;
 579
 580   memcpy (section->sectname, buf, 16);
 581   section->sectname[16] = '\0';
 582   memcpy (section->segname, buf + 16, 16);
 583   section->segname[16] = '\0';
 584   section->addr = bfd_h_get_32 (abfd, buf + 32);
 585   section->size = bfd_h_get_32 (abfd, buf + 36);
 586   section->offset = bfd_h_get_32 (abfd, buf + 40);
 587   section->align = bfd_h_get_32 (abfd, buf + 44);
 588   section->reloff = bfd_h_get_32 (abfd, buf + 48);
 589   section->nreloc = bfd_h_get_32 (abfd, buf + 52);
 590   section->flags = bfd_h_get_32 (abfd, buf + 56);
 591   section->reserved1 = bfd_h_get_32 (abfd, buf + 60);
 592   section->reserved2 = bfd_h_get_32 (abfd, buf + 64);
 593   section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section);
 594
 595   if (section->bfdsection == NULL)
 596     return -1;
 597
 598   return 0;
 599 }
 600
 601 static int
 602 bfd_mach_o_scan_write_section (abfd, section, offset)
 603      bfd *abfd;
 604      bfd_mach_o_section *section;
 605      bfd_vma offset;
 606 {
 607   unsigned char buf[68];
 608
 609   memcpy (buf, section->sectname, 16);
 610   memcpy (buf + 16, section->segname, 16);
 611   bfd_h_put_32 (abfd, section->addr, buf + 32);
 612   bfd_h_put_32 (abfd, section->size, buf + 36);
 613   bfd_h_put_32 (abfd, section->offset, buf + 40);
 614   bfd_h_put_32 (abfd, section->align, buf + 44);
 615   bfd_h_put_32 (abfd, section->reloff, buf + 48);
 616   bfd_h_put_32 (abfd, section->nreloc, buf + 52);
 617   bfd_h_put_32 (abfd, section->flags, buf + 56);
 618   /* bfd_h_put_32 (abfd, section->reserved1, buf + 60); */
 619   /* bfd_h_put_32 (abfd, section->reserved2, buf + 64); */
 620
 621   bfd_seek (abfd, offset, SEEK_SET);
 622   if (bfd_bwrite ((PTR) buf, 68, abfd) != 68)
 623     return -1;
 624
 625   return 0;
 626 }
 627
 628 static int
 629 bfd_mach_o_scan_write_symtab_symbols (abfd, command)
 630      bfd *abfd;
 631      bfd_mach_o_load_command *command;
 632 {
 633   bfd_mach_o_symtab_command *sym = &command->command.symtab;
 634   asymbol *s = NULL;
 635   unsigned long i;
 636
 637   for (i = 0; i < sym->nsyms; i++)
 638     {
 639       unsigned char buf[12];
 640       bfd_vma symoff = sym->symoff + (i * 12);
 641       unsigned char ntype = 0;
 642       unsigned char nsect = 0;
 643       short ndesc = 0;
 644
 645       s = &sym->symbols[i];
 646
 647       /* Instead just set from the stored values.  */
 648       ntype = (s->udata.i >> 24) & 0xff;
 649       nsect = (s->udata.i >> 16) & 0xff;
 650       ndesc = s->udata.i & 0xffff;
 651
 652       bfd_h_put_32 (abfd, s->name - sym->strtab, buf);
 653       bfd_h_put_8 (abfd, ntype, buf + 4);
 654       bfd_h_put_8 (abfd, nsect, buf + 5);
 655       bfd_h_put_16 (abfd, ndesc, buf + 6);
 656       bfd_h_put_32 (abfd, s->section->vma + s->value, buf + 8);
 657
 658       bfd_seek (abfd, symoff, SEEK_SET);
 659       if (bfd_bwrite ((PTR) buf, 12, abfd) != 12)
 660         {
 661           fprintf (stderr, "bfd_mach_o_scan_write_symtab_symbols: unable to write %d bytes at %lu\n",
 662                    12, (unsigned long) symoff);
 663           return -1;
 664         }
 665     }
 666
 667   return 0;
 668 }
 669
 670 int
 671 bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, i)
 672      bfd *abfd;
 673      bfd_mach_o_symtab_command *sym;
 674      asymbol *s;
 675      unsigned long i;
 676 {
 677   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
 678   bfd_vma symoff = sym->symoff + (i * 12);
 679   unsigned char buf[12];
 680   unsigned char type = -1;
 681   unsigned char section = -1;
 682   short desc = -1;
 683   unsigned long value = -1;
 684   unsigned long stroff = -1;
 685   unsigned int symtype = -1;
 686
 687   BFD_ASSERT (sym->strtab != NULL);
 688
 689   bfd_seek (abfd, symoff, SEEK_SET);
 690   if (bfd_bread ((PTR) buf, 12, abfd) != 12)
 691     {
 692       fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: unable to read %d bytes at %lu\n",
 693                12, (unsigned long) symoff);
 694       return -1;
 695     }
 696
 697   stroff = bfd_h_get_32 (abfd, buf);
 698   type = bfd_h_get_8 (abfd, buf + 4);
 699   symtype = (type & 0x0e);
 700   section = bfd_h_get_8 (abfd, buf + 5) - 1;
 701   desc = bfd_h_get_16 (abfd, buf + 6);
 702   value = bfd_h_get_32 (abfd, buf + 8);
 703
 704   if (stroff >= sym->strsize)
 705     {
 706       fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
 707                (unsigned long) stroff, (unsigned long) sym->strsize);
 708       return -1;
 709     }
 710
 711   s->the_bfd = abfd;
 712   s->name = sym->strtab + stroff;
 713   s->value = value;
 714   s->udata.i = (type << 24) | (section << 16) | desc;
 715   s->flags = 0x0;
 716
 717   if (type & BFD_MACH_O_N_STAB)
 718     {
 719       s->flags |= BSF_DEBUGGING;
 720       s->section = bfd_und_section_ptr;
 721     }
 722   else
 723     {
 724       if (type & BFD_MACH_O_N_PEXT)
 725         {
 726           type &= ~BFD_MACH_O_N_PEXT;
 727           s->flags |= BSF_GLOBAL;
 728         }
 729
 730       if (type & BFD_MACH_O_N_EXT)
 731         {
 732           type &= ~BFD_MACH_O_N_EXT;
 733           s->flags |= BSF_GLOBAL;
 734         }
 735
 736       switch (symtype)
 737         {
 738         case BFD_MACH_O_N_UNDF:
 739           s->section = bfd_und_section_ptr;
 740           break;
 741         case BFD_MACH_O_N_PBUD:
 742           s->section = bfd_und_section_ptr;
 743           break;
 744         case BFD_MACH_O_N_ABS:
 745           s->section = bfd_abs_section_ptr;
 746           break;
 747         case BFD_MACH_O_N_SECT:
 748           if ((section > 0) && (section <= mdata->nsects))
 749             {
 750               s->section = mdata->sections[section - 1]->bfdsection;
 751               s->value = s->value - mdata->sections[section - 1]->addr;
 752             }
 753           else
 754             {
 755               /* Mach-O uses 0 to mean "no section"; not an error.  */
 756               if (section != 0)
 757                 {
 758                   fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
 759                            "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
 760                            s->name, section, mdata->nsects);
 761                 }
 762               s->section = bfd_und_section_ptr;
 763             }
 764           break;
 765         case BFD_MACH_O_N_INDR:
 766           fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
 767                    "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
 768                    s->name);
 769           s->section = bfd_und_section_ptr;
 770           break;
 771         default:
 772           fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbol: "
 773                    "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
 774                    s->name, symtype);
 775           s->section = bfd_und_section_ptr;
 776           break;
 777         }
 778     }
 779
 780   return 0;
 781 }
 782
 783 int
 784 bfd_mach_o_scan_read_symtab_strtab (abfd, sym)
 785      bfd *abfd;
 786      bfd_mach_o_symtab_command *sym;
 787 {
 788   BFD_ASSERT (sym->strtab == NULL);
 789
 790   if (abfd->flags & BFD_IN_MEMORY)
 791     {
 792       struct bfd_in_memory *b;
 793
 794       b = (struct bfd_in_memory *) abfd->iostream;
 795
 796       if ((sym->stroff + sym->strsize) > b->size)
 797         {
 798           bfd_set_error (bfd_error_file_truncated);
 799           return -1;
 800         }
 801       sym->strtab = (char *) b->buffer + sym->stroff;
 802       return 0;
 803     }
 804
 805   sym->strtab = bfd_alloc (abfd, sym->strsize);
 806   if (sym->strtab == NULL)
 807     return -1;
 808
 809   bfd_seek (abfd, sym->stroff, SEEK_SET);
 810   if (bfd_bread ((PTR) sym->strtab, sym->strsize, abfd) != sym->strsize)
 811     {
 812       fprintf (stderr, "bfd_mach_o_scan_read_symtab_strtab: unable to read %lu bytes at %lu\n",
 813                sym->strsize, sym->stroff);
 814       return -1;
 815     }
 816
 817   return 0;
 818 }
 819
 820 int
 821 bfd_mach_o_scan_read_symtab_symbols (abfd, sym)
 822      bfd *abfd;
 823      bfd_mach_o_symtab_command *sym;
 824 {
 825   unsigned long i;
 826   int ret;
 827
 828   BFD_ASSERT (sym->symbols == NULL);
 829   sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (asymbol));
 830
 831   if (sym->symbols == NULL)
 832     {
 833       fprintf (stderr, "bfd_mach_o_scan_read_symtab_symbols: unable to allocate memory for symbols\n");
 834       return -1;
 835     }
 836
 837   ret = bfd_mach_o_scan_read_symtab_strtab (abfd, sym);
 838   if (ret != 0)
 839     return ret;
 840
 841   for (i = 0; i < sym->nsyms; i++)
 842     {
 843       ret = bfd_mach_o_scan_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
 844       if (ret != 0)
 845         return ret;
 846     }
 847
 848   return 0;
 849 }
 850
 851 int
 852 bfd_mach_o_scan_read_dysymtab_symbol (abfd, dysym, sym, s, i)
 853      bfd *abfd;
 854      bfd_mach_o_dysymtab_command *dysym;
 855      bfd_mach_o_symtab_command *sym;
 856      asymbol *s;
 857      unsigned long i;
 858 {
 859   unsigned long isymoff = dysym->indirectsymoff + (i * 4);
 860   unsigned long symindex;
 861   unsigned char buf[4];
 862
 863   BFD_ASSERT (i < dysym->nindirectsyms);
 864
 865   bfd_seek (abfd, isymoff, SEEK_SET);
 866   if (bfd_bread ((PTR) buf, 4, abfd) != 4)
 867     {
 868       fprintf (stderr, "bfd_mach_o_scan_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
 869                (unsigned long) 4, isymoff);
 870       return -1;
 871     }
 872   symindex = bfd_h_get_32 (abfd, buf);
 873
 874   return bfd_mach_o_scan_read_symtab_symbol (abfd, sym, s, symindex);
 875 }
 876
 877 static const char *
 878 bfd_mach_o_i386_flavour_string (flavour)
 879      unsigned int flavour;
 880 {
 881   switch ((int) flavour)
 882     {
 883     case BFD_MACH_O_i386_NEW_THREAD_STATE: return "i386_NEW_THREAD_STATE";
 884     case BFD_MACH_O_i386_FLOAT_STATE: return "i386_FLOAT_STATE";
 885     case BFD_MACH_O_i386_ISA_PORT_MAP_STATE: return "i386_ISA_PORT_MAP_STATE";
 886     case BFD_MACH_O_i386_V86_ASSIST_STATE: return "i386_V86_ASSIST_STATE";
 887     case BFD_MACH_O_i386_REGS_SEGS_STATE: return "i386_REGS_SEGS_STATE";
 888     case BFD_MACH_O_i386_THREAD_SYSCALL_STATE: return "i386_THREAD_SYSCALL_STATE";
 889     case BFD_MACH_O_i386_THREAD_STATE_NONE: return "i386_THREAD_STATE_NONE";
 890     case BFD_MACH_O_i386_SAVED_STATE: return "i386_SAVED_STATE";
 891     case BFD_MACH_O_i386_THREAD_STATE: return "i386_THREAD_STATE";
 892     case BFD_MACH_O_i386_THREAD_FPSTATE: return "i386_THREAD_FPSTATE";
 893     case BFD_MACH_O_i386_THREAD_EXCEPTSTATE: return "i386_THREAD_EXCEPTSTATE";
 894     case BFD_MACH_O_i386_THREAD_CTHREADSTATE: return "i386_THREAD_CTHREADSTATE";
 895     default: return "UNKNOWN";
 896     }
 897 }
 898
 899 static const char *
 900 bfd_mach_o_ppc_flavour_string (flavour)
 901      unsigned int flavour;
 902 {
 903   switch ((int) flavour)
 904     {
 905     case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
 906     case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
 907     case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
 908     case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
 909     default: return "UNKNOWN";
 910     }
 911 }
 912
 913 static int
 914 bfd_mach_o_scan_write_thread (abfd, command)
 915      bfd *abfd;
 916      bfd_mach_o_load_command *command;
 917 {
 918   bfd_mach_o_thread_command *cmd = &command->command.thread;
 919   unsigned int i;
 920   unsigned char buf[8];
 921   bfd_vma offset;
 922   unsigned int nflavours;
 923
 924   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
 925               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
 926
 927   offset = 8;
 928   nflavours = 0;
 929   for (i = 0; i < cmd->nflavours; i++)
 930     {
 931       BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
 932       BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8));
 933
 934       bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf);
 935       bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
 936
 937       bfd_seek (abfd, command->offset + offset, SEEK_SET);
 938       if (bfd_bwrite ((PTR) buf, 8, abfd) != 8)
 939         return -1;
 940
 941       offset += cmd->flavours[i].size + 8;
 942     }
 943
 944   return 0;
 945 }
 946
 947 static int
 948 bfd_mach_o_scan_read_dylinker (abfd, command)
 949      bfd *abfd;
 950      bfd_mach_o_load_command *command;
 951 {
 952   bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
 953   unsigned char buf[4];
 954   unsigned int nameoff;
 955   asection *bfdsec;
 956   char *sname;
 957   const char *prefix;
 958
 959   BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
 960               || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
 961
 962   bfd_seek (abfd, command->offset + 8, SEEK_SET);
 963   if (bfd_bread ((PTR) buf, 4, abfd) != 4)
 964     return -1;
 965
 966   nameoff = bfd_h_get_32 (abfd, buf + 0);
 967
 968   cmd->name_offset = command->offset + nameoff;
 969   cmd->name_len = command->len - nameoff;
 970
 971   if (command->type == BFD_MACH_O_LC_LOAD_DYLINKER)
 972     prefix = "LC_LOAD_DYLINKER";
 973   else if (command->type == BFD_MACH_O_LC_ID_DYLINKER)
 974     prefix = "LC_ID_DYLINKER";
 975   else
 976     abort ();
 977
 978   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
 979   if (sname == NULL)
 980     return -1;
 981   strcpy (sname, prefix);
 982
 983   bfdsec = bfd_make_section_anyway (abfd, sname);
 984   if (bfdsec == NULL)
 985     return -1;
 986
 987   bfdsec->vma = 0;
 988   bfdsec->lma = 0;
 989   bfdsec->size = command->len - 8;
 990   bfdsec->filepos = command->offset + 8;
 991   bfdsec->alignment_power = 0;
 992   bfdsec->flags = SEC_HAS_CONTENTS;
 993
 994   cmd->section = bfdsec;
 995
 996   return 0;
 997 }
 998
 999 static int
1000 bfd_mach_o_scan_read_dylib (abfd, command)
1001      bfd *abfd;
1002      bfd_mach_o_load_command *command;
1003 {
1004   bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1005   unsigned char buf[16];
1006   unsigned int nameoff;
1007   asection *bfdsec;
1008   char *sname;
1009   const char *prefix;
1010
1011   BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLIB)
1012               || (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1013               || (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB));
1014
1015   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1016   if (bfd_bread ((PTR) buf, 16, abfd) != 16)
1017     return -1;
1018
1019   nameoff = bfd_h_get_32 (abfd, buf + 0);
1020   cmd->timestamp = bfd_h_get_32 (abfd, buf + 4);
1021   cmd->current_version = bfd_h_get_32 (abfd, buf + 8);
1022   cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12);
1023
1024   cmd->name_offset = command->offset + nameoff;
1025   cmd->name_len = command->len - nameoff;
1026
1027   if (command->type == BFD_MACH_O_LC_LOAD_DYLIB)
1028     prefix = "LC_LOAD_DYLIB";
1029   else if (command->type == BFD_MACH_O_LC_LOAD_WEAK_DYLIB)
1030     prefix = "LC_LOAD_WEAK_DYLIB";
1031   else if (command->type == BFD_MACH_O_LC_ID_DYLIB)
1032     prefix = "LC_ID_DYLIB";
1033   else
1034     abort ();
1035
1036   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1037   if (sname == NULL)
1038     return -1;
1039   strcpy (sname, prefix);
1040
1041   bfdsec = bfd_make_section_anyway (abfd, sname);
1042   if (bfdsec == NULL)
1043     return -1;
1044
1045   bfdsec->vma = 0;
1046   bfdsec->lma = 0;
1047   bfdsec->size = command->len - 8;
1048   bfdsec->filepos = command->offset + 8;
1049   bfdsec->alignment_power = 0;
1050   bfdsec->flags = SEC_HAS_CONTENTS;
1051
1052   cmd->section = bfdsec;
1053
1054   return 0;
1055 }
1056
1057 static int
1058 bfd_mach_o_scan_read_prebound_dylib (abfd, command)
1059      bfd *abfd ATTRIBUTE_UNUSED;
1060      bfd_mach_o_load_command *command ATTRIBUTE_UNUSED;
1061 {
1062   /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
1063
1064   BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
1065   return 0;
1066 }
1067
1068 static int
1069 bfd_mach_o_scan_read_thread (abfd, command)
1070      bfd *abfd;
1071      bfd_mach_o_load_command *command;
1072 {
1073   bfd_mach_o_data_struct *mdata = NULL;
1074   bfd_mach_o_thread_command *cmd = &command->command.thread;
1075   unsigned char buf[8];
1076   bfd_vma offset;
1077   unsigned int nflavours;
1078   unsigned int i;
1079
1080   BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1081               || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1082
1083   BFD_ASSERT (bfd_mach_o_valid (abfd));
1084   mdata = abfd->tdata.mach_o_data;
1085
1086   offset = 8;
1087   nflavours = 0;
1088   while (offset != command->len)
1089     {
1090       if (offset >= command->len)
1091         return -1;
1092
1093       bfd_seek (abfd, command->offset + offset, SEEK_SET);
1094
1095       if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1096         return -1;
1097
1098       offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
1099       nflavours++;
1100     }
1101
1102   cmd->flavours =
1103     ((bfd_mach_o_thread_flavour *)
1104      bfd_alloc (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour)));
1105   if (cmd->flavours == NULL)
1106     return -1;
1107   cmd->nflavours = nflavours;
1108
1109   offset = 8;
1110   nflavours = 0;
1111   while (offset != command->len)
1112     {
1113       if (offset >= command->len)
1114         return -1;
1115
1116       if (nflavours >= cmd->nflavours)
1117         return -1;
1118
1119       bfd_seek (abfd, command->offset + offset, SEEK_SET);
1120
1121       if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1122         return -1;
1123
1124       cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
1125       cmd->flavours[nflavours].offset = command->offset + offset + 8;
1126       cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4;
1127       offset += cmd->flavours[nflavours].size + 8;
1128       nflavours++;
1129     }
1130
1131   for (i = 0; i < nflavours; i++)
1132     {
1133       asection *bfdsec;
1134       unsigned int snamelen;
1135       char *sname;
1136       const char *flavourstr;
1137       const char *prefix = "LC_THREAD";
1138       unsigned int j = 0;
1139
1140       switch (mdata->header.cputype)
1141         {
1142         case BFD_MACH_O_CPU_TYPE_POWERPC:
1143           flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
1144           break;
1145         case BFD_MACH_O_CPU_TYPE_I386:
1146           flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
1147           break;
1148         default:
1149           flavourstr = "UNKNOWN_ARCHITECTURE";
1150           break;
1151         }
1152
1153       snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
1154       sname = (char *) bfd_alloc (abfd, snamelen);
1155       if (sname == NULL)
1156         return -1;
1157
1158       for (;;)
1159         {
1160           sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
1161           if (bfd_get_section_by_name (abfd, sname) == NULL)
1162             break;
1163           j++;
1164         }
1165
1166       bfdsec = bfd_make_section (abfd, sname);
1167
1168       bfdsec->vma = 0;
1169       bfdsec->lma = 0;
1170       bfdsec->size = cmd->flavours[i].size;
1171       bfdsec->filepos = cmd->flavours[i].offset;
1172       bfdsec->alignment_power = 0x0;
1173       bfdsec->flags = SEC_HAS_CONTENTS;
1174
1175       cmd->section = bfdsec;
1176     }
1177
1178   return 0;
1179 }
1180
1181 static int
1182 bfd_mach_o_scan_write_symtab (abfd, command)
1183      bfd *abfd;
1184      bfd_mach_o_load_command *command;
1185 {
1186   bfd_mach_o_symtab_command *seg = &command->command.symtab;
1187   unsigned char buf[16];
1188
1189   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1190
1191   bfd_h_put_32 (abfd, seg->symoff, buf);
1192   bfd_h_put_32 (abfd, seg->nsyms, buf + 4);
1193   bfd_h_put_32 (abfd, seg->stroff, buf + 8);
1194   bfd_h_put_32 (abfd, seg->strsize, buf + 12);
1195
1196   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1197   if (bfd_bwrite ((PTR) buf, 16, abfd) != 16)
1198     return -1;
1199
1200   if (bfd_mach_o_scan_write_symtab_symbols (abfd, command) != 0)
1201     return -1;
1202
1203   return 0;
1204 }
1205
1206 static int
1207 bfd_mach_o_scan_read_dysymtab (abfd, command)
1208      bfd *abfd;
1209      bfd_mach_o_load_command *command;
1210 {
1211   bfd_mach_o_dysymtab_command *seg = &command->command.dysymtab;
1212   unsigned char buf[72];
1213
1214   BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1215
1216   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1217   if (bfd_bread ((PTR) buf, 72, abfd) != 72)
1218     return -1;
1219
1220   seg->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
1221   seg->nlocalsym = bfd_h_get_32 (abfd, buf + 4);
1222   seg->iextdefsym = bfd_h_get_32 (abfd, buf + 8);
1223   seg->nextdefsym = bfd_h_get_32 (abfd, buf + 12);
1224   seg->iundefsym = bfd_h_get_32 (abfd, buf + 16);
1225   seg->nundefsym = bfd_h_get_32 (abfd, buf + 20);
1226   seg->tocoff = bfd_h_get_32 (abfd, buf + 24);
1227   seg->ntoc = bfd_h_get_32 (abfd, buf + 28);
1228   seg->modtaboff = bfd_h_get_32 (abfd, buf + 32);
1229   seg->nmodtab = bfd_h_get_32 (abfd, buf + 36);
1230   seg->extrefsymoff = bfd_h_get_32 (abfd, buf + 40);
1231   seg->nextrefsyms = bfd_h_get_32 (abfd, buf + 44);
1232   seg->indirectsymoff = bfd_h_get_32 (abfd, buf + 48);
1233   seg->nindirectsyms = bfd_h_get_32 (abfd, buf + 52);
1234   seg->extreloff = bfd_h_get_32 (abfd, buf + 56);
1235   seg->nextrel = bfd_h_get_32 (abfd, buf + 60);
1236   seg->locreloff = bfd_h_get_32 (abfd, buf + 64);
1237   seg->nlocrel = bfd_h_get_32 (abfd, buf + 68);
1238
1239   return 0;
1240 }
1241
1242 static int
1243 bfd_mach_o_scan_read_symtab (abfd, command)
1244      bfd *abfd;
1245      bfd_mach_o_load_command *command;
1246 {
1247   bfd_mach_o_symtab_command *seg = &command->command.symtab;
1248   unsigned char buf[16];
1249   asection *bfdsec;
1250   char *sname;
1251   const char *prefix = "LC_SYMTAB.stabs";
1252
1253   BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1254
1255   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1256   if (bfd_bread ((PTR) buf, 16, abfd) != 16)
1257     return -1;
1258
1259   seg->symoff = bfd_h_get_32 (abfd, buf);
1260   seg->nsyms = bfd_h_get_32 (abfd, buf + 4);
1261   seg->stroff = bfd_h_get_32 (abfd, buf + 8);
1262   seg->strsize = bfd_h_get_32 (abfd, buf + 12);
1263   seg->symbols = NULL;
1264   seg->strtab = NULL;
1265
1266   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1267   if (sname == NULL)
1268     return -1;
1269   strcpy (sname, prefix);
1270
1271   bfdsec = bfd_make_section_anyway (abfd, sname);
1272   if (bfdsec == NULL)
1273     return -1;
1274
1275   bfdsec->vma = 0;
1276   bfdsec->lma = 0;
1277   bfdsec->size = seg->nsyms * 12;
1278   bfdsec->filepos = seg->symoff;
1279   bfdsec->alignment_power = 0;
1280   bfdsec->flags = SEC_HAS_CONTENTS;
1281
1282   seg->stabs_segment = bfdsec;
1283
1284   prefix = "LC_SYMTAB.stabstr";
1285   sname = (char *) bfd_alloc (abfd, strlen (prefix) + 1);
1286   if (sname == NULL)
1287     return -1;
1288   strcpy (sname, prefix);
1289
1290   bfdsec = bfd_make_section_anyway (abfd, sname);
1291   if (bfdsec == NULL)
1292     return -1;
1293
1294   bfdsec->vma = 0;
1295   bfdsec->lma = 0;
1296   bfdsec->size = seg->strsize;
1297   bfdsec->filepos = seg->stroff;
1298   bfdsec->alignment_power = 0;
1299   bfdsec->flags = SEC_HAS_CONTENTS;
1300
1301   seg->stabstr_segment = bfdsec;
1302
1303   return 0;
1304 }
1305
1306 static int
1307 bfd_mach_o_scan_read_segment (abfd, command)
1308      bfd *abfd;
1309      bfd_mach_o_load_command *command;
1310 {
1311   unsigned char buf[48];
1312   bfd_mach_o_segment_command *seg = &command->command.segment;
1313   unsigned long i;
1314   asection *bfdsec;
1315   char *sname;
1316   const char *prefix = "LC_SEGMENT";
1317   unsigned int snamelen;
1318
1319   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1320
1321   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1322   if (bfd_bread ((PTR) buf, 48, abfd) != 48)
1323     return -1;
1324
1325   memcpy (seg->segname, buf, 16);
1326   seg->vmaddr = bfd_h_get_32 (abfd, buf + 16);
1327   seg->vmsize = bfd_h_get_32 (abfd, buf + 20);
1328   seg->fileoff = bfd_h_get_32 (abfd, buf + 24);
1329   seg->filesize = bfd_h_get_32 (abfd, buf +  28);
1330   /* seg->maxprot = bfd_h_get_32 (abfd, buf + 32); */
1331   /* seg->initprot = bfd_h_get_32 (abfd, buf + 36); */
1332   seg->nsects = bfd_h_get_32 (abfd, buf + 40);
1333   seg->flags = bfd_h_get_32 (abfd, buf + 44);
1334
1335   snamelen = strlen (prefix) + 1 + strlen (seg->segname) + 1;
1336   sname = (char *) bfd_alloc (abfd, snamelen);
1337   if (sname == NULL)
1338     return -1;
1339   sprintf (sname, "%s.%s", prefix, seg->segname);
1340
1341   bfdsec = bfd_make_section_anyway (abfd, sname);
1342   if (bfdsec == NULL)
1343     return -1;
1344
1345   bfdsec->vma = seg->vmaddr;
1346   bfdsec->lma = seg->vmaddr;
1347   bfdsec->size = seg->filesize;
1348   bfdsec->filepos = seg->fileoff;
1349   bfdsec->alignment_power = 0x0;
1350   bfdsec->flags = SEC_HAS_CONTENTS | SEC_LOAD | SEC_ALLOC | SEC_CODE;
1351
1352   seg->segment = bfdsec;
1353
1354   if (seg->nsects != 0)
1355     {
1356       seg->sections =
1357         ((bfd_mach_o_section *)
1358          bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section)));
1359       if (seg->sections == NULL)
1360         return -1;
1361
1362       for (i = 0; i < seg->nsects; i++)
1363         {
1364           bfd_vma segoff = command->offset + 48 + 8 + (i * 68);
1365
1366           if (bfd_mach_o_scan_read_section (abfd, &seg->sections[i],
1367                                             segoff) != 0)
1368             return -1;
1369         }
1370     }
1371
1372   return 0;
1373 }
1374
1375 static int
1376 bfd_mach_o_scan_write_segment (abfd, command)
1377      bfd *abfd;
1378      bfd_mach_o_load_command *command;
1379 {
1380   unsigned char buf[48];
1381   bfd_mach_o_segment_command *seg = &command->command.segment;
1382   unsigned long i;
1383
1384   BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1385
1386   memcpy (buf, seg->segname, 16);
1387   bfd_h_put_32 (abfd, seg->vmaddr, buf + 16);
1388   bfd_h_put_32 (abfd, seg->vmsize, buf + 20);
1389   bfd_h_put_32 (abfd, seg->fileoff, buf + 24);
1390   bfd_h_put_32 (abfd, seg->filesize, buf + 28);
1391   bfd_h_put_32 (abfd, 0 /* seg->maxprot */, buf + 32);
1392   bfd_h_put_32 (abfd, 0 /* seg->initprot */, buf + 36);
1393   bfd_h_put_32 (abfd, seg->nsects, buf + 40);
1394   bfd_h_put_32 (abfd, seg->flags, buf + 44);
1395
1396   bfd_seek (abfd, command->offset + 8, SEEK_SET);
1397   if (bfd_bwrite ((PTR) buf, 48, abfd) != 48)
1398     return -1;
1399
1400   {
1401     char buf[1024];
1402     bfd_vma nbytes = seg->filesize;
1403     bfd_vma curoff = seg->fileoff;
1404
1405     while (nbytes > 0)
1406       {
1407         bfd_vma thisread = nbytes;
1408
1409         if (thisread > 1024)
1410           thisread = 1024;
1411
1412         bfd_seek (abfd, curoff, SEEK_SET);
1413         if (bfd_bread ((PTR) buf, thisread, abfd) != thisread)
1414           return -1;
1415
1416         bfd_seek (abfd, curoff, SEEK_SET);
1417         if (bfd_bwrite ((PTR) buf, thisread, abfd) != thisread)
1418           return -1;
1419
1420         nbytes -= thisread;
1421         curoff += thisread;
1422       }
1423   }
1424
1425   for (i = 0; i < seg->nsects; i++)
1426     {
1427       bfd_vma segoff = command->offset + 48 + 8 + (i * 68);
1428
1429       if (bfd_mach_o_scan_write_section (abfd, &seg->sections[i], segoff) != 0)
1430         return -1;
1431     }
1432
1433   return 0;
1434 }
1435
1436 static int
1437 bfd_mach_o_scan_read_command (abfd, command)
1438      bfd *abfd;
1439      bfd_mach_o_load_command *command;
1440 {
1441   unsigned char buf[8];
1442
1443   bfd_seek (abfd, command->offset, SEEK_SET);
1444   if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1445     return -1;
1446
1447   command->type = (bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD);
1448   command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD
1449                             ? 1 : 0);
1450   command->len = bfd_h_get_32 (abfd, buf + 4);
1451
1452   switch (command->type)
1453     {
1454     case BFD_MACH_O_LC_SEGMENT:
1455       if (bfd_mach_o_scan_read_segment (abfd, command) != 0)
1456         return -1;
1457       break;
1458     case BFD_MACH_O_LC_SYMTAB:
1459       if (bfd_mach_o_scan_read_symtab (abfd, command) != 0)
1460         return -1;
1461       break;
1462     case BFD_MACH_O_LC_SYMSEG:
1463       break;
1464     case BFD_MACH_O_LC_THREAD:
1465     case BFD_MACH_O_LC_UNIXTHREAD:
1466       if (bfd_mach_o_scan_read_thread (abfd, command) != 0)
1467         return -1;
1468       break;
1469     case BFD_MACH_O_LC_LOAD_DYLINKER:
1470     case BFD_MACH_O_LC_ID_DYLINKER:
1471       if (bfd_mach_o_scan_read_dylinker (abfd, command) != 0)
1472         return -1;
1473       break;
1474     case BFD_MACH_O_LC_LOAD_DYLIB:
1475     case BFD_MACH_O_LC_ID_DYLIB:
1476     case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1477       if (bfd_mach_o_scan_read_dylib (abfd, command) != 0)
1478         return -1;
1479       break;
1480     case BFD_MACH_O_LC_PREBOUND_DYLIB:
1481       if (bfd_mach_o_scan_read_prebound_dylib (abfd, command) != 0)
1482         return -1;
1483       break;
1484     case BFD_MACH_O_LC_LOADFVMLIB:
1485     case BFD_MACH_O_LC_IDFVMLIB:
1486     case BFD_MACH_O_LC_IDENT:
1487     case BFD_MACH_O_LC_FVMFILE:
1488     case BFD_MACH_O_LC_PREPAGE:
1489     case BFD_MACH_O_LC_ROUTINES:
1490     case BFD_MACH_O_LC_SUB_FRAMEWORK:
1491       break;
1492     case BFD_MACH_O_LC_DYSYMTAB:
1493       if (bfd_mach_o_scan_read_dysymtab (abfd, command) != 0)
1494         return -1;
1495       break;
1496     case BFD_MACH_O_LC_SUB_UMBRELLA:
1497     case BFD_MACH_O_LC_SUB_CLIENT:
1498     case BFD_MACH_O_LC_SUB_LIBRARY:
1499     case BFD_MACH_O_LC_TWOLEVEL_HINTS:
1500     case BFD_MACH_O_LC_PREBIND_CKSUM:
1501       break;
1502     default:
1503       fprintf (stderr, "unable to read unknown load command 0x%lx\n",
1504                (unsigned long) command->type);
1505       break;
1506     }
1507
1508   return 0;
1509 }
1510
1511 static void
1512 bfd_mach_o_flatten_sections (abfd)
1513      bfd *abfd;
1514 {
1515   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1516   long csect = 0;
1517   unsigned long i, j;
1518
1519   mdata->nsects = 0;
1520
1521   for (i = 0; i < mdata->header.ncmds; i++)
1522     {
1523       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT)
1524         {
1525           bfd_mach_o_segment_command *seg;
1526
1527           seg = &mdata->commands[i].command.segment;
1528           mdata->nsects += seg->nsects;
1529         }
1530     }
1531
1532   mdata->sections = bfd_alloc (abfd,
1533                                mdata->nsects * sizeof (bfd_mach_o_section *));
1534   csect = 0;
1535
1536   for (i = 0; i < mdata->header.ncmds; i++)
1537     {
1538       if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT)
1539         {
1540           bfd_mach_o_segment_command *seg;
1541
1542           seg = &mdata->commands[i].command.segment;
1543           BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
1544
1545           for (j = 0; j < seg->nsects; j++)
1546             mdata->sections[csect++] = &seg->sections[j];
1547         }
1548     }
1549 }
1550
1551 int
1552 bfd_mach_o_scan_start_address (abfd)
1553      bfd *abfd;
1554 {
1555   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
1556   bfd_mach_o_thread_command *cmd = NULL;
1557   unsigned long i;
1558
1559   for (i = 0; i < mdata->header.ncmds; i++)
1560     {
1561       if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
1562           (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
1563         {
1564           if (cmd == NULL)
1565             cmd = &mdata->commands[i].command.thread;
1566           else
1567             return 0;
1568         }
1569     }
1570
1571   if (cmd == NULL)
1572     return 0;
1573
1574   for (i = 0; i < cmd->nflavours; i++)
1575     {
1576       if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
1577           && (cmd->flavours[i].flavour
1578               == (unsigned long) BFD_MACH_O_i386_THREAD_STATE))
1579         {
1580           unsigned char buf[4];
1581
1582           bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET);
1583
1584           if (bfd_bread (buf, 4, abfd) != 4)
1585             return -1;
1586
1587           abfd->start_address = bfd_h_get_32 (abfd, buf);
1588         }
1589       else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
1590                && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
1591         {
1592           unsigned char buf[4];
1593
1594           bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET);
1595
1596           if (bfd_bread (buf, 4, abfd) != 4)
1597             return -1;
1598
1599           abfd->start_address = bfd_h_get_32 (abfd, buf);
1600         }
1601     }
1602
1603   return 0;
1604 }
1605
1606 int
1607 bfd_mach_o_scan (abfd, header, mdata)
1608      bfd *abfd;
1609      bfd_mach_o_header *header;
1610      bfd_mach_o_data_struct *mdata;
1611 {
1612   unsigned int i;
1613   enum bfd_architecture cputype;
1614   unsigned long cpusubtype;
1615
1616   mdata->header = *header;
1617   mdata->symbols = NULL;
1618
1619   abfd->flags = (abfd->xvec->object_flags
1620                  | (abfd->flags & (BFD_IN_MEMORY | BFD_IO_FUNCS)));
1621   abfd->tdata.mach_o_data = mdata;
1622
1623   bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
1624                                    &cputype, &cpusubtype);
1625   if (cputype == bfd_arch_unknown)
1626     {
1627       fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
1628                header->cputype, header->cpusubtype);
1629       return -1;
1630     }
1631
1632   bfd_set_arch_mach (abfd, cputype, cpusubtype);
1633
1634   if (header->ncmds != 0)
1635     {
1636       mdata->commands =
1637         ((bfd_mach_o_load_command *)
1638          bfd_alloc (abfd, header->ncmds * sizeof (bfd_mach_o_load_command)));
1639       if (mdata->commands == NULL)
1640         return -1;
1641
1642       for (i = 0; i < header->ncmds; i++)
1643         {
1644           bfd_mach_o_load_command *cur = &mdata->commands[i];
1645
1646           if (i == 0)
1647             cur->offset = 28;
1648           else
1649             {
1650               bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
1651               cur->offset = prev->offset + prev->len;
1652             }
1653
1654           if (bfd_mach_o_scan_read_command (abfd, cur) < 0)
1655             return -1;
1656         }
1657     }
1658
1659   if (bfd_mach_o_scan_start_address (abfd) < 0)
1660     return -1;
1661
1662   bfd_mach_o_flatten_sections (abfd);
1663   return 0;
1664 }
1665
1666 bfd_boolean
1667 bfd_mach_o_mkobject (abfd)
1668      bfd *abfd;
1669 {
1670   bfd_mach_o_data_struct *mdata = NULL;
1671
1672   mdata = ((bfd_mach_o_data_struct *)
1673            bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct)));
1674   if (mdata == NULL)
1675     return FALSE;
1676   abfd->tdata.mach_o_data = mdata;
1677
1678   mdata->header.magic = 0;
1679   mdata->header.cputype = 0;
1680   mdata->header.cpusubtype = 0;
1681   mdata->header.filetype = 0;
1682   mdata->header.ncmds = 0;
1683   mdata->header.sizeofcmds = 0;
1684   mdata->header.flags = 0;
1685   mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
1686   mdata->commands = NULL;
1687   mdata->nsymbols = 0;
1688   mdata->symbols = NULL;
1689   mdata->nsects = 0;
1690   mdata->sections = NULL;
1691   mdata->ibfd = NULL;
1692
1693   return TRUE;
1694 }
1695
1696 const bfd_target *
1697 bfd_mach_o_object_p (abfd)
1698      bfd *abfd;
1699 {
1700   struct bfd_preserve preserve;
1701   bfd_mach_o_header header;
1702
1703   preserve.marker = NULL;
1704   if (bfd_mach_o_read_header (abfd, &header) != 0)
1705     goto wrong;
1706
1707   if (! (header.byteorder == BFD_ENDIAN_BIG
1708          || header.byteorder == BFD_ENDIAN_LITTLE))
1709     {
1710       fprintf (stderr, "unknown header byte-order value 0x%lx\n",
1711                (long) header.byteorder);
1712       goto wrong;
1713     }
1714
1715   if (! ((header.byteorder == BFD_ENDIAN_BIG
1716           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
1717           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
1718          || (header.byteorder == BFD_ENDIAN_LITTLE
1719              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
1720              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
1721     goto wrong;
1722
1723   preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
1724   if (preserve.marker == NULL
1725       || !bfd_preserve_save (abfd, &preserve))
1726     goto fail;
1727
1728   if (bfd_mach_o_scan (abfd, &header,
1729                        (bfd_mach_o_data_struct *) preserve.marker) != 0)
1730     goto wrong;
1731
1732   bfd_preserve_finish (abfd, &preserve);
1733   return abfd->xvec;
1734
1735  wrong:
1736   bfd_set_error (bfd_error_wrong_format);
1737
1738  fail:
1739   if (preserve.marker != NULL)
1740     bfd_preserve_restore (abfd, &preserve);
1741   return NULL;
1742 }
1743
1744 const bfd_target *
1745 bfd_mach_o_core_p (abfd)
1746      bfd *abfd;
1747 {
1748   struct bfd_preserve preserve;
1749   bfd_mach_o_header header;
1750
1751   preserve.marker = NULL;
1752   if (bfd_mach_o_read_header (abfd, &header) != 0)
1753     goto wrong;
1754
1755   if (! (header.byteorder == BFD_ENDIAN_BIG
1756          || header.byteorder == BFD_ENDIAN_LITTLE))
1757     {
1758       fprintf (stderr, "unknown header byte-order value 0x%lx\n",
1759                (long) header.byteorder);
1760       abort ();
1761     }
1762
1763   if (! ((header.byteorder == BFD_ENDIAN_BIG
1764           && abfd->xvec->byteorder == BFD_ENDIAN_BIG
1765           && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
1766          || (header.byteorder == BFD_ENDIAN_LITTLE
1767              && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
1768              && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
1769     goto wrong;
1770
1771   if (header.filetype != BFD_MACH_O_MH_CORE)
1772     goto wrong;
1773
1774   preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
1775   if (preserve.marker == NULL
1776       || !bfd_preserve_save (abfd, &preserve))
1777     goto fail;
1778
1779   if (bfd_mach_o_scan (abfd, &header,
1780                        (bfd_mach_o_data_struct *) preserve.marker) != 0)
1781     goto wrong;
1782
1783   bfd_preserve_finish (abfd, &preserve);
1784   return abfd->xvec;
1785
1786  wrong:
1787   bfd_set_error (bfd_error_wrong_format);
1788
1789  fail:
1790   if (preserve.marker != NULL)
1791     bfd_preserve_restore (abfd, &preserve);
1792   return NULL;
1793 }
1794
1795 typedef struct mach_o_fat_archentry
1796 {
1797   unsigned long cputype;
1798   unsigned long cpusubtype;
1799   unsigned long offset;
1800   unsigned long size;
1801   unsigned long align;
1802   bfd *abfd;
1803 } mach_o_fat_archentry;
1804
1805 typedef struct mach_o_fat_data_struct
1806 {
1807   unsigned long magic;
1808   unsigned long nfat_arch;
1809   mach_o_fat_archentry *archentries;
1810 } mach_o_fat_data_struct;
1811
1812 const bfd_target *
1813 bfd_mach_o_archive_p (abfd)
1814      bfd *abfd;
1815 {
1816   mach_o_fat_data_struct *adata = NULL;
1817   unsigned char buf[20];
1818   unsigned long i;
1819
1820   bfd_seek (abfd, 0, SEEK_SET);
1821   if (bfd_bread ((PTR) buf, 8, abfd) != 8)
1822     goto error;
1823
1824   adata = (mach_o_fat_data_struct *)
1825     bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
1826   if (adata == NULL)
1827     goto error;
1828
1829   adata->magic = bfd_getb32 (buf);
1830   adata->nfat_arch = bfd_getb32 (buf + 4);
1831   if (adata->magic != 0xcafebabe)
1832     goto error;
1833
1834   adata->archentries = (mach_o_fat_archentry *)
1835     bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
1836   if (adata->archentries == NULL)
1837     goto error;
1838
1839   for (i = 0; i < adata->nfat_arch; i++)
1840     {
1841       bfd_seek (abfd, 8 + 20 * i, SEEK_SET);
1842
1843       if (bfd_bread ((PTR) buf, 20, abfd) != 20)
1844         goto error;
1845       adata->archentries[i].cputype = bfd_getb32 (buf);
1846       adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
1847       adata->archentries[i].offset = bfd_getb32 (buf + 8);
1848       adata->archentries[i].size = bfd_getb32 (buf + 12);
1849       adata->archentries[i].align = bfd_getb32 (buf + 16);
1850       adata->archentries[i].abfd = NULL;
1851     }
1852
1853   abfd->tdata.mach_o_fat_data = adata;
1854   return abfd->xvec;
1855
1856  error:
1857   if (adata != NULL)
1858     bfd_release (abfd, adata);
1859   bfd_set_error (bfd_error_wrong_format);
1860   return NULL;
1861 }
1862
1863 bfd *
1864 bfd_mach_o_openr_next_archived_file (archive, prev)
1865   bfd *archive;
1866   bfd *prev;
1867 {
1868   mach_o_fat_data_struct *adata;
1869   mach_o_fat_archentry *entry = NULL;
1870   unsigned long i;
1871
1872   adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
1873   BFD_ASSERT (adata != NULL);
1874
1875   /* Find index of previous entry.  */
1876   if (prev == NULL)
1877     i = 0;      /* Start at first one.  */
1878   else
1879     {
1880       for (i = 0; i < adata->nfat_arch; i++)
1881         {
1882           if (adata->archentries[i].abfd == prev)
1883             break;
1884         }
1885
1886       if (i == adata->nfat_arch)
1887         {
1888           /* Not found.  */
1889           bfd_set_error (bfd_error_bad_value);
1890           return NULL;
1891         }
1892     i++;        /* Get next entry.  */
1893   }
1894
1895   if (i >= adata->nfat_arch)
1896     {
1897       bfd_set_error (bfd_error_no_more_archived_files);
1898       return NULL;
1899     }
1900
1901   entry = &adata->archentries[i];
1902   if (entry->abfd == NULL)
1903     {
1904       bfd *nbfd = _bfd_new_bfd_contained_in (archive);
1905       char *s = NULL;
1906
1907       if (nbfd == NULL)
1908         return NULL;
1909
1910       nbfd->origin = entry->offset;
1911       s = bfd_malloc (strlen (archive->filename) + 1);
1912       if (s == NULL)
1913         return NULL;
1914       strcpy (s, archive->filename);
1915       nbfd->filename = s;
1916       nbfd->iostream = NULL;
1917       entry->abfd = nbfd;
1918     }
1919
1920   return entry->abfd;
1921 }
1922
1923 int
1924 bfd_mach_o_lookup_section (abfd, section, mcommand, msection)
1925      bfd *abfd;
1926      asection *section;
1927      bfd_mach_o_load_command **mcommand;
1928      bfd_mach_o_section **msection;
1929 {
1930   struct mach_o_data_struct *md = abfd->tdata.mach_o_data;
1931   unsigned int i, j, num;
1932
1933   bfd_mach_o_load_command *ncmd = NULL;
1934   bfd_mach_o_section *nsect = NULL;
1935
1936   BFD_ASSERT (mcommand != NULL);
1937   BFD_ASSERT (msection != NULL);
1938
1939   num = 0;
1940   for (i = 0; i < md->header.ncmds; i++)
1941     {
1942       struct bfd_mach_o_load_command *cmd = &md->commands[i];
1943       struct bfd_mach_o_segment_command *seg = NULL;
1944
1945       if (cmd->type != BFD_MACH_O_LC_SEGMENT)
1946         continue;
1947       seg = &cmd->command.segment;
1948
1949       if (seg->segment == section)
1950         {
1951           if (num == 0)
1952             ncmd = cmd;
1953           num++;
1954         }
1955
1956       for (j = 0; j < seg->nsects; j++)
1957         {
1958           struct bfd_mach_o_section *sect = &seg->sections[j];
1959
1960           if (sect->bfdsection == section)
1961             {
1962               if (num == 0)
1963                 nsect = sect;
1964               num++;
1965             }
1966         }
1967     }
1968
1969   *mcommand = ncmd;
1970   *msection = nsect;
1971   return num;
1972 }
1973
1974 int
1975 bfd_mach_o_lookup_command (abfd, type, mcommand)
1976      bfd *abfd;
1977      bfd_mach_o_load_command_type type;
1978      bfd_mach_o_load_command **mcommand;
1979 {
1980   struct mach_o_data_struct *md = NULL;
1981   bfd_mach_o_load_command *ncmd = NULL;
1982   unsigned int i, num;
1983
1984   md = abfd->tdata.mach_o_data;
1985
1986   BFD_ASSERT (md != NULL);
1987   BFD_ASSERT (mcommand != NULL);
1988
1989   num = 0;
1990   for (i = 0; i < md->header.ncmds; i++)
1991     {
1992       struct bfd_mach_o_load_command *cmd = &md->commands[i];
1993
1994       if (cmd->type != type)
1995         continue;
1996
1997       if (num == 0)
1998         ncmd = cmd;
1999       num++;
2000     }
2001
2002   *mcommand = ncmd;
2003   return num;
2004 }
2005
2006 unsigned long
2007 bfd_mach_o_stack_addr (type)
2008      enum bfd_mach_o_cpu_type type;
2009 {
2010   switch (type)
2011     {
2012     case BFD_MACH_O_CPU_TYPE_MC680x0:
2013       return 0x04000000;
2014     case BFD_MACH_O_CPU_TYPE_MC88000:
2015       return 0xffffe000;
2016     case BFD_MACH_O_CPU_TYPE_POWERPC:
2017       return 0xc0000000;
2018     case BFD_MACH_O_CPU_TYPE_I386:
2019       return 0xc0000000;
2020     case BFD_MACH_O_CPU_TYPE_SPARC:
2021       return 0xf0000000;
2022     case BFD_MACH_O_CPU_TYPE_I860:
2023       return 0;
2024     case BFD_MACH_O_CPU_TYPE_HPPA:
2025       return 0xc0000000 - 0x04000000;
2026     default:
2027       return 0;
2028     }
2029 }
2030
2031 int
2032 bfd_mach_o_core_fetch_environment (abfd, rbuf, rlen)
2033      bfd *abfd;
2034      unsigned char **rbuf;
2035      unsigned int *rlen;
2036 {
2037   bfd_mach_o_data_struct *mdata = abfd->tdata.mach_o_data;
2038   unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
2039   unsigned int i = 0;
2040
2041   for (i = 0; i < mdata->header.ncmds; i++)
2042     {
2043       bfd_mach_o_load_command *cur = &mdata->commands[i];
2044       bfd_mach_o_segment_command *seg = NULL;
2045
2046       if (cur->type != BFD_MACH_O_LC_SEGMENT)
2047         continue;
2048
2049       seg = &cur->command.segment;
2050
2051       if ((seg->vmaddr + seg->vmsize) == stackaddr)
2052         {
2053           unsigned long start = seg->fileoff;
2054           unsigned long end = seg->fileoff + seg->filesize;
2055           unsigned char *buf = bfd_malloc (1024);
2056           unsigned long size = 1024;
2057
2058           for (;;)
2059             {
2060               bfd_size_type nread = 0;
2061               unsigned long offset;
2062               int found_nonnull = 0;
2063
2064               if (size > (end - start))
2065                 size = (end - start);
2066
2067               buf = bfd_realloc (buf, size);
2068
2069               bfd_seek (abfd, end - size, SEEK_SET);
2070               nread = bfd_bread (buf, size, abfd);
2071
2072               if (nread != size)
2073                 return -1;
2074
2075               for (offset = 4; offset <= size; offset += 4)
2076                 {
2077                   unsigned long val;
2078
2079                   val = *((unsigned long *) (buf + size - offset));
2080                   if (! found_nonnull)
2081                     {
2082                       if (val != 0)
2083                         found_nonnull = 1;
2084                     }
2085                   else if (val == 0x0)
2086                     {
2087                       unsigned long bottom;
2088                       unsigned long top;
2089
2090                       bottom = seg->fileoff + seg->filesize - offset;
2091                       top = seg->fileoff + seg->filesize - 4;
2092                       *rbuf = bfd_malloc (top - bottom);
2093                       *rlen = top - bottom;
2094
2095                       memcpy (*rbuf, buf + size - *rlen, *rlen);
2096                       return 0;
2097                     }
2098                 }
2099
2100               if (size == (end - start))
2101                 break;
2102
2103               size *= 2;
2104             }
2105         }
2106     }
2107
2108   return -1;
2109 }
2110
2111 char *
2112 bfd_mach_o_core_file_failing_command (abfd)
2113      bfd *abfd;
2114 {
2115   unsigned char *buf = NULL;
2116   unsigned int len = 0;
2117   int ret = -1;
2118
2119   ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
2120   if (ret < 0)
2121     return NULL;
2122
2123   return (char *) buf;
2124 }
2125
2126 int
2127 bfd_mach_o_core_file_failing_signal (abfd)
2128      bfd *abfd ATTRIBUTE_UNUSED;
2129 {
2130   return 0;
2131 }
2132
2133 bfd_boolean
2134 bfd_mach_o_core_file_matches_executable_p (core_bfd, exec_bfd)
2135      bfd *core_bfd ATTRIBUTE_UNUSED;
2136      bfd *exec_bfd ATTRIBUTE_UNUSED;
2137 {
2138   return TRUE;
2139 }
2140
2141 #define TARGET_NAME mach_o_be_vec
2142 #define TARGET_STRING "mach-o-be"
2143 #define TARGET_BIG_ENDIAN 1
2144 #define TARGET_ARCHIVE 0
2145
2146 #include "mach-o-target.c"
2147
2148 #undef TARGET_NAME
2149 #undef TARGET_STRING
2150 #undef TARGET_BIG_ENDIAN
2151 #undef TARGET_ARCHIVE
2152
2153 #define TARGET_NAME mach_o_le_vec
2154 #define TARGET_STRING "mach-o-le"
2155 #define TARGET_BIG_ENDIAN 0
2156 #define TARGET_ARCHIVE 0
2157
2158 #include "mach-o-target.c"
2159
2160 #undef TARGET_NAME
2161 #undef TARGET_STRING
2162 #undef TARGET_BIG_ENDIAN
2163 #undef TARGET_ARCHIVE
2164
2165 #define TARGET_NAME mach_o_fat_vec
2166 #define TARGET_STRING "mach-o-fat"
2167 #define TARGET_BIG_ENDIAN 1
2168 #define TARGET_ARCHIVE 1
2169
2170 #include "mach-o-target.c"
2171
2172 #undef TARGET_NAME
2173 #undef TARGET_STRING
2174 #undef TARGET_BIG_ENDIAN
2175 #undef TARGET_ARCHIVE